/* * Copyright (c) 2005 Alexander Gottwald * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. * * Except as contained in this notice, the name(s) of the above copyright * holders shall not be used in advertising or otherwise to promote the sale, * use or other dealings in this Software without prior written authorization. */ #define SAVEPOSIX _POSIX_ #undef _POSIX_ #include #include #include #include #define _POSIX_ SAVEPOSIX #include "window/util.h" #include "window/wizard.h" #include "resources/resources.h" #include "config.h" #include #include #include #include #include /// @brief Send WM_ENDSESSION to all program windows. /// This will shutdown the started xserver BOOL CALLBACK KillWindowsProc(HWND hwnd, LPARAM lParam) { SendMessage(hwnd, WM_ENDSESSION, 0, 0); return TRUE; } /// @brief Actual wizard implementation. /// This is based on generic CWizard but handles the special dialogs class CMyWizard : public CWizard { public: private: CConfig config; /// Storage for config options. public: /// @brief Constructor. /// Set wizard pages. CMyWizard() : CWizard() { AddPage(IDD_DISPLAY, IDS_DISPLAY_TITLE, IDS_DISPLAY_SUBTITLE); AddPage(IDD_CLIENTS, IDS_CLIENTS_TITLE, IDS_CLIENTS_SUBTITLE); AddPage(IDD_PROGRAM, IDS_PROGRAM_TITLE, IDS_PROGRAM_SUBTITLE); AddPage(IDD_XDMCP, IDS_XDMCP_TITLE, IDS_XDMCP_SUBTITLE); //AddPage(IDD_FONTPATH, IDS_FONTPATH_TITLE, IDS_FONTPATH_SUBTITLE); AddPage(IDD_EXTRA, IDS_EXTRA_TITLE, IDS_EXTRA_SUBTITLE); AddPage(IDD_FINISH, IDS_FINISH_TITLE, IDS_FINISH_SUBTITLE); } virtual void LoadConfig(const char *filename) { try { config.Load(filename); } catch (std::runtime_error &e) { char Message[255]; sprintf(Message,"Failure: %s\n", e.what()); MessageBox(NULL,Message,"Exception",MB_OK); } } /// @brief Handle the PSN_WIZNEXT message. /// @param hwndDlg Handle to active page dialog. /// @param index Index of current page. /// @return TRUE if the message was handled. FALSE otherwise. virtual BOOL WizardNext(HWND hwndDlg, unsigned index) { #ifdef _DEBUG printf("%s %d\n", __FUNCTION__, index); #endif switch (PageID(index)) { case IDD_DISPLAY: // Check for select window mode if (IsDlgButtonChecked(hwndDlg, IDC_MULTIWINDOW)) config.window = CConfig::MultiWindow; else if (IsDlgButtonChecked(hwndDlg, IDC_FULLSCREEN)) config.window = CConfig::Fullscreen; else if (IsDlgButtonChecked(hwndDlg, IDC_WINDOWED)) config.window = CConfig::Windowed; else if (IsDlgButtonChecked(hwndDlg, IDC_NODECORATION)) config.window = CConfig::Nodecoration; else { SetWindowLong(hwndDlg, DWL_MSGRESULT, -1); return TRUE; } // Get selected display number { char buffer[512]; GetDlgItemText(hwndDlg, IDC_DISPLAY, buffer, 512); buffer[511] = 0; config.display = buffer; } // Check for valid input if (config.display.empty()) { MessageBox(hwndDlg,"Please fill in a display number.","Error",MB_OK); SetWindowLong(hwndDlg, DWL_MSGRESULT, -1); } else SetWindowLong(hwndDlg, DWL_MSGRESULT, IDD_CLIENTS); return TRUE; case IDD_CLIENTS: // Check for select client startup method if (IsDlgButtonChecked(hwndDlg, IDC_CLIENT)) { config.client = CConfig::StartProgram; SetWindowLong(hwndDlg, DWL_MSGRESULT, IDD_PROGRAM); } else if (IsDlgButtonChecked(hwndDlg, IDC_XDMCP)) { config.client = CConfig::XDMCP; SetWindowLong(hwndDlg, DWL_MSGRESULT, IDD_XDMCP); } else if (IsDlgButtonChecked(hwndDlg, IDC_CLIENT_NONE)) { config.client = CConfig::NoClient; SetWindowLong(hwndDlg, DWL_MSGRESULT, IDD_EXTRA); } else SetWindowLong(hwndDlg, DWL_MSGRESULT, -1); return TRUE; case IDD_PROGRAM: // Check wether local or remote client should be started if (IsDlgButtonChecked(hwndDlg, IDC_CLIENT_LOCAL)) config.local = true; else if (IsDlgButtonChecked(hwndDlg, IDC_CLIENT_REMOTE)) config.local = false; else { SetWindowLong(hwndDlg, DWL_MSGRESULT, -1); return TRUE; } // Read program, user and host name { char buffer[512]; GetDlgItemText(hwndDlg, IDC_CLIENT_USER, buffer, 512); buffer[511] = 0; config.user = buffer; GetDlgItemText(hwndDlg, IDC_CLIENT_HOST, buffer, 512); buffer[511] = 0; config.host = buffer; GetDlgItemText(hwndDlg, IDC_CLIENT_PROGRAM, buffer, 512); buffer[511] = 0; config.localprogram = buffer; GetDlgItemText(hwndDlg, IDC_CLIENT_REMOTEPROGRAM, buffer, 512); buffer[511] = 0; config.remoteprogram = buffer; GetDlgItemText(hwndDlg, IDC_CLIENT_PASSWORD, buffer, 512); buffer[511] = 0; config.remotepassword = buffer; GetDlgItemText(hwndDlg, IDC_CLIENT_PRIVATEKEY, buffer, 512); buffer[511] = 0; config.privatekey = buffer; } // Check for valid input if (!config.local && (config.host.empty() || config.localprogram.empty() || config.remoteprogram.empty())) SetWindowLong(hwndDlg, DWL_MSGRESULT, -1); else SetWindowLong(hwndDlg, DWL_MSGRESULT, IDD_EXTRA); return TRUE; case IDD_XDMCP: // Check for broadcast if (IsDlgButtonChecked(hwndDlg, IDC_XDMCP_BROADCAST)) config.broadcast = true; else if (IsDlgButtonChecked(hwndDlg, IDC_XDMCP_QUERY)) config.broadcast = false; else { SetWindowLong(hwndDlg, DWL_MSGRESULT, -1); return TRUE; } // Check for indirect mode if (IsDlgButtonChecked(hwndDlg, IDC_XDMCP_INDIRECT)) config.indirect = true; else config.indirect = false; // Read hostname { char buffer[512]; GetDlgItemText(hwndDlg, IDC_XDMCP_HOST, buffer, 512); buffer[511] = 0; config.xdmcp_host = buffer; } // Check for valid input if (!config.broadcast && config.xdmcp_host.empty()) SetWindowLong(hwndDlg, DWL_MSGRESULT, -1); else SetWindowLong(hwndDlg, DWL_MSGRESULT, IDD_EXTRA); if (IsDlgButtonChecked(hwndDlg, IDC_XDMCP_TERMINATE)) config.xdmcpterminate = true; else config.xdmcpterminate = false; return TRUE; case IDD_EXTRA: // check for clipboard if (IsDlgButtonChecked(hwndDlg, IDC_CLIPBOARD)) config.clipboard = true; else config.clipboard = false; // check for clipboard primary selection if (IsDlgButtonChecked(hwndDlg, IDC_CLIPBOARDPRIMARY)) config.clipboardprimary = true; else config.clipboardprimary = false; // check for wgl if (IsDlgButtonChecked(hwndDlg, IDC_WGL)) config.wgl = true; else config.wgl = false; // check for access control if (IsDlgButtonChecked(hwndDlg, IDC_DISABLEAC)) config.disableac = true; else config.disableac = false; // read parameters { char buffer[512]; GetDlgItemText(hwndDlg, IDC_EXTRA_PARAMS, buffer, 512); buffer[511] = 0; config.extra_params = buffer; } SetWindowLong(hwndDlg, DWL_MSGRESULT, IDD_FINISH); return TRUE; default: break; } return FALSE; } /// @brief Handle PSN_WIZFINISH message. /// @param hwndDlg Handle to active page dialog. /// @param index Index of current page. /// @return TRUE if the message was handled. FALSE otherwise. virtual BOOL WizardFinish(HWND hwndDlg, unsigned index) { #ifdef _DEBUG printf("finish %d\n", index); #endif return FALSE; } /// @brief Handle PSN_WIZBACK message. /// Basicly handles switching to proper page (skipping XDMCP or program page /// if required). /// @param hwndDlg Handle to active page dialog. /// @param index Index of current page. /// @return TRUE if the message was handled. FALSE otherwise. virtual BOOL WizardBack(HWND hwndDlg, unsigned index) { switch (PageID(index)) { case IDD_PROGRAM: case IDD_XDMCP: SetWindowLong(hwndDlg, DWL_MSGRESULT, IDD_CLIENTS); return TRUE; case IDD_FONTPATH: case IDD_EXTRA: // temporary. fontpath is disabled switch (config.client) { case CConfig::NoClient: SetWindowLong(hwndDlg, DWL_MSGRESULT, IDD_CLIENTS); return TRUE; case CConfig::StartProgram: SetWindowLong(hwndDlg, DWL_MSGRESULT, IDD_PROGRAM); return TRUE; case CConfig::XDMCP: SetWindowLong(hwndDlg, DWL_MSGRESULT, IDD_XDMCP); return TRUE; } break; } return FALSE; } /// @brief Handle PSN_SETACTIVE message. /// @param hwndDlg Handle to active page dialog. /// @param index Index of current page. /// @return TRUE if the message was handled. FALSE otherwise. virtual BOOL WizardActivate(HWND hwndDlg, unsigned index) { #ifdef _DEBUG printf("%s %d\n", __FUNCTION__, index); #endif switch (PageID(index)) { case IDD_CLIENTS: // Enable or disable XDMCP radiobutton and text if (config.window != CConfig::MultiWindow) { EnableWindow(GetDlgItem(hwndDlg, IDC_XDMCP), true); EnableWindow(GetDlgItem(hwndDlg, IDC_XDMCP_DESC), true); } else { if (IsDlgButtonChecked(hwndDlg, IDC_XDMCP)) CheckRadioButton(hwndDlg, IDC_CLIENT_NONE, IDC_CLIENT, IDC_CLIENT_NONE); EnableWindow(GetDlgItem(hwndDlg, IDC_XDMCP), false); EnableWindow(GetDlgItem(hwndDlg, IDC_XDMCP_DESC), false); } break; } return FALSE; } protected: /// @brief Enable or disable the control for remote clients. /// @param hwndDlg Handle to active page dialog. /// @param state State of control group. void EnableRemoteProgramGroup(HWND hwndDlg, BOOL state) { EnableWindow(GetDlgItem(hwndDlg, IDC_CLIENT_PASSWORD), state); EnableWindow(GetDlgItem(hwndDlg, IDC_CLIENT_HOST), state); EnableWindow(GetDlgItem(hwndDlg, IDC_CLIENT_USER), state); EnableWindow(GetDlgItem(hwndDlg, IDC_CLIENT_PASSWORD_DESC), state); EnableWindow(GetDlgItem(hwndDlg, IDC_CLIENT_HOST_DESC), state); EnableWindow(GetDlgItem(hwndDlg, IDC_CLIENT_USER_DESC), state); EnableWindow(GetDlgItem(hwndDlg, IDC_CLIENT_REMOTEPROGRAM), state); EnableWindow(GetDlgItem(hwndDlg, IDC_CLIENT_REMOTEPROGRAM_DESC), state); EnableWindow(GetDlgItem(hwndDlg, IDC_CLIENT_PRIVATEKEY), state); EnableWindow(GetDlgItem(hwndDlg, IDC_CLIENT_PRIVATEKEY_DESC), state); EnableWindow(GetDlgItem(hwndDlg, IDC_CLIENT_PROGRAM), !state); EnableWindow(GetDlgItem(hwndDlg, IDC_CLIENT_PROGRAM_DESC), !state); } /// @brief Enable or disable the control for XDMCP connection. /// @param hwndDlg Handle to active page dialog. /// @param state State of control group. void EnableXDMCPQueryGroup(HWND hwndDlg, BOOL state) { EnableWindow(GetDlgItem(hwndDlg, IDC_XDMCP_HOST), state); EnableWindow(GetDlgItem(hwndDlg, IDC_XDMCP_INDIRECT), state); } /// @brief Fill program box with default values. /// @param hwndDlg Handle to active page dialog. void FillProgramBox(HWND hwndDlg) { HWND cbwnd = GetDlgItem(hwndDlg, IDC_CLIENT_PROGRAM); if (cbwnd == NULL) return; SendMessage(cbwnd, CB_RESETCONTENT, 0, 0); SendMessage(cbwnd, CB_ADDSTRING, 0, (LPARAM) "xcalc"); SendMessage(cbwnd, CB_ADDSTRING, 0, (LPARAM) "xclock"); SendMessage(cbwnd, CB_ADDSTRING, 0, (LPARAM) "xwininfo"); SendMessage(cbwnd, CB_SETCURSEL, 0, 0); } void ShowSaveDialog(HWND parent) { char szTitle[512]; char szFilter[512]; char szFileTitle[512]; char szFile[MAX_PATH]; HINSTANCE hInst = GetModuleHandle(NULL); LoadString(hInst, IDS_SAVE_TITLE, szTitle, sizeof(szTitle)); LoadString(hInst, IDS_SAVE_FILETITLE, szFileTitle, sizeof(szFileTitle)); LoadString(hInst, IDS_SAVE_FILTER, szFilter, sizeof(szFilter)); for (unsigned i=0; szFilter[i]; i++) if (szFilter[i] == '%') szFilter[i] = '\0'; strcpy(szFile, "config.xlaunch"); OPENFILENAME ofn; memset(&ofn, 0, sizeof(OPENFILENAME)); ofn.lStructSize = sizeof(OPENFILENAME); ofn.hwndOwner = parent; ofn.lpstrFilter = szFilter; ofn.lpstrFile= szFile; ofn.nMaxFile = sizeof(szFile)/ sizeof(*szFile); ofn.lpstrFileTitle = szFileTitle; ofn.nMaxFileTitle = sizeof(szFileTitle); ofn.lpstrInitialDir = (LPSTR)NULL; ofn.Flags = OFN_SHOWHELP | OFN_OVERWRITEPROMPT; ofn.lpstrTitle = szTitle; if (GetSaveFileName(&ofn)) { try { config.Save(ofn.lpstrFile); } catch (std::runtime_error &e) { char Message[255]; sprintf(Message,"Failure: %s\n", e.what()); MessageBox(NULL,Message,"Exception",MB_OK); } } } public: /// @brief Handle messages fo the dialog pages. /// @param hwndDlg Handle of active dialog. /// @param uMsg Message code. /// @param wParam Message parameter. /// @param lParam Message parameter. /// @param psp Handle to sheet paramters. virtual INT_PTR PageDispatch(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam, PROPSHEETPAGE *psp) { HWND hwnd; switch (uMsg) { case WM_INITDIALOG: switch (PageID(PageIndex(psp))) { case IDD_DISPLAY: // Init display dialog. Enable correct check buttons switch (config.window) { default: case CConfig::MultiWindow: CheckRadioButton(hwndDlg, IDC_MULTIWINDOW, IDC_NODECORATION, IDC_MULTIWINDOW); break; case CConfig::Fullscreen: CheckRadioButton(hwndDlg, IDC_MULTIWINDOW, IDC_NODECORATION, IDC_FULLSCREEN); break; case CConfig::Windowed: CheckRadioButton(hwndDlg, IDC_MULTIWINDOW, IDC_NODECORATION, IDC_WINDOWED); break; case CConfig::Nodecoration: CheckRadioButton(hwndDlg, IDC_MULTIWINDOW, IDC_NODECORATION, IDC_NODECORATION); break; } // Set display number SetDlgItemText(hwndDlg, IDC_DISPLAY, config.display.c_str()); break; case IDD_CLIENTS: // Init client dialog. Enable correct check buttons switch (config.client) { default: case CConfig::NoClient: CheckRadioButton(hwndDlg, IDC_CLIENT_NONE, IDC_CLIENT, IDC_CLIENT_NONE); break; case CConfig::StartProgram: CheckRadioButton(hwndDlg, IDC_CLIENT_NONE, IDC_CLIENT, IDC_CLIENT); break; case CConfig::XDMCP: CheckRadioButton(hwndDlg, IDC_CLIENT_NONE, IDC_CLIENT, IDC_XDMCP); break; } break; case IDD_PROGRAM: // Init program dialog. Check local and remote buttons CheckRadioButton(hwndDlg, IDC_CLIENT_LOCAL, IDC_CLIENT_REMOTE, config.local?IDC_CLIENT_LOCAL:IDC_CLIENT_REMOTE); EnableRemoteProgramGroup(hwndDlg, config.local?FALSE:TRUE); // Fill combo boxes FillProgramBox(hwndDlg); // Set edit fields SetDlgItemText(hwndDlg, IDC_CLIENT_PROGRAM, config.localprogram.c_str()); SetDlgItemText(hwndDlg, IDC_CLIENT_REMOTEPROGRAM, config.remoteprogram.c_str()); SetDlgItemText(hwndDlg, IDC_CLIENT_USER, config.user.c_str()); SetDlgItemText(hwndDlg, IDC_CLIENT_HOST, config.host.c_str()); SetDlgItemText(hwndDlg, IDC_CLIENT_PASSWORD, config.remotepassword.c_str()); SetDlgItemText(hwndDlg, IDC_CLIENT_PRIVATEKEY, config.privatekey.c_str()); break; case IDD_XDMCP: // Init XDMCP dialog. Check broadcast and indirect button CheckRadioButton(hwndDlg, IDC_XDMCP_QUERY, IDC_XDMCP_BROADCAST, config.broadcast?IDC_XDMCP_BROADCAST:IDC_XDMCP_QUERY); CheckDlgButton(hwndDlg, IDC_XDMCP_INDIRECT, config.indirect?BST_CHECKED:BST_UNCHECKED); EnableXDMCPQueryGroup(hwndDlg, config.broadcast?FALSE:TRUE); // Set hostname SetDlgItemText(hwndDlg, IDC_XDMCP_HOST, config.xdmcp_host.c_str()); CheckDlgButton(hwndDlg, IDC_XDMCP_TERMINATE, config.xdmcpterminate?BST_CHECKED:BST_UNCHECKED); break; case IDD_EXTRA: CheckDlgButton(hwndDlg, IDC_CLIPBOARD, config.clipboard?BST_CHECKED:BST_UNCHECKED); CheckDlgButton(hwndDlg, IDC_CLIPBOARDPRIMARY, config.clipboardprimary?BST_CHECKED:BST_UNCHECKED); CheckDlgButton(hwndDlg, IDC_WGL, config.wgl?BST_CHECKED:BST_UNCHECKED); CheckDlgButton(hwndDlg, IDC_DISABLEAC, config.disableac?BST_CHECKED:BST_UNCHECKED); SetDlgItemText(hwndDlg, IDC_EXTRA_PARAMS, config.extra_params.c_str()); break; } case WM_COMMAND: // Handle control messages switch (LOWORD(wParam)) { // Handle clicks on images. Check proper radiobutton case IDC_MULTIWINDOW_IMG: case IDC_FULLSCREEN_IMG: case IDC_WINDOWED_IMG: case IDC_NODECORATION_IMG: CheckRadioButton(hwndDlg, IDC_MULTIWINDOW, IDC_NODECORATION, LOWORD(wParam)-4); SetFocus(GetDlgItem(hwndDlg, LOWORD(wParam)-4)); break; // Disable unavailable controls case IDC_CLIENT_REMOTE: case IDC_CLIENT_LOCAL: EnableRemoteProgramGroup(hwndDlg, LOWORD(wParam) == IDC_CLIENT_REMOTE); break; case IDC_XDMCP_QUERY: case IDC_XDMCP_BROADCAST: EnableXDMCPQueryGroup(hwndDlg, LOWORD(wParam) == IDC_XDMCP_QUERY); break; case IDC_FINISH_SAVE: ShowSaveDialog(hwndDlg); break; } } // pass messages to parent return CWizard::PageDispatch(hwndDlg, uMsg, wParam, lParam, psp); } /// @brief Try to connect to server. /// Repeat until successful, server died or maximum number of retries /// reached. Display *WaitForServer(HANDLE serverProcess) { int ncycles = 120; /* # of cycles to wait */ int cycles; /* Wait cycle count */ Display *xd; for (cycles = 0; cycles < ncycles; cycles++) { if ((xd = XOpenDisplay(NULL))) { return xd; } else { if (WaitForSingleObject(serverProcess, 1000) == WAIT_TIMEOUT) continue; } } return NULL; } /// @brief Do the actual start of VCXsrv and clients void StartUp() { std::string buffer; std::string client; // Construct display strings int DisplayNbr=atoi(config.display.c_str()); std::string display_id = ":" + config.display; std::string display = "DISPLAY=127.0.0.1" + display_id + ".0"; // Build Xsrv commandline buffer = "vcxsrv "; if (DisplayNbr!=-1) buffer += display_id + " "; switch (config.window) { case CConfig::MultiWindow: buffer += "-multiwindow "; break; case CConfig::Fullscreen: buffer += "-fullscreen "; break; case CConfig::Nodecoration: buffer += "-nodecoration "; break; default: break; } // Add XDMCP parameter if (config.client == CConfig::XDMCP) { if (config.broadcast) buffer += "-broadcast "; else { if (config.indirect) buffer += "-indirect "; else buffer += "-query "; buffer += config.xdmcp_host; buffer += " "; } if (config.xdmcpterminate) buffer += "-terminate "; } if (config.clipboard) buffer += "-clipboard "; if (!config.clipboardprimary) buffer += "-noclipboardprimary "; if (config.wgl) buffer += "-wgl "; if (config.disableac) buffer += "-ac "; if (!config.extra_params.empty()) { buffer += config.extra_params; buffer += " "; } int *pDisplayfd; if (DisplayNbr==-1) { // Pass the handle of some shared memory to vcxsrv to getting back the display nbr SECURITY_ATTRIBUTES sa; sa.nLength=sizeof(sa); sa.lpSecurityDescriptor=NULL; sa.bInheritHandle=TRUE; HANDLE hDisplayFdMem=CreateFileMapping(INVALID_HANDLE_VALUE, &sa, PAGE_READWRITE, 0, sizeof(int), NULL); pDisplayfd=(int*)MapViewOfFile(hDisplayFdMem, FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, 0); *pDisplayfd=-1; // Not yet initialised buffer+="-displayfd "; std::stringstream ss; ss<<(int)hDisplayFdMem; buffer+=ss.str(); } // Construct client commandline if (config.client == CConfig::StartProgram) { if (!config.local) { char cmdline[512]; std::string host = config.host; std::string remotepassword; if (!config.user.empty()) host = config.user + "@" + config.host; if (!config.remotepassword.empty()) remotepassword=std::string(" -pw ")+config.remotepassword; if (!config.privatekey.empty()) remotepassword+=std::string(" -i \"")+config.privatekey+"\""; // Need to use -console since certain commands will not execute when no console _snprintf(cmdline,512,"plink -ssh -X%s %s %s", remotepassword.c_str(), host.c_str(),config.remoteprogram.c_str()); client += cmdline; } else { client += config.localprogram.c_str(); } } // Prepare program startup STARTUPINFO si, sic; PROCESS_INFORMATION pi, pic; HANDLE handles[2]; DWORD hcount = 0; Display *dpy = NULL; ZeroMemory( &si, sizeof(si) ); si.cb = sizeof(si); ZeroMemory( &pi, sizeof(pi) ); ZeroMemory( &sic, sizeof(sic) ); sic.cb = sizeof(sic); ZeroMemory( &pic, sizeof(pic) ); // Start VCXsrv process. #ifdef _DEBUG printf("%s\n", buffer.c_str()); #endif char CurDir[MAX_PATH]; GetModuleFileName(NULL,CurDir,MAX_PATH); *strrchr(CurDir,'\\')=0; if( !CreateProcess( NULL, (CHAR*)buffer.c_str(), NULL, NULL, TRUE, 0, NULL, CurDir, &si, &pi )) throw win32_error("CreateProcess failed"); handles[hcount++] = pi.hProcess; if (!client.empty()) { if (DisplayNbr==-1) { // Wait maximum 10 seconds int Count=1000; while (-1==*pDisplayfd) { if (Count-- < 0) throw std::runtime_error("Connection to server failed"); Sleep(10); } std::stringstream ss; ss<<*pDisplayfd; display_id = ":" + ss.str(); display = "DISPLAY=127.0.0.1" + display_id + ".0"; } // Set DISPLAY variable _putenv(display.c_str()); // Wait for server to startup dpy = WaitForServer(pi.hProcess); if (dpy == NULL) { while (hcount--) TerminateProcess(handles[hcount], (DWORD)-1); throw std::runtime_error("Connection to server failed"); } #ifdef _DEBUG printf("%s\n", client.c_str()); #endif // Hide a console window // FIXME: This may make it impossible to enter the password sic.dwFlags = STARTF_USESHOWWINDOW; sic.wShowWindow = SW_HIDE; // Start the child process. // Create a console, otherwise some commands will not execute with plink #ifdef WITH_FLASH AllocConsole(); #else HWINSTA h=GetProcessWindowStation(); HWINSTA horig=h; if (h) { h=CreateWindowStationW(NULL, 0, STANDARD_RIGHTS_READ, NULL); if (h) SetProcessWindowStation(h); AllocConsole(); SetProcessWindowStation(horig); CloseWindowStation(h); } #endif #if 1 { HANDLE hChildStdinRd; HANDLE hChildStdinWr; HANDLE hChildStdoutRd; HANDLE hChildStdoutWr; HANDLE hChildStdinWrDup; HANDLE hChildStdoutRdDup; SECURITY_ATTRIBUTES saAttr; BOOL fSuccess; STARTUPINFO StartupInfo; memset(&StartupInfo,0,sizeof(StartupInfo)); StartupInfo.cb=sizeof(STARTUPINFO); PROCESS_INFORMATION ProcessInfo; saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); saAttr.bInheritHandle = TRUE; saAttr.lpSecurityDescriptor = NULL; if (!CreatePipe(&hChildStdinRd, &hChildStdinWr, &saAttr, 0)) throw win32_error("CreatePipe failed", GetLastError()); /* Create new output read handle and the input write handle. Set * the inheritance properties to FALSE. Otherwise, the child inherits * the these handles; resulting in non-closeable handles to the pipes * being created. */ fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdinWr, GetCurrentProcess(), &hChildStdinWrDup, 0, FALSE, DUPLICATE_SAME_ACCESS); if (!fSuccess) throw win32_error("DuplicateHandle failed", GetLastError()); /* Close the inheritable version of ChildStdin that we're using. */ CloseHandle(hChildStdinWr); if (!CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, 0)) throw win32_error("CreatePipe failed", GetLastError()); fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdoutRd, GetCurrentProcess(), &hChildStdoutRdDup, 0, FALSE, DUPLICATE_SAME_ACCESS); if (!fSuccess) throw win32_error("DuplicateHandle failed", GetLastError()); CloseHandle(hChildStdoutRd); int hStdIn = _open_osfhandle((long)hChildStdinWrDup, _O_WRONLY|_O_TEXT); FILE *pStdIn = _fdopen(hStdIn, "w"); int hStdOut = _open_osfhandle((long)hChildStdoutRdDup, _O_RDONLY|_O_TEXT); FILE *pStdOut = _fdopen(hStdOut, "r"); StartupInfo.dwFlags = STARTF_USESTDHANDLES; StartupInfo.hStdInput = hChildStdinRd; StartupInfo.hStdOutput = hChildStdoutWr; StartupInfo.hStdError = hChildStdoutWr; if (!CreateProcess(NULL,(CHAR*)client.c_str(),NULL,NULL,TRUE,CREATE_NO_WINDOW,NULL, CurDir, &StartupInfo, &ProcessInfo)) { DWORD err = GetLastError(); while (hcount--) TerminateProcess(handles[hcount], (DWORD)-1); throw win32_error("CreateProcess failed", err); } CloseHandle(hChildStdinRd); CloseHandle(hChildStdoutWr); CloseHandle(ProcessInfo.hThread); char Buf[256]; size_t Nbr; std::string output; while ( (Nbr=fread(Buf,1,sizeof(Buf)-1,pStdOut)) > 0) { output+=Buf; } if (!output.empty()) { MessageBox(NULL,output.c_str(),"Child output",MB_OK); } } #else if( !CreateProcess( NULL, (CHAR*)client.c_str(), NULL, NULL, FALSE, 0, NULL, CurDir, &sic, &pic )) { DWORD err = GetLastError(); while (hcount--) TerminateProcess(handles[hcount], (DWORD)-1); throw win32_error("CreateProcess failed", err); } #endif handles[hcount++] = pic.hProcess; #ifdef WITHFLASH ShowWindow( GetConsoleWindow(), SW_HIDE ); // make it hidden #endif } // Wait until any child process exits. DWORD ret = WaitForMultipleObjects(hcount, handles, FALSE, INFINITE ); #ifdef _DEBUG printf("killing process!\n"); #endif // Check if Xsrv is still running, but only when we started a local program if (config.local) { DWORD exitcode; GetExitCodeProcess(pi.hProcess, &exitcode); unsigned counter = 0; while (exitcode == STILL_ACTIVE) { if (++counter > 10) TerminateProcess(pi.hProcess, (DWORD)-1); else // Shutdown Xsrv (the soft way!) EnumThreadWindows(pi.dwThreadId, KillWindowsProc, 0); Sleep(500); GetExitCodeProcess(pi.hProcess, &exitcode); } // Kill the client TerminateProcess(pic.hProcess, (DWORD)-1); } // Close process and thread handles. CloseHandle( pi.hProcess ); CloseHandle( pi.hThread ); CloseHandle( pic.hProcess ); CloseHandle( pic.hThread ); } }; int main(int argc, char **argv) { try { InitCommonControls(); CMyWizard dialog; bool skip_wizard = false; for (int i = 1; i < argc; i++) { if (argv[i] == NULL) continue; std::string arg(argv[i]); if (arg == "-load" && i + 1 < argc) { i++; dialog.LoadConfig(argv[i]); continue; } if (arg == "-run" && i + 1 < argc) { i++; dialog.LoadConfig(argv[i]); skip_wizard = true; continue; } } int ret = 0; if (skip_wizard || (ret =dialog.ShowModal()) != 0) dialog.StartUp(); #ifdef _DEBUG printf("return %d\n", ret); #endif return 0; } catch (std::runtime_error &e) { char Message[255]; sprintf(Message,"Failure: %s\n", e.what()); MessageBox(NULL,Message,"Exception",MB_OK); return -1; } }