Home | History | Annotate | Download | only in sandbox_poc 
      1 // Copyright (c) 2006-2010 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include <windows.h>
      6 #include <CommCtrl.h>
      7 #include <commdlg.h>
      8 #include <time.h>
      9 #include <windowsx.h>
     10 #include <atlbase.h>
     11 #include <atlsecurity.h>
     12 #include <algorithm>
     13 #include <sstream>
     14 
     15 #include "sandbox/win/sandbox_poc/main_ui_window.h"
     16 #include "base/logging.h"
     17 #include "sandbox/win/sandbox_poc/resource.h"
     18 #include "sandbox/win/src/acl.h"
     19 #include "sandbox/win/src/sandbox.h"
     20 #include "sandbox/win/src/win_utils.h"
     21 
     22 HWND MainUIWindow::list_view_ = NULL;
     23 
     24 const wchar_t MainUIWindow::kDefaultDll_[]        = L"\\POCDLL.dll";
     25 const wchar_t MainUIWindow::kDefaultEntryPoint_[] = L"Run";
     26 const wchar_t MainUIWindow::kDefaultLogFile_[]    = L"";
     27 
     28 MainUIWindow::MainUIWindow()
     29     : instance_handle_(NULL),
     30       spawn_target_(L""),
     31       dll_path_(L""),
     32       entry_point_(L""),
     33       broker_(NULL) {
     34 }
     35 
     36 MainUIWindow::~MainUIWindow() {
     37 }
     38 
     39 unsigned int MainUIWindow::CreateMainWindowAndLoop(
     40     HINSTANCE instance,
     41     wchar_t* command_line,
     42     int show_command,
     43     sandbox::BrokerServices* broker) {
     44   DCHECK(instance);
     45   DCHECK(command_line);
     46   DCHECK(broker);
     47 
     48   instance_handle_ = instance;
     49   spawn_target_ = command_line;
     50   broker_ = broker;
     51 
     52   // We'll use spawn_target_ later for creating a child process, but
     53   // CreateProcess doesn't like double quotes, so we remove them along with
     54   // tabs and spaces from the start and end of the string
     55   const wchar_t *trim_removal = L" \r\t\"";
     56   spawn_target_.erase(0, spawn_target_.find_first_not_of(trim_removal));
     57   spawn_target_.erase(spawn_target_.find_last_not_of(trim_removal) + 1);
     58 
     59   WNDCLASSEX window_class = {0};
     60   window_class.cbSize        = sizeof(WNDCLASSEX);
     61   window_class.style         = CS_HREDRAW | CS_VREDRAW;
     62   window_class.lpfnWndProc   = MainUIWindow::WndProc;
     63   window_class.cbClsExtra    = 0;
     64   window_class.cbWndExtra    = 0;
     65   window_class.hInstance     = instance;
     66   window_class.hIcon         =
     67       ::LoadIcon(instance, MAKEINTRESOURCE(IDI_SANDBOX));
     68   window_class.hCursor       = ::LoadCursor(NULL, IDC_ARROW);
     69   window_class.hbrBackground = GetStockBrush(WHITE_BRUSH);
     70   window_class.lpszMenuName  = MAKEINTRESOURCE(IDR_MENU_MAIN_UI);
     71   window_class.lpszClassName = L"sandbox_ui_1";
     72   window_class.hIconSm       = NULL;
     73 
     74   INITCOMMONCONTROLSEX controls = {
     75     sizeof(INITCOMMONCONTROLSEX),
     76     ICC_STANDARD_CLASSES | ICC_LISTVIEW_CLASSES
     77   };
     78   ::InitCommonControlsEx(&controls);
     79 
     80   if (!::RegisterClassEx(&window_class))
     81     return ::GetLastError();
     82 
     83   // Create a main window of size 600x400
     84   HWND window = ::CreateWindowW(window_class.lpszClassName,
     85                                 L"",            // window name
     86                                 WS_OVERLAPPEDWINDOW,
     87                                 CW_USEDEFAULT,  // x
     88                                 CW_USEDEFAULT,  // y
     89                                 600,            // width
     90                                 400,            // height
     91                                 NULL,           // parent
     92                                 NULL,           // NULL = use class menu
     93                                 instance,
     94                                 0);             // lpParam
     95 
     96   if (NULL == window)
     97     return ::GetLastError();
     98 
     99   ::SetWindowLongPtr(window,
    100                      GWLP_USERDATA,
    101                      reinterpret_cast<LONG_PTR>(this));
    102 
    103   ::SetWindowText(window, L"Sandbox Proof of Concept");
    104 
    105   ::ShowWindow(window, show_command);
    106 
    107   MSG message;
    108   // Now lets start the message pump retrieving messages for any window that
    109   // belongs to the current thread
    110   while (::GetMessage(&message, NULL, 0, 0)) {
    111     ::TranslateMessage(&message);
    112     ::DispatchMessage(&message);
    113   }
    114 
    115   return 0;
    116 }
    117 
    118 LRESULT CALLBACK MainUIWindow::WndProc(HWND window,
    119                                        UINT message_id,
    120                                        WPARAM wparam,
    121                                        LPARAM lparam) {
    122   MainUIWindow* host = FromWindow(window);
    123 
    124   #define HANDLE_MSG(hwnd, message, fn)    \
    125     case (message): return HANDLE_##message((hwnd), (wParam), (lParam), (fn))
    126 
    127   switch (message_id) {
    128     case WM_CREATE:
    129       // 'host' is not yet available when we get the WM_CREATE message
    130       return HANDLE_WM_CREATE(window, wparam, lparam, OnCreate);
    131     case WM_DESTROY:
    132       return HANDLE_WM_DESTROY(window, wparam, lparam, host->OnDestroy);
    133     case WM_SIZE:
    134       return HANDLE_WM_SIZE(window, wparam, lparam, host->OnSize);
    135     case WM_COMMAND: {
    136       // Look at which menu item was clicked on (or which accelerator)
    137       int id = LOWORD(wparam);
    138       switch (id) {
    139         case ID_FILE_EXIT:
    140           host->OnFileExit();
    141           break;
    142         case ID_COMMANDS_SPAWNTARGET:
    143           host->OnCommandsLaunch(window);
    144           break;
    145         default:
    146           // Some other menu item or accelerator
    147           break;
    148       }
    149 
    150       return ERROR_SUCCESS;
    151     }
    152 
    153     default:
    154       // Some other WM_message, let it pass to DefWndProc
    155       break;
    156   }
    157 
    158   return DefWindowProc(window, message_id, wparam, lparam);
    159 }
    160 
    161 INT_PTR CALLBACK MainUIWindow::SpawnTargetWndProc(HWND dialog,
    162                                                   UINT message_id,
    163                                                   WPARAM wparam,
    164                                                   LPARAM lparam) {
    165   UNREFERENCED_PARAMETER(lparam);
    166 
    167   // Grab a reference to the main UI window (from the window handle)
    168   MainUIWindow* host = FromWindow(GetParent(dialog));
    169   DCHECK(host);
    170 
    171   switch (message_id) {
    172     case WM_INITDIALOG: {
    173       // Initialize the window text for DLL name edit box
    174       HWND edit_box_dll_name = ::GetDlgItem(dialog, IDC_DLL_NAME);
    175       wchar_t current_dir[MAX_PATH];
    176       if (GetCurrentDirectory(MAX_PATH, current_dir)) {
    177         std::wstring dll_path = std::wstring(current_dir) +
    178                                 std::wstring(kDefaultDll_);
    179         ::SetWindowText(edit_box_dll_name, dll_path.c_str());
    180       }
    181 
    182       // Initialize the window text for Entry Point edit box
    183       HWND edit_box_entry_point = ::GetDlgItem(dialog, IDC_ENTRY_POINT);
    184       ::SetWindowText(edit_box_entry_point, kDefaultEntryPoint_);
    185 
    186       // Initialize the window text for Log File edit box
    187       HWND edit_box_log_file = ::GetDlgItem(dialog, IDC_LOG_FILE);
    188       ::SetWindowText(edit_box_log_file, kDefaultLogFile_);
    189 
    190       return static_cast<INT_PTR>(TRUE);
    191     }
    192     case WM_COMMAND:
    193       // If the user presses the OK button (Launch)
    194       if (LOWORD(wparam) == IDOK) {
    195         if (host->OnLaunchDll(dialog)) {
    196           if (host->SpawnTarget()) {
    197             ::EndDialog(dialog, LOWORD(wparam));
    198           }
    199         }
    200         return static_cast<INT_PTR>(TRUE);
    201       } else if (LOWORD(wparam) == IDCANCEL) {
    202         // If the user presses the Cancel button
    203         ::EndDialog(dialog, LOWORD(wparam));
    204         return static_cast<INT_PTR>(TRUE);
    205       } else if (LOWORD(wparam) == IDC_BROWSE_DLL) {
    206         // If the user presses the Browse button to look for a DLL
    207         std::wstring dll_path = host->OnShowBrowseForDllDlg(dialog);
    208         if (dll_path.length() > 0) {
    209           // Initialize the window text for Log File edit box
    210           HWND edit_box_dll_path = ::GetDlgItem(dialog, IDC_DLL_NAME);
    211           ::SetWindowText(edit_box_dll_path, dll_path.c_str());
    212         }
    213         return static_cast<INT_PTR>(TRUE);
    214       } else if (LOWORD(wparam) == IDC_BROWSE_LOG) {
    215         // If the user presses the Browse button to look for a log file
    216         std::wstring log_path = host->OnShowBrowseForLogFileDlg(dialog);
    217         if (log_path.length() > 0) {
    218           // Initialize the window text for Log File edit box
    219           HWND edit_box_log_file = ::GetDlgItem(dialog, IDC_LOG_FILE);
    220           ::SetWindowText(edit_box_log_file, log_path.c_str());
    221         }
    222         return static_cast<INT_PTR>(TRUE);
    223       }
    224 
    225       break;
    226   }
    227 
    228   return static_cast<INT_PTR>(FALSE);
    229 }
    230 
    231 MainUIWindow* MainUIWindow::FromWindow(HWND main_window) {
    232   // We store a 'this' pointer using SetWindowLong in CreateMainWindowAndLoop
    233   // so that we can retrieve it with this function later. This prevents us
    234   // from having to define all the message handling functions (that we refer to
    235   // in the window proc) as static
    236   ::GetWindowLongPtr(main_window, GWLP_USERDATA);
    237   return reinterpret_cast<MainUIWindow*>(
    238       ::GetWindowLongPtr(main_window, GWLP_USERDATA));
    239 }
    240 
    241 BOOL MainUIWindow::OnCreate(HWND parent_window, LPCREATESTRUCT) {
    242   // Create the listview that will the main app UI
    243   list_view_ = ::CreateWindow(WC_LISTVIEW,    // Class name
    244                               L"",            // Window name
    245                               WS_CHILD | WS_VISIBLE | LVS_REPORT |
    246                               LVS_NOCOLUMNHEADER | WS_BORDER,
    247                               0,              // x
    248                               0,              // y
    249                               0,              // width
    250                               0,              // height
    251                               parent_window,  // parent
    252                               NULL,           // menu
    253                               ::GetModuleHandle(NULL),
    254                               0);             // lpParam
    255 
    256   DCHECK(list_view_);
    257   if (!list_view_)
    258     return FALSE;
    259 
    260   LVCOLUMN list_view_column = {0};
    261   list_view_column.mask = LVCF_FMT | LVCF_WIDTH ;
    262   list_view_column.fmt = LVCFMT_LEFT;
    263   list_view_column.cx = 10000;  // Maximum size of an entry in the list view.
    264   ListView_InsertColumn(list_view_, 0, &list_view_column);
    265 
    266   // Set list view to show green font on black background
    267   ListView_SetBkColor(list_view_, CLR_NONE);
    268   ListView_SetTextColor(list_view_, RGB(0x0, 0x0, 0x0));
    269   ListView_SetTextBkColor(list_view_, CLR_NONE);
    270 
    271   return TRUE;
    272 }
    273 
    274 void MainUIWindow::OnDestroy(HWND window) {
    275   UNREFERENCED_PARAMETER(window);
    276 
    277   // Post a quit message because our application is over when the
    278   // user closes this window.
    279   ::PostQuitMessage(0);
    280 }
    281 
    282 void MainUIWindow::OnSize(HWND window, UINT state, int cx, int cy) {
    283   UNREFERENCED_PARAMETER(window);
    284   UNREFERENCED_PARAMETER(state);
    285 
    286   // If we have a valid inner child, resize it to cover the entire
    287   // client area of the main UI window.
    288   if (list_view_) {
    289     ::MoveWindow(list_view_,
    290                  0,      // x
    291                  0,      // y
    292                  cx,     // width
    293                  cy,     // height
    294                  TRUE);  // repaint
    295   }
    296 }
    297 
    298 void MainUIWindow::OnPaint(HWND window) {
    299   PAINTSTRUCT paintstruct;
    300   ::BeginPaint(window, &paintstruct);
    301   // add painting code here if required
    302   ::EndPaint(window, &paintstruct);
    303 }
    304 
    305 void MainUIWindow::OnFileExit() {
    306   ::PostQuitMessage(0);
    307 }
    308 
    309 void MainUIWindow::OnCommandsLaunch(HWND window) {
    310   // User wants to see the Select DLL dialog box
    311   ::DialogBox(instance_handle_,
    312               MAKEINTRESOURCE(IDD_LAUNCH_DLL),
    313               window,
    314               SpawnTargetWndProc);
    315 }
    316 
    317 bool MainUIWindow::OnLaunchDll(HWND dialog) {
    318   HWND edit_box_dll_name = ::GetDlgItem(dialog, IDC_DLL_NAME);
    319   HWND edit_box_entry_point = ::GetDlgItem(dialog, IDC_ENTRY_POINT);
    320   HWND edit_log_file = ::GetDlgItem(dialog, IDC_LOG_FILE);
    321 
    322   wchar_t dll_path[MAX_PATH];
    323   wchar_t entry_point[MAX_PATH];
    324   wchar_t log_file[MAX_PATH];
    325 
    326   int dll_name_len    = ::GetWindowText(edit_box_dll_name, dll_path, MAX_PATH);
    327   int entry_point_len = ::GetWindowText(edit_box_entry_point,
    328                                         entry_point, MAX_PATH);
    329   // Log file is optional (can be blank)
    330   ::GetWindowText(edit_log_file, log_file, MAX_PATH);
    331 
    332   if (0 >= dll_name_len) {
    333     ::MessageBox(dialog,
    334                  L"Please specify a DLL for the target to load",
    335                  L"No DLL specified",
    336                  MB_ICONERROR);
    337     return false;
    338   }
    339 
    340   if (GetFileAttributes(dll_path) == INVALID_FILE_ATTRIBUTES) {
    341     ::MessageBox(dialog,
    342                  L"DLL specified was not found",
    343                  L"DLL not found",
    344                  MB_ICONERROR);
    345     return false;
    346   }
    347 
    348   if (0 >= entry_point_len) {
    349     ::MessageBox(dialog,
    350                  L"Please specify an entry point for the DLL",
    351                  L"No entry point specified",
    352                  MB_ICONERROR);
    353     return false;
    354   }
    355 
    356   // store these values in the member variables for use in SpawnTarget
    357   log_file_ = std::wstring(L"\"") + log_file + std::wstring(L"\"");
    358   dll_path_ = dll_path;
    359   entry_point_ = entry_point;
    360 
    361   return true;
    362 }
    363 
    364 DWORD WINAPI MainUIWindow::ListenPipeThunk(void *param) {
    365   return reinterpret_cast<MainUIWindow*>(param)->ListenPipe();
    366 }
    367 
    368 DWORD WINAPI MainUIWindow::WaitForTargetThunk(void *param) {
    369   return reinterpret_cast<MainUIWindow*>(param)->WaitForTarget();
    370 }
    371 
    372 // Thread waiting for the target application to die. It displays
    373 // a message in the list view when it happens.
    374 DWORD MainUIWindow::WaitForTarget() {
    375   WaitForSingleObject(target_.hProcess, INFINITE);
    376 
    377   DWORD exit_code = 0;
    378   if (!GetExitCodeProcess(target_.hProcess, &exit_code)) {
    379     exit_code = 0xFFFF;  // Default exit code
    380   }
    381 
    382   ::CloseHandle(target_.hProcess);
    383   ::CloseHandle(target_.hThread);
    384 
    385   AddDebugMessage(L"Targed exited with return code %d", exit_code);
    386   return 0;
    387 }
    388 
    389 // Thread waiting for messages on the log pipe. It displays the messages
    390 // in the listview.
    391 DWORD MainUIWindow::ListenPipe() {
    392   HANDLE logfile_handle = NULL;
    393   ATL::CString file_to_open = log_file_.c_str();
    394   file_to_open.Remove(L'\"');
    395   if (file_to_open.GetLength()) {
    396     logfile_handle = ::CreateFile(file_to_open.GetBuffer(),
    397                                   GENERIC_WRITE,
    398                                   FILE_SHARE_READ | FILE_SHARE_WRITE,
    399                                   NULL,  // Default security attributes
    400                                   CREATE_ALWAYS,
    401                                   FILE_ATTRIBUTE_NORMAL,
    402                                   NULL);  // No template
    403     if (INVALID_HANDLE_VALUE == logfile_handle) {
    404       AddDebugMessage(L"Failed to open \"%ls\" for logging. Error %d",
    405                       file_to_open.GetBuffer(), ::GetLastError());
    406       logfile_handle = NULL;
    407     }
    408   }
    409 
    410   const int kSizeBuffer = 1024;
    411   BYTE read_buffer[kSizeBuffer] = {0};
    412   ATL::CStringA read_buffer_global;
    413   ATL::CStringA string_to_print;
    414 
    415   DWORD last_error = 0;
    416   while(last_error == ERROR_SUCCESS || last_error == ERROR_PIPE_LISTENING ||
    417         last_error == ERROR_NO_DATA)
    418   {
    419     DWORD read_data_length;
    420     if (::ReadFile(pipe_handle_,
    421                   read_buffer,
    422                   kSizeBuffer - 1,  // Max read size
    423                   &read_data_length,
    424                   NULL)) {  // Not overlapped
    425       if (logfile_handle) {
    426         DWORD write_data_length;
    427         ::WriteFile(logfile_handle,
    428                     read_buffer,
    429                     read_data_length,
    430                     &write_data_length,
    431                     FALSE);  // Not overlapped
    432       }
    433 
    434       // Append the new buffer to the current buffer
    435       read_buffer[read_data_length] = NULL;
    436       read_buffer_global += reinterpret_cast<char *>(read_buffer);
    437       read_buffer_global.Remove(10);  // Remove the CRs
    438 
    439       // If we completed a new line, output it
    440       int endline = read_buffer_global.Find(13);  // search for LF
    441       while (-1 != endline) {
    442         string_to_print = read_buffer_global;
    443         string_to_print.Delete(endline, string_to_print.GetLength());
    444         read_buffer_global.Delete(0, endline);
    445 
    446         //  print the line (with the ending LF)
    447         OutputDebugStringA(string_to_print.GetBuffer());
    448 
    449         // Remove the ending LF
    450         read_buffer_global.Delete(0, 1);
    451 
    452         // Add the line to the log
    453         AddDebugMessage(L"%S", string_to_print.GetBuffer());
    454 
    455         endline = read_buffer_global.Find(13);
    456       }
    457       last_error = ERROR_SUCCESS;
    458     } else {
    459       last_error = GetLastError();
    460       Sleep(100);
    461     }
    462   }
    463 
    464   if (read_buffer_global.GetLength()) {
    465     AddDebugMessage(L"%S", read_buffer_global.GetBuffer());
    466   }
    467 
    468   CloseHandle(pipe_handle_);
    469 
    470   if (logfile_handle) {
    471     CloseHandle(logfile_handle);
    472   }
    473 
    474   return 0;
    475 }
    476 
    477 bool MainUIWindow::SpawnTarget() {
    478   // Generate the pipe name
    479   GUID random_id;
    480   CoCreateGuid(&random_id);
    481 
    482   wchar_t log_pipe[MAX_PATH] = {0};
    483   wnsprintf(log_pipe, MAX_PATH - 1,
    484             L"\\\\.\\pipe\\sbox_pipe_log_%lu_%lu_%lu_%lu",
    485             random_id.Data1,
    486             random_id.Data2,
    487             random_id.Data3,
    488             random_id.Data4);
    489 
    490   // We concatenate the four strings, add three spaces and a zero termination
    491   // We use the resulting string as a param to CreateProcess (in SpawnTarget)
    492   // Documented maximum for command line in CreateProcess is 32K (msdn)
    493   size_t size_call = spawn_target_.length() + entry_point_.length() +
    494                   dll_path_.length() + wcslen(log_pipe) + 6;
    495   if (32 * 1024 < (size_call * sizeof(wchar_t))) {
    496     AddDebugMessage(L"The length of the arguments exceeded 32K. "
    497                     L"Aborting operation.");
    498     return false;
    499   }
    500 
    501   wchar_t * arguments = new wchar_t[size_call];
    502   wnsprintf(arguments, static_cast<int>(size_call), L"%ls %ls \"%ls\" %ls",
    503             spawn_target_.c_str(), entry_point_.c_str(),
    504             dll_path_.c_str(), log_pipe);
    505 
    506   arguments[size_call - 1] = L'\0';
    507 
    508   sandbox::TargetPolicy* policy = broker_->CreatePolicy();
    509   policy->SetJobLevel(sandbox::JOB_LOCKDOWN, 0);
    510   policy->SetTokenLevel(sandbox::USER_RESTRICTED_SAME_ACCESS,
    511                         sandbox::USER_LOCKDOWN);
    512   policy->SetAlternateDesktop(true);
    513   policy->SetDelayedIntegrityLevel(sandbox::INTEGRITY_LEVEL_LOW);
    514 
    515   // Set the rule to allow the POC dll to be loaded by the target. Note that
    516   // the rule allows 'all access' to the DLL, which could mean that the target
    517   // could modify the DLL on disk.
    518   policy->AddRule(sandbox::TargetPolicy::SUBSYS_FILES,
    519                   sandbox::TargetPolicy::FILES_ALLOW_ANY, dll_path_.c_str());
    520 
    521   sandbox::ResultCode result = broker_->SpawnTarget(spawn_target_.c_str(),
    522                                                     arguments, policy,
    523                                                     &target_);
    524 
    525   policy->Release();
    526   policy = NULL;
    527 
    528   bool return_value = false;
    529   if (sandbox::SBOX_ALL_OK != result) {
    530     AddDebugMessage(
    531         L"Failed to spawn target %ls w/args (%ls), sandbox error code: %d",
    532         spawn_target_.c_str(), arguments, result);
    533     return_value = false;
    534   } else {
    535 
    536     DWORD thread_id;
    537     ::CreateThread(NULL,  // Default security attributes
    538                    NULL,  // Default stack size
    539                    &MainUIWindow::WaitForTargetThunk,
    540                    this,
    541                    0,  // No flags
    542                    &thread_id);
    543 
    544     pipe_handle_ = ::CreateNamedPipe(log_pipe,
    545                                      PIPE_ACCESS_INBOUND | WRITE_DAC,
    546                                      PIPE_TYPE_MESSAGE | PIPE_NOWAIT,
    547                                      1,  // Number of instances.
    548                                      512,  // Out buffer size.
    549                                      512,  // In buffer size.
    550                                      NMPWAIT_USE_DEFAULT_WAIT,
    551                                      NULL);  // Default security descriptor
    552 
    553     if (INVALID_HANDLE_VALUE == pipe_handle_)
    554       AddDebugMessage(L"Failed to create pipe. Error %d", ::GetLastError());
    555 
    556     if (!sandbox::AddKnownSidToKernelObject(pipe_handle_, WinWorldSid,
    557                                             FILE_ALL_ACCESS))
    558       AddDebugMessage(L"Failed to set security on pipe. Error %d",
    559                       ::GetLastError());
    560 
    561     ::CreateThread(NULL,  // Default security attributes
    562                    NULL,  // Default stack size
    563                    &MainUIWindow::ListenPipeThunk,
    564                    this,
    565                    0,  // No flags
    566                    &thread_id);
    567 
    568     ::ResumeThread(target_.hThread);
    569 
    570     AddDebugMessage(L"Successfully spawned target w/args (%ls)", arguments);
    571     return_value = true;
    572   }
    573 
    574   delete[] arguments;
    575   return return_value;
    576 }
    577 
    578 std::wstring MainUIWindow::OnShowBrowseForDllDlg(HWND owner) {
    579   wchar_t filename[MAX_PATH];
    580   wcscpy_s(filename, MAX_PATH, L"");
    581 
    582   OPENFILENAMEW file_info = {0};
    583   file_info.lStructSize = sizeof(file_info);
    584   file_info.hwndOwner = owner;
    585   file_info.lpstrFile = filename;
    586   file_info.nMaxFile = MAX_PATH;
    587   file_info.lpstrFilter = L"DLL files (*.dll)\0*.dll\0All files\0*.*\0\0\0";
    588 
    589   file_info.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST;
    590 
    591   if (GetOpenFileName(&file_info)) {
    592     return file_info.lpstrFile;
    593   }
    594 
    595   return L"";
    596 }
    597 
    598 std::wstring MainUIWindow::OnShowBrowseForLogFileDlg(HWND owner) {
    599   wchar_t filename[MAX_PATH];
    600   wcscpy_s(filename, MAX_PATH, L"");
    601 
    602   OPENFILENAMEW file_info = {0};
    603   file_info.lStructSize = sizeof(file_info);
    604   file_info.hwndOwner = owner;
    605   file_info.lpstrFile = filename;
    606   file_info.nMaxFile = MAX_PATH;
    607   file_info.lpstrFilter = L"Log file (*.txt)\0*.txt\0All files\0*.*\0\0\0";
    608 
    609   file_info.Flags = OFN_OVERWRITEPROMPT | OFN_PATHMUSTEXIST;
    610 
    611   if (GetSaveFileName(&file_info)) {
    612     return file_info.lpstrFile;
    613   }
    614 
    615   return L"";
    616 }
    617 
    618 void MainUIWindow::AddDebugMessage(const wchar_t* format, ...) {
    619   DCHECK(format);
    620   if (!format)
    621     return;
    622 
    623   const int kMaxDebugBuffSize = 1024;
    624 
    625   va_list arg_list;
    626   _crt_va_start(arg_list, format);
    627 
    628   wchar_t text[kMaxDebugBuffSize + 1];
    629   vswprintf_s(text, kMaxDebugBuffSize, format, arg_list);
    630   text[kMaxDebugBuffSize] = L'\0';
    631 
    632   InsertLineInListView(text);
    633 }
    634 
    635 
    636 void MainUIWindow::InsertLineInListView(wchar_t* debug_message) {
    637   DCHECK(debug_message);
    638   if (!debug_message)
    639     return;
    640 
    641   // Prepend the time to the message
    642   const int kSizeTime = 100;
    643   size_t size_message_with_time = wcslen(debug_message) + kSizeTime;
    644   wchar_t * message_time = new wchar_t[size_message_with_time];
    645 
    646   time_t time_temp;
    647   time_temp = time(NULL);
    648 
    649   struct tm time = {0};
    650   localtime_s(&time, &time_temp);
    651 
    652   size_t return_code;
    653   return_code = wcsftime(message_time, kSizeTime, L"[%H:%M:%S] ", &time);
    654 
    655   wcscat_s(message_time, size_message_with_time, debug_message);
    656 
    657   // We add the debug message to the top of the listview
    658   LVITEM item;
    659   item.iItem = ListView_GetItemCount(list_view_);
    660   item.iSubItem = 0;
    661   item.mask = LVIF_TEXT | LVIF_PARAM;
    662   item.pszText = message_time;
    663   item.lParam = 0;
    664 
    665   ListView_InsertItem(list_view_, &item);
    666 
    667   delete[] message_time;
    668 }
    669