1 /*

     2  * Copyright (c) 2014, 2019, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 #include "Platform.h"

    27 

    28 #include "JavaVirtualMachine.h"

    29 #include "WindowsPlatform.h"

    30 #include "Package.h"

    31 #include "Helpers.h"

    32 #include "PlatformString.h"

    33 #include "Macros.h"

    34 

    35 #include <map>

    36 #include <vector>

    37 #include <regex>

    38 #include <fstream>

    39 #include <locale>

    40 #include <codecvt>

    41 

    42 using namespace std;

    43 

    44 #define WINDOWS_JPACKAGE_TMP_DIR \

    45         L"\\AppData\\Local\\Java\\JPackage\\tmp"

    46 

    47 class Registry {

    48 private:

    49     HKEY FKey;

    50     HKEY FOpenKey;

    51     bool FOpen;

    52 

    53 public:

    54 

    55     Registry(HKEY Key) {

    56         FOpen = false;

    57         FKey = Key;

    58     }

    59 

    60     ~Registry() {

    61         Close();

    62     }

    63 

    64     void Close() {

    65         if (FOpen == true) {

    66             RegCloseKey(FOpenKey);

    67         }

    68     }

    69 

    70     bool Open(TString SubKey) {

    71         bool result = false;

    72         Close();

    73 

    74         if (RegOpenKeyEx(FKey, SubKey.data(), 0, KEY_READ, &FOpenKey) ==

    75                 ERROR_SUCCESS) {

    76             result = true;

    77         }

    78 

    79         return result;

    80     }

    81 

    82     std::list<TString> GetKeys() {

    83         std::list<TString> result;

    84         DWORD count;

    85 

    86         if (RegQueryInfoKey(FOpenKey, NULL, NULL, NULL, NULL, NULL, NULL,

    87                 &count, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {

    88 

    89             DWORD length = 255;

    90             DynamicBuffer<TCHAR> buffer(length);

    91             if (buffer.GetData() == NULL) {

    92                 return result;

    93             }

    94 

    95             for (unsigned int index = 0; index < count; index++) {

    96                 buffer.Zero();

    97                 DWORD status = RegEnumValue(FOpenKey, index, buffer.GetData(),

    98                         &length, NULL, NULL, NULL, NULL);

    99 

   100                 while (status == ERROR_MORE_DATA) {

   101                     length = length * 2;

   102                     if (!buffer.Resize(length)) {

   103                         return result;

   104                     }

   105                     status = RegEnumValue(FOpenKey, index, buffer.GetData(),

   106                             &length, NULL, NULL, NULL, NULL);

   107                 }

   108 

   109                 if (status == ERROR_SUCCESS) {

   110                     TString value = buffer.GetData();

   111                     result.push_back(value);

   112                 }

   113             }

   114         }

   115 

   116         return result;

   117     }

   118 

   119     TString ReadString(TString Name) {

   120         TString result;

   121         DWORD length;

   122         DWORD dwRet;

   123         DynamicBuffer<wchar_t> buffer(0);

   124         length = 0;

   125 

   126         dwRet = RegQueryValueEx(FOpenKey, Name.data(), NULL, NULL, NULL,

   127                 &length);

   128         if (dwRet == ERROR_MORE_DATA || dwRet == 0) {

   129             if (!buffer.Resize(length + 1)) {

   130                 return result;

   131             }

   132             dwRet = RegQueryValueEx(FOpenKey, Name.data(), NULL, NULL,

   133                     (LPBYTE) buffer.GetData(), &length);

   134             result = buffer.GetData();

   135         }

   136 

   137         return result;

   138     }

   139 };

   140 

   141 WindowsPlatform::WindowsPlatform(void) : Platform() {

   142     FMainThread = ::GetCurrentThreadId();

   143 }

   144 

   145 WindowsPlatform::~WindowsPlatform(void) {

   146 }

   147 

   148 TString WindowsPlatform::GetPackageAppDirectory() {

   149     return FilePath::IncludeTrailingSeparator(

   150             GetPackageRootDirectory()) + _T("app");

   151 }

   152 

   153 TString WindowsPlatform::GetPackageLauncherDirectory() {

   154     return  GetPackageRootDirectory();

   155 }

   156 

   157 TString WindowsPlatform::GetPackageRuntimeBinDirectory() {

   158     return FilePath::IncludeTrailingSeparator(GetPackageRootDirectory()) + _T("runtime\\bin");

   159 }

   160 

   161 TCHAR* WindowsPlatform::ConvertStringToFileSystemString(TCHAR* Source,

   162         bool &release) {

   163     // Not Implemented.

   164     return NULL;

   165 }

   166 

   167 TCHAR* WindowsPlatform::ConvertFileSystemStringToString(TCHAR* Source,

   168         bool &release) {

   169     // Not Implemented.

   170     return NULL;

   171 }

   172 

   173 TString WindowsPlatform::GetPackageRootDirectory() {

   174     TString result;

   175     TString filename = GetModuleFileName();

   176     return FilePath::ExtractFilePath(filename);

   177 }

   178 

   179 TString WindowsPlatform::GetAppDataDirectory() {

   180     TString result;

   181     TCHAR path[MAX_PATH];

   182 

   183     if (SHGetFolderPath(NULL, CSIDL_APPDATA, NULL, 0, path) == S_OK) {

   184         result = path;

   185     }

   186 

   187     return result;

   188 }

   189 

   190 TString WindowsPlatform::GetAppName() {

   191     TString result = GetModuleFileName();

   192     result = FilePath::ExtractFileName(result);

   193     result = FilePath::ChangeFileExt(result, _T(""));

   194     return result;

   195 }

   196 

   197 void WindowsPlatform::ShowMessage(TString title, TString description) {

   198     MessageBox(NULL, description.data(),

   199             !title.empty() ? title.data() : description.data(),

   200             MB_ICONERROR | MB_OK);

   201 }

   202 

   203 void WindowsPlatform::ShowMessage(TString description) {

   204     TString appname = GetModuleFileName();

   205     appname = FilePath::ExtractFileName(appname);

   206     MessageBox(NULL, description.data(), appname.data(), MB_ICONERROR | MB_OK);

   207 }

   208 

   209 MessageResponse WindowsPlatform::ShowResponseMessage(TString title,

   210         TString description) {

   211     MessageResponse result = mrCancel;

   212 

   213     if (::MessageBox(NULL, description.data(), title.data(), MB_OKCANCEL) ==

   214             IDOK) {

   215         result = mrOK;

   216     }

   217 

   218     return result;

   219 }

   220 

   221 TString WindowsPlatform::GetBundledJavaLibraryFileName(TString RuntimePath) {

   222     TString result = FilePath::IncludeTrailingSeparator(RuntimePath) +

   223             _T("jre\\bin\\jli.dll");

   224 

   225     if (FilePath::FileExists(result) == false) {

   226         result = FilePath::IncludeTrailingSeparator(RuntimePath) +

   227                 _T("bin\\jli.dll");

   228     }

   229 

   230     return result;

   231 }

   232 

   233 ISectionalPropertyContainer* WindowsPlatform::GetConfigFile(TString FileName) {

   234     IniFile *result = new IniFile();

   235     if (result == NULL) {

   236         return NULL;

   237     }

   238 

   239     result->LoadFromFile(FileName);

   240 

   241     return result;

   242 }

   243 

   244 TString WindowsPlatform::GetModuleFileName() {

   245     TString result;

   246     DynamicBuffer<wchar_t> buffer(MAX_PATH);

   247     if (buffer.GetData() == NULL) {

   248         return result;

   249     }

   250 

   251     ::GetModuleFileName(NULL, buffer.GetData(),

   252             static_cast<DWORD> (buffer.GetSize()));

   253 

   254     while (ERROR_INSUFFICIENT_BUFFER == GetLastError()) {

   255         if (!buffer.Resize(buffer.GetSize() * 2)) {

   256             return result;

   257         }

   258         ::GetModuleFileName(NULL, buffer.GetData(),

   259                 static_cast<DWORD> (buffer.GetSize()));

   260     }

   261 

   262     result = buffer.GetData();

   263     return result;

   264 }

   265 

   266 Module WindowsPlatform::LoadLibrary(TString FileName) {

   267     return ::LoadLibrary(FileName.data());

   268 }

   269 

   270 void WindowsPlatform::FreeLibrary(Module AModule) {

   271     ::FreeLibrary((HMODULE) AModule);

   272 }

   273 

   274 Procedure WindowsPlatform::GetProcAddress(Module AModule,

   275         std::string MethodName) {

   276     return ::GetProcAddress((HMODULE) AModule, MethodName.c_str());

   277 }

   278 

   279 bool WindowsPlatform::IsMainThread() {

   280     bool result = (FMainThread == ::GetCurrentThreadId());

   281     return result;

   282 }

   283 

   284 TString WindowsPlatform::GetTempDirectory() {

   285     TString result;

   286     PWSTR userDir = 0;

   287 

   288     if (SUCCEEDED(SHGetKnownFolderPath(

   289             FOLDERID_Profile,

   290             0,

   291             NULL,

   292             &userDir))) {

   293         result = userDir;

   294         result += WINDOWS_JPACKAGE_TMP_DIR;

   295         CoTaskMemFree(userDir);

   296     }

   297 

   298     return result;

   299 }

   300 

   301 static BOOL CALLBACK enumWindows(HWND winHandle, LPARAM lParam) {

   302     DWORD pid = (DWORD) lParam, wPid = 0;

   303     GetWindowThreadProcessId(winHandle, &wPid);

   304     if (pid == wPid) {

   305         SetForegroundWindow(winHandle);

   306         return FALSE;

   307     }

   308     return TRUE;

   309 }

   310 

   311 TPlatformNumber WindowsPlatform::GetMemorySize() {

   312     SYSTEM_INFO si;

   313     GetSystemInfo(&si);

   314     size_t result = (size_t) si.lpMaximumApplicationAddress;

   315     result = result / 1048576; // Convert from bytes to megabytes.

   316     return result;

   317 }

   318 

   319 std::vector<TString> FilterList(std::vector<TString> &Items,

   320         std::wregex Pattern) {

   321     std::vector<TString> result;

   322 

   323     for (std::vector<TString>::iterator it = Items.begin();

   324             it != Items.end(); ++it) {

   325         TString item = *it;

   326         std::wsmatch match;

   327 

   328         if (std::regex_search(item, match, Pattern)) {

   329             result.push_back(item);

   330         }

   331     }

   332     return result;

   333 }

   334 

   335 Process* WindowsPlatform::CreateProcess() {

   336     return new WindowsProcess();

   337 }

   338 

   339 void WindowsPlatform::InitStreamLocale(wios *stream) {

   340     const std::locale empty_locale = std::locale::empty();

   341     const std::locale utf8_locale =

   342                 std::locale(empty_locale, new std::codecvt_utf8<wchar_t>());

   343     stream->imbue(utf8_locale);

   344 }

   345 

   346 void WindowsPlatform::addPlatformDependencies(JavaLibrary *pJavaLibrary) {

   347     if (pJavaLibrary == NULL) {

   348         return;

   349     }

   350 

   351     if (FilePath::FileExists(_T("msvcr100.dll")) == true) {

   352         pJavaLibrary->AddDependency(_T("msvcr100.dll"));

   353     }

   354 

   355     TString runtimeBin = GetPackageRuntimeBinDirectory();

   356     SetDllDirectory(runtimeBin.c_str());

   357 }

   358 

   359 void Platform::CopyString(char *Destination,

   360         size_t NumberOfElements, const char *Source) {

   361     strcpy_s(Destination, NumberOfElements, Source);

   362 

   363     if (NumberOfElements > 0) {

   364         Destination[NumberOfElements - 1] = '\0';

   365     }

   366 }

   367 

   368 void Platform::CopyString(wchar_t *Destination,

   369         size_t NumberOfElements, const wchar_t *Source) {

   370     wcscpy_s(Destination, NumberOfElements, Source);

   371 

   372     if (NumberOfElements > 0) {

   373         Destination[NumberOfElements - 1] = '\0';

   374     }

   375 }

   376 

   377 // Owner must free the return value.

   378 MultibyteString Platform::WideStringToMultibyteString(

   379         const wchar_t* value) {

   380     MultibyteString result;

   381     size_t count = 0;

   382 

   383     if (value == NULL) {

   384         return result;

   385     }

   386 

   387     count = WideCharToMultiByte(CP_UTF8, 0, value, -1, NULL, 0, NULL, NULL);

   388 

   389     if (count > 0) {

   390         result.data = new char[count + 1];

   391         result.length = WideCharToMultiByte(CP_UTF8, 0, value, -1,

   392                 result.data, (int)count, NULL, NULL);

   393     }

   394 

   395     return result;

   396 }

   397 

   398 // Owner must free the return value.

   399 WideString Platform::MultibyteStringToWideString(const char* value) {

   400     WideString result;

   401     size_t count = 0;

   402 

   403     if (value == NULL) {

   404         return result;

   405     }

   406 

   407     mbstowcs_s(&count, NULL, 0, value, _TRUNCATE);

   408 

   409     if (count > 0) {

   410         result.data = new wchar_t[count + 1];

   411         mbstowcs_s(&result.length, result.data, count, value, count);

   412     }

   413 

   414     return result;

   415 }

   416 

   417 FileHandle::FileHandle(std::wstring FileName) {

   418     FHandle = ::CreateFile(FileName.data(), GENERIC_READ, FILE_SHARE_READ,

   419             NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);

   420 }

   421 

   422 FileHandle::~FileHandle() {

   423     if (IsValid() == true) {

   424         ::CloseHandle(FHandle);

   425     }

   426 }

   427 

   428 bool FileHandle::IsValid() {

   429     return FHandle != INVALID_HANDLE_VALUE;

   430 }

   431 

   432 HANDLE FileHandle::GetHandle() {

   433     return FHandle;

   434 }

   435 

   436 FileMappingHandle::FileMappingHandle(HANDLE FileHandle) {

   437     FHandle = ::CreateFileMapping(FileHandle, NULL, PAGE_READONLY, 0, 0, NULL);

   438 }

   439 

   440 bool FileMappingHandle::IsValid() {

   441     return FHandle != NULL;

   442 }

   443 

   444 FileMappingHandle::~FileMappingHandle() {

   445     if (IsValid() == true) {

   446         ::CloseHandle(FHandle);

   447     }

   448 }

   449 

   450 HANDLE FileMappingHandle::GetHandle() {

   451     return FHandle;

   452 }

   453 

   454 FileData::FileData(HANDLE Handle) {

   455     FBaseAddress = ::MapViewOfFile(Handle, FILE_MAP_READ, 0, 0, 0);

   456 }

   457 

   458 FileData::~FileData() {

   459     if (IsValid() == true) {

   460         ::UnmapViewOfFile(FBaseAddress);

   461     }

   462 }

   463 

   464 bool FileData::IsValid() {

   465     return FBaseAddress != NULL;

   466 }

   467 

   468 LPVOID FileData::GetBaseAddress() {

   469     return FBaseAddress;

   470 }

   471 

   472 WindowsLibrary::WindowsLibrary(std::wstring FileName) {

   473     FFileName = FileName;

   474 }

   475 

   476 std::vector<TString> WindowsLibrary::GetImports() {

   477     std::vector<TString> result;

   478     FileHandle library(FFileName);

   479 

   480     if (library.IsValid() == true) {

   481         FileMappingHandle mapping(library.GetHandle());

   482 

   483         if (mapping.IsValid() == true) {

   484             FileData fileData(mapping.GetHandle());

   485 

   486             if (fileData.IsValid() == true) {

   487                 PIMAGE_DOS_HEADER dosHeader =

   488                         (PIMAGE_DOS_HEADER) fileData.GetBaseAddress();

   489                 PIMAGE_FILE_HEADER pImgFileHdr =

   490                         (PIMAGE_FILE_HEADER) fileData.GetBaseAddress();

   491                 if (dosHeader->e_magic == IMAGE_DOS_SIGNATURE) {

   492                     result = DumpPEFile(dosHeader);

   493                 }

   494             }

   495         }

   496     }

   497 

   498     return result;

   499 }

   500 

   501 // Given an RVA, look up the section header that encloses it and return a

   502 // pointer to its IMAGE_SECTION_HEADER

   503 

   504 PIMAGE_SECTION_HEADER WindowsLibrary::GetEnclosingSectionHeader(DWORD rva,

   505         PIMAGE_NT_HEADERS pNTHeader) {

   506     PIMAGE_SECTION_HEADER result = 0;

   507     PIMAGE_SECTION_HEADER section = IMAGE_FIRST_SECTION(pNTHeader);

   508 

   509     for (unsigned index = 0; index < pNTHeader->FileHeader.NumberOfSections;

   510             index++, section++) {

   511         // Is the RVA is within this section?

   512         if ((rva >= section->VirtualAddress) &&

   513                 (rva < (section->VirtualAddress + section->Misc.VirtualSize))) {

   514             result = section;

   515         }

   516     }

   517 

   518     return result;

   519 }

   520 

   521 LPVOID WindowsLibrary::GetPtrFromRVA(DWORD rva, PIMAGE_NT_HEADERS pNTHeader,

   522         DWORD imageBase) {

   523     LPVOID result = 0;

   524     PIMAGE_SECTION_HEADER pSectionHdr = GetEnclosingSectionHeader(rva,

   525             pNTHeader);

   526 

   527     if (pSectionHdr != NULL) {

   528         INT delta = (INT) (

   529                 pSectionHdr->VirtualAddress - pSectionHdr->PointerToRawData);

   530         DWORD_PTR dwp = (DWORD_PTR) (imageBase + rva - delta);

   531         result = reinterpret_cast<LPVOID> (dwp); // VS2017 - FIXME

   532     }

   533 

   534     return result;

   535 }

   536 

   537 std::vector<TString> WindowsLibrary::GetImportsSection(DWORD base,

   538         PIMAGE_NT_HEADERS pNTHeader) {

   539     std::vector<TString> result;

   540 

   541     // Look up where the imports section is located. Normally in

   542     // the .idata section,

   543     // but not necessarily so. Therefore, grab the RVA from the data dir.

   544     DWORD importsStartRVA = pNTHeader->OptionalHeader.DataDirectory[

   545             IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;

   546 

   547     if (importsStartRVA != NULL) {

   548         // Get the IMAGE_SECTION_HEADER that contains the imports. This is

   549         // usually the .idata section, but doesn't have to be.

   550         PIMAGE_SECTION_HEADER pSection =

   551                 GetEnclosingSectionHeader(importsStartRVA, pNTHeader);

   552 

   553         if (pSection != NULL) {

   554             PIMAGE_IMPORT_DESCRIPTOR importDesc =

   555                     (PIMAGE_IMPORT_DESCRIPTOR) GetPtrFromRVA(

   556                     importsStartRVA, pNTHeader, base);

   557 

   558             if (importDesc != NULL) {

   559                 while (true) {

   560                     // See if we've reached an empty IMAGE_IMPORT_DESCRIPTOR

   561                     if ((importDesc->TimeDateStamp == 0) &&

   562                             (importDesc->Name == 0)) {

   563                         break;

   564                     }

   565 

   566                     std::string filename = (char*) GetPtrFromRVA(

   567                             importDesc->Name, pNTHeader, base);

   568                     result.push_back(PlatformString(filename));

   569                     importDesc++; // advance to next IMAGE_IMPORT_DESCRIPTOR

   570                 }

   571             }

   572         }

   573     }

   574 

   575     return result;

   576 }

   577 

   578 std::vector<TString> WindowsLibrary::DumpPEFile(PIMAGE_DOS_HEADER dosHeader) {

   579     std::vector<TString> result;

   580     // all of this is VS2017 - FIXME

   581     DWORD_PTR dwDosHeaders = reinterpret_cast<DWORD_PTR> (dosHeader);

   582     DWORD_PTR dwPIHeaders = dwDosHeaders + (DWORD) (dosHeader->e_lfanew);

   583 

   584     PIMAGE_NT_HEADERS pNTHeader =

   585             reinterpret_cast<PIMAGE_NT_HEADERS> (dwPIHeaders);

   586 

   587     // Verify that the e_lfanew field gave us a reasonable

   588     // pointer and the PE signature.

   589     // TODO: To really fix JDK-8131321 this condition needs to be changed.

   590     // There is a matching change

   591     // in JavaVirtualMachine.cpp that also needs to be changed.

   592     if (pNTHeader->Signature == IMAGE_NT_SIGNATURE) {

   593         DWORD base = (DWORD) (dwDosHeaders);

   594         result = GetImportsSection(base, pNTHeader);

   595     }

   596 

   597     return result;

   598 }

   599 

   600 #include <TlHelp32.h>

   601 

   602 WindowsJob::WindowsJob() {

   603     FHandle = NULL;

   604 }

   605 

   606 WindowsJob::~WindowsJob() {

   607     if (FHandle != NULL) {

   608         CloseHandle(FHandle);

   609     }

   610 }

   611 

   612 HANDLE WindowsJob::GetHandle() {

   613     if (FHandle == NULL) {

   614         FHandle = CreateJobObject(NULL, NULL); // GLOBAL

   615 

   616         if (FHandle == NULL) {

   617             ::MessageBox(0, _T("Could not create job object"),

   618                     _T("TEST"), MB_OK);

   619         } else {

   620             JOBOBJECT_EXTENDED_LIMIT_INFORMATION jeli = {0};

   621 

   622             // Configure all child processes associated with

   623             // the job to terminate when the

   624             jeli.BasicLimitInformation.LimitFlags =

   625                     JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;

   626             if (0 == SetInformationJobObject(FHandle,

   627                     JobObjectExtendedLimitInformation, &jeli, sizeof (jeli))) {

   628                 ::MessageBox(0, _T("Could not SetInformationJobObject"),

   629                         _T("TEST"), MB_OK);

   630             }

   631         }

   632     }

   633 

   634     return FHandle;

   635 }

   636 

   637 // Initialize static member of WindowsProcess

   638 WindowsJob WindowsProcess::FJob;

   639 

   640 WindowsProcess::WindowsProcess() : Process() {

   641     FRunning = false;

   642 }

   643 

   644 WindowsProcess::~WindowsProcess() {

   645     Terminate();

   646 }

   647 

   648 void WindowsProcess::Cleanup() {

   649     CloseHandle(FProcessInfo.hProcess);

   650     CloseHandle(FProcessInfo.hThread);

   651 }

   652 

   653 bool WindowsProcess::IsRunning() {

   654     bool result = false;

   655 

   656     HANDLE handle = ::CreateToolhelp32Snapshot(TH32CS_SNAPALL, 0);

   657     if (handle == INVALID_HANDLE_VALUE) {

   658         return false;

   659     }

   660 

   661     PROCESSENTRY32 process = {0};

   662     process.dwSize = sizeof (process);

   663 

   664     if (::Process32First(handle, &process)) {

   665         do {

   666             if (process.th32ProcessID == FProcessInfo.dwProcessId) {

   667                 result = true;

   668                 break;

   669             }

   670         } while (::Process32Next(handle, &process));

   671     }

   672 

   673     CloseHandle(handle);

   674 

   675     return result;

   676 }

   677 

   678 bool WindowsProcess::Terminate() {

   679     bool result = false;

   680 

   681     if (IsRunning() == true && FRunning == true) {

   682         FRunning = false;

   683     }

   684 

   685     return result;

   686 }

   687 

   688 bool WindowsProcess::Execute(const TString Application,

   689         const std::vector<TString> Arguments, bool AWait) {

   690     bool result = false;

   691 

   692     if (FRunning == false) {

   693         FRunning = true;

   694 

   695         STARTUPINFO startupInfo;

   696         ZeroMemory(&startupInfo, sizeof (startupInfo));

   697         startupInfo.cb = sizeof (startupInfo);

   698         ZeroMemory(&FProcessInfo, sizeof (FProcessInfo));

   699 

   700         TString command = Application;

   701 

   702         for (std::vector<TString>::const_iterator iterator = Arguments.begin();

   703                 iterator != Arguments.end(); iterator++) {

   704             command += TString(_T(" ")) + *iterator;

   705         }

   706 

   707         if (::CreateProcess(Application.data(), (wchar_t*)command.data(), NULL,

   708                 NULL, FALSE, 0, NULL, NULL, &startupInfo, &FProcessInfo)

   709                 == FALSE) {

   710             TString message = PlatformString::Format(

   711                     _T("Error: Unable to create process %s"),

   712                     Application.data());

   713             throw Exception(message);

   714         } else {

   715             if (FJob.GetHandle() != NULL) {

   716                 if (::AssignProcessToJobObject(FJob.GetHandle(),

   717                         FProcessInfo.hProcess) == 0) {

   718                     // Failed to assign process to job. It doesn't prevent

   719                     // anything from continuing so continue.

   720                 }

   721             }

   722 

   723             // Wait until child process exits.

   724             if (AWait == true) {

   725                 Wait();

   726                 // Close process and thread handles.

   727                 Cleanup();

   728             }

   729         }

   730     }

   731 

   732     return result;

   733 }

   734 

   735 bool WindowsProcess::Wait() {

   736     bool result = false;

   737 

   738     WaitForSingleObject(FProcessInfo.hProcess, INFINITE);

   739     return result;

   740 }

   741 

   742 TProcessID WindowsProcess::GetProcessID() {

   743     return FProcessInfo.dwProcessId;

   744 }

   745 

   746 bool WindowsProcess::ReadOutput() {

   747     bool result = false;

   748     // TODO implement

   749     return result;

   750 }

   751 

   752 void WindowsProcess::SetInput(TString Value) {

   753     // TODO implement

   754 }

   755 

   756 std::list<TString> WindowsProcess::GetOutput() {

   757     ReadOutput();

   758     return Process::GetOutput();

   759 }