mono/metadata/w32process-win32.c

   1 /**
   2  * \file
   3  * System.Diagnostics.Process support
   4  *
   5  * Author:
   6  *      Dick Porter (dick@ximian.com)
   7  *
   8  * Copyright 2002 Ximian, Inc.
   9  * Copyright 2002-2006 Novell, Inc.
  10  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  11  */
  12
  13 #include <config.h>
  14
  15 #include <glib.h>
  16 #include <string.h>
  17
  18 #include <winsock2.h>
  19 #include <windows.h>
  20
  21 #include <mono/metadata/w32process.h>
  22 #include <mono/metadata/assembly.h>
  23 #include <mono/metadata/appdomain.h>
  24 #include <mono/metadata/image.h>
  25 #include <mono/metadata/cil-coff.h>
  26 #include <mono/metadata/exception.h>
  27 #include <mono/metadata/threadpool-io.h>
  28 #include <mono/utils/strenc.h>
  29 #include <mono/utils/mono-proclib.h>
  30 #include <mono/metadata/w32handle.h>
  31 #include <mono/utils/w32api.h>
  32 #include <mono/utils/mono-threads-coop.h>
  33 #include <mono/utils/w32subset.h>
  34
  35 void
  36 mono_w32process_init (void)
  37 {
  38 }
  39
  40 void
  41 mono_w32process_cleanup (void)
  42 {
  43 }
  44
  45 void
  46 mono_w32process_signal_finished (void)
  47 {
  48 }
  49
  50 guint32
  51 mono_w32process_get_pid (gpointer handle)
  52 {
  53         return GetProcessId (handle);
  54 }
  55
  56 #if HAVE_API_SUPPORT_WIN32_ENUM_WINDOWS
  57 typedef struct {
  58         DWORD pid;
  59         HWND hwnd;
  60 } EnumWindowsArgs;
  61
  62 static BOOL CALLBACK
  63 mono_enum_windows_callback(HWND hwnd, LPARAM lparam)
  64 {
  65         EnumWindowsArgs *args = (EnumWindowsArgs *)lparam;
  66         DWORD pid = 0;
  67         GetWindowThreadProcessId(hwnd, &pid);
  68         if (pid != args->pid || GetWindow(hwnd, GW_OWNER) != NULL || !IsWindowVisible(hwnd)) return TRUE;
  69         args->hwnd = hwnd;
  70         return FALSE;
  71 }
  72
  73 HANDLE
  74 ves_icall_System_Diagnostics_Process_MainWindowHandle_internal (guint32 pid, MonoError *error)
  75 {
  76         EnumWindowsArgs args = {pid, NULL};
  77         EnumWindows(mono_enum_windows_callback, (LPARAM)&args);
  78         return args.hwnd;
  79 }
  80 #elif !HAVE_EXTERN_DEFINED_WIN32_ENUM_WINDOWS
  81 HANDLE
  82 ves_icall_System_Diagnostics_Process_MainWindowHandle_internal (guint32 pid, MonoError *error)
  83 {
  84         /*TODO: Implement for uwp*/
  85         return NULL;
  86 }
  87 #endif /* HAVE_API_SUPPORT_WIN32_ENUM_WINDOWS */
  88
  89 #if HAVE_API_SUPPORT_WIN32_ENUM_PROCESS_MODULES
  90 gboolean
  91 mono_w32process_try_get_modules (gpointer process, gpointer *modules, guint32 size, guint32 *needed)
  92 {
  93         return EnumProcessModules (process, (HMODULE *)modules, size, (PDWORD)needed);
  94 }
  95 #elif !HAVE_EXTERN_DEFINED_WIN32_ENUM_PROCESS_MODULES
  96 gboolean
  97 mono_w32process_try_get_modules (gpointer process, gpointer *modules, guint32 size, guint32 *needed)
  98 {
  99         g_unsupported_api ("EnumProcessModules");
 100         SetLastError (ERROR_NOT_SUPPORTED);
 101         return FALSE;
 102 }
 103 #endif
 104
 105 #if HAVE_API_SUPPORT_WIN32_GET_MODULE_BASE_NAME
 106 gboolean
 107 mono_w32process_module_get_name (gpointer process, gpointer module, gunichar2 **str, guint32 *len)
 108 {
 109         return mono_get_module_basename (process, module, str, len);
 110 }
 111 #elif !HAVE_EXTERN_DEFINED_WIN32_GET_MODULE_BASE_NAME
 112 gboolean
 113 mono_w32process_module_get_name (gpointer process, gpointer module, gunichar2 **str, guint32 *len)
 114 {
 115         g_unsupported_api ("GetModuleBaseName");
 116         SetLastError (ERROR_NOT_SUPPORTED);
 117         return FALSE;
 118  }
 119 #endif /* HAVE_API_SUPPORT_WIN32_GET_MODULE_BASE_NAME */
 120
 121 #if HAVE_API_SUPPORT_WIN32_GET_MODULE_FILE_NAME_EX
 122 gboolean
 123 mono_w32process_module_get_filename (gpointer process, gpointer module, gunichar2 **str, guint32 *len)
 124 {
 125         return mono_get_module_filename_ex (process, module, str, len);
 126 }
 127 #elif !HAVE_EXTERN_DEFINED_WIN32_GET_MODULE_FILE_NAME_EX
 128 gboolean
 129 mono_w32process_module_get_filename (gpointer process, gpointer module, gunichar2 **str, guint32 *len)
 130 {
 131         g_unsupported_api ("GetModuleFileNameEx");
 132         SetLastError (ERROR_NOT_SUPPORTED);
 133         return FALSE;
 134  }
 135 #endif /* HAVE_API_SUPPORT_WIN32_GET_MODULE_FILE_NAME_EX */
 136
 137 #if HAVE_API_SUPPORT_WIN32_GET_MODULE_INFORMATION
 138 gboolean
 139 mono_w32process_module_get_information (gpointer process, gpointer module, gpointer modinfo, guint32 size)
 140 {
 141         return GetModuleInformation (process, (HMODULE)module, (MODULEINFO *)modinfo, size);
 142 }
 143 #elif !HAVE_EXTERN_DEFINED_WIN32_GET_MODULE_INFORMATION
 144 gboolean
 145 mono_w32process_module_get_information (gpointer process, gpointer module, gpointer modinfo, guint32 size)
 146 {
 147         g_unsupported_api ("GetModuleInformation");
 148         SetLastError (ERROR_NOT_SUPPORTED);
 149         return FALSE;
 150 }
 151 #endif /* HAVE_API_SUPPORT_WIN32_GET_MODULE_INFORMATION */
 152
 153 #if HAVE_API_SUPPORT_WIN32_GET_FILE_VERSION_INFO
 154 gboolean
 155 mono_w32process_get_fileversion_info (const gunichar2 *filename, gpointer *data)
 156 {
 157         DWORD handle;
 158
 159         g_assert (data);
 160         *data = NULL;
 161
 162         DWORD datasize = GetFileVersionInfoSizeW (filename, &handle);
 163         if (datasize <= 0)
 164                 return FALSE;
 165
 166         *data = g_malloc0 (datasize);
 167         if (!GetFileVersionInfoW (filename, handle, datasize, *data)) {
 168                 g_free (*data);
 169                 return FALSE;
 170         }
 171
 172         return TRUE;
 173 }
 174 #elif !HAVE_EXTERN_DEFINED_WIN32_GET_FILE_VERSION_INFO
 175 gboolean
 176 mono_w32process_get_fileversion_info (const gunichar2 *filename, gpointer *data)
 177 {
 178         g_unsupported_api ("GetFileVersionInfo");
 179         SetLastError (ERROR_NOT_SUPPORTED);
 180         return FALSE;
 181 }
 182 #endif /* HAVE_API_SUPPORT_WIN32_GET_FILE_VERSION_INFO */
 183
 184 #if HAVE_API_SUPPORT_WIN32_VER_QUERY_VALUE
 185 gboolean
 186 mono_w32process_ver_query_value (gconstpointer datablock, const gunichar2 *subblock, gpointer *buffer, guint32 *len)
 187 {
 188         return VerQueryValueW (datablock, subblock, buffer, len);
 189 }
 190 #elif !HAVE_EXTERN_DEFINED_WIN32_VER_QUERY_VALUE
 191 gboolean
 192 mono_w32process_ver_query_value (gconstpointer datablock, const gunichar2 *subblock, gpointer *buffer, guint32 *len)
 193 {
 194         g_unsupported_api ("VerQueryValue");
 195         SetLastError (ERROR_NOT_SUPPORTED);
 196         return FALSE;
 197 }
 198 #endif /* HAVE_API_SUPPORT_WIN32_VER_QUERY_VALUE */
 199
 200 #if HAVE_API_SUPPORT_WIN32_VER_LANGUAGE_NAME
 201 guint32
 202 mono_w32process_ver_language_name (guint32 lang, gunichar2 *lang_out, guint32 lang_len)
 203 {
 204         return VerLanguageNameW (lang, lang_out, lang_len);
 205 }
 206 #elif !HAVE_EXTERN_DEFINED_WIN32_VER_LANGUAGE_NAME
 207 guint32
 208 mono_w32process_ver_language_name (guint32 lang, gunichar2 *lang_out, guint32 lang_len)
 209 {
 210         g_unsupported_api ("VerLanguageName");
 211         SetLastError (ERROR_NOT_SUPPORTED);
 212         return 0;
 213 }
 214 #endif /* HAVE_API_SUPPORT_WIN32_VER_LANGUAGE_NAME */
 215
 216 #if HAVE_API_SUPPORT_WIN32_OPEN_PROCESS
 217 HANDLE
 218 ves_icall_System_Diagnostics_Process_GetProcess_internal (guint32 pid, MonoError *error)
 219 {
 220         HANDLE handle;
 221
 222         /* GetCurrentProcess returns a pseudo-handle, so use
 223          * OpenProcess instead
 224          */
 225         handle = OpenProcess (PROCESS_ALL_ACCESS, TRUE, pid);
 226         if (handle == NULL)
 227                 /* FIXME: Throw an exception */
 228                 return NULL;
 229         return handle;
 230 }
 231 #elif !HAVE_EXTERN_DEFINED_WIN32_OPEN_PROCESS
 232 HANDLE
 233 ves_icall_System_Diagnostics_Process_GetProcess_internal (guint32 pid, MonoError *error)
 234 {
 235         g_unsupported_api ("OpenProcess");
 236         mono_error_set_not_supported (error, G_UNSUPPORTED_API, "OpenProcess");
 237         SetLastError (ERROR_NOT_SUPPORTED);
 238         return NULL;
 239 }
 240 #endif /* HAVE_API_SUPPORT_WIN32_OPEN_PROCESS */
 241
 242 #if HAVE_API_SUPPORT_WIN32_SHELL_EXECUTE_EX
 243 #include <shellapi.h>
 244 MonoBoolean
 245 ves_icall_System_Diagnostics_Process_ShellExecuteEx_internal (MonoW32ProcessStartInfoHandle proc_start_info, MonoW32ProcessInfo *process_info, MonoError *error)
 246 {
 247         MonoCreateProcessCoop coop;
 248         mono_createprocess_coop_init (&coop, proc_start_info, process_info);
 249
 250         SHELLEXECUTEINFOW shellex = {0};
 251         gboolean ret;
 252
 253         shellex.cbSize = sizeof(SHELLEXECUTEINFO);
 254         shellex.fMask = (gulong)(SEE_MASK_NOASYNC | SEE_MASK_NOCLOSEPROCESS | SEE_MASK_UNICODE);
 255         shellex.nShow = (gulong)MONO_HANDLE_GETVAL (proc_start_info, window_style);
 256         shellex.nShow = (gulong)((shellex.nShow == 0) ? 1 : (shellex.nShow == 1 ? 0 : shellex.nShow));
 257
 258         shellex.lpFile = coop.filename;
 259         shellex.lpParameters = coop.arguments;
 260
 261         if (coop.length.verb)
 262                 shellex.lpVerb = coop.verb;
 263
 264         if (coop.length.working_directory)
 265                 shellex.lpDirectory = coop.working_directory;
 266
 267         if (MONO_HANDLE_GETVAL (proc_start_info, error_dialog))
 268                 shellex.hwnd = (HWND)MONO_HANDLE_GETVAL (proc_start_info, error_dialog_parent_handle);
 269         else
 270                 shellex.fMask = (gulong)(shellex.fMask | SEE_MASK_FLAG_NO_UI);
 271
 272         MONO_ENTER_GC_SAFE;
 273         ret = ShellExecuteExW (&shellex);
 274         MONO_EXIT_GC_SAFE;
 275
 276         if (ret == FALSE) {
 277                 process_info->pid = -GetLastError ();
 278         } else {
 279                 process_info->process_handle = shellex.hProcess;
 280 #if !defined(MONO_CROSS_COMPILE)
 281                 process_info->pid = GetProcessId (shellex.hProcess);
 282 #else
 283                 process_info->pid = 0;
 284 #endif
 285         }
 286
 287         mono_createprocess_coop_cleanup (&coop);
 288
 289         return ret;
 290 }
 291 #elif !HAVE_EXTERN_DEFINED_WIN32_SHELL_EXECUTE_EX
 292 MonoBoolean
 293 ves_icall_System_Diagnostics_Process_ShellExecuteEx_internal (MonoW32ProcessStartInfoHandle proc_start_info, MonoW32ProcessInfo *process_info, MonoError *error)
 294 {
 295         g_unsupported_api ("ShellExecuteEx");
 296         mono_error_set_not_supported (error, G_UNSUPPORTED_API, "ShellExecuteEx");
 297         process_info->pid = (guint32)(-ERROR_NOT_SUPPORTED);
 298         SetLastError (ERROR_NOT_SUPPORTED);
 299         return FALSE;
 300 }
 301 #endif /* HAVE_API_SUPPORT_WIN32_SHELL_EXECUTE_EX */
 302
 303 #if HAVE_API_SUPPORT_WIN32_CREATE_PROCESS_WITH_LOGON || HAVE_API_SUPPORT_WIN32_CREATE_PROCESS
 304 static gboolean
 305 mono_process_create_process (MonoCreateProcessCoop *coop, MonoW32ProcessInfo *mono_process_info,
 306         MonoStringHandle cmd, guint32 creation_flags, gunichar2 *env_vars, gunichar2 *dir,
 307         HANDLE stdin_handle, HANDLE stdout_handle, HANDLE stderr_handle, PROCESS_INFORMATION *process_info, MonoError *error)
 308 {
 309         gboolean result = FALSE;
 310         MonoGCHandle cmd_gchandle = NULL;
 311         gunichar2 *cmd_chars = MONO_HANDLE_IS_NULL (cmd) ? NULL : mono_string_handle_pin_chars (cmd, &cmd_gchandle);
 312
 313         STARTUPINFOW start_info={0};
 314 #if HAVE_API_SUPPORT_WIN32_CONSOLE
 315         start_info.cb = sizeof(STARTUPINFOW);
 316         start_info.dwFlags = STARTF_USESTDHANDLES;
 317         start_info.hStdInput = stdin_handle;
 318         start_info.hStdOutput = stdout_handle;
 319         start_info.hStdError = stderr_handle;
 320 #else
 321         start_info.dwFlags = 0;
 322         start_info.hStdInput = INVALID_HANDLE_VALUE;
 323         start_info.hStdOutput = INVALID_HANDLE_VALUE;
 324         start_info.hStdError = INVALID_HANDLE_VALUE;
 325 #endif /* HAVE_API_SUPPORT_WIN32_CONSOLE */
 326
 327         MONO_ENTER_GC_SAFE;
 328         if (coop->username) {
 329 #if HAVE_API_SUPPORT_WIN32_CREATE_PROCESS_WITH_LOGON
 330                 guint32 logon_flags = mono_process_info->load_user_profile ? LOGON_WITH_PROFILE : 0;
 331
 332                 result = CreateProcessWithLogonW (coop->username,
 333                                                   coop->domain,
 334                                                   mono_process_info->password,
 335                                                   logon_flags,
 336                                                   NULL,
 337                                                   cmd_chars,
 338                                                   creation_flags,
 339                                                   env_vars, dir, &start_info, process_info);
 340 #else
 341                 memset (process_info, 0, sizeof (PROCESS_INFORMATION));
 342                 g_unsupported_api ("CreateProcessWithLogon");
 343                 mono_error_set_not_supported (error, G_UNSUPPORTED_API, "CreateProcessWithLogon");
 344                 SetLastError (ERROR_NOT_SUPPORTED);
 345 #endif /* HAVE_API_SUPPORT_WIN32_CREATE_PROCESS_WITH_LOGON */
 346         } else {
 347 #if HAVE_API_SUPPORT_WIN32_CREATE_PROCESS
 348                 result = CreateProcessW (NULL,
 349                                         cmd_chars,
 350                                         NULL,
 351                                         NULL,
 352                                         TRUE,
 353                                         creation_flags,
 354                                         env_vars,
 355                                         dir,
 356                                         &start_info,
 357                                         process_info);
 358 #else
 359                 memset (process_info, 0, sizeof (PROCESS_INFORMATION));
 360                 g_unsupported_api ("CreateProcess");
 361                 mono_error_set_not_supported (error, G_UNSUPPORTED_API, "CreateProcess");
 362                 SetLastError (ERROR_NOT_SUPPORTED);
 363 #endif
 364         }
 365         MONO_EXIT_GC_SAFE;
 366
 367         mono_gchandle_free_internal (cmd_gchandle);
 368
 369         return result;
 370 }
 371 #elif !HAVE_EXTERN_DEFINED_WIN32_CREATE_PROCESS_WITH_LOGON && !HAVE_EXTERN_DEFINED_WIN32_CREATE_PROCESS
 372 static gboolean
 373 mono_process_create_process (MonoCreateProcessCoop *coop, MonoW32ProcessInfo *mono_process_info,
 374         MonoStringHandle cmd, guint32 creation_flags, gunichar2 *env_vars, gunichar2 *dir,
 375         HANDLE stdin_handle, HANDLE stdout_handle, HANDLE stderr_handle, PROCESS_INFORMATION *process_info, MonoError *error)
 376 {
 377         memset (process_info, 0, sizeof (PROCESS_INFORMATION));
 378         g_unsupported_api ("CreateProcessWithLogon, CreateProcess");
 379         mono_error_set_not_supported (error, G_UNSUPPORTED_API, "CreateProcessWithLogon, CreateProcess");
 380         SetLastError (ERROR_NOT_SUPPORTED);
 381         return FALSE;
 382 }
 383 #endif /* HAVE_API_SUPPORT_WIN32_CREATE_PROCESS_WITH_LOGON || HAVE_API_SUPPORT_WIN32_CREATE_PROCESS */
 384
 385 static gchar*
 386 process_unquote_application_name (gchar *appname)
 387 {
 388         size_t len = strlen (appname);
 389         if (len) {
 390                 if (appname[len-1] == '\"')
 391                         appname[len-1] = '\0';
 392                 if (appname[0] == '\"')
 393                         appname++;
 394         }
 395
 396         return appname;
 397 }
 398
 399 static gchar*
 400 process_quote_path (const gchar *path)
 401 {
 402         gchar *res = g_shell_quote (path);
 403         gchar *q = res;
 404         while (*q) {
 405                 if (*q == '\'')
 406                         *q = '\"';
 407                 q++;
 408         }
 409         return res;
 410 }
 411
 412 /* Only used when UseShellExecute is false */
 413 static gchar*
 414 process_complete_path (const gunichar2 *appname)
 415 {
 416         // FIXME This function should stick to gunichar2.
 417
 418         char *utf8app;
 419         char *utf8appmemory = NULL;
 420         char *result;
 421
 422         utf8appmemory = g_utf16_to_utf8 (appname, -1, NULL, NULL, NULL);
 423         utf8app = process_unquote_application_name (utf8appmemory);
 424
 425         result = process_quote_path (utf8app);
 426
 427         g_free (utf8appmemory);
 428
 429         return result;
 430 }
 431
 432 static gboolean
 433 process_get_shell_arguments (MonoCreateProcessCoop *proc_start_info, MonoStringHandle *cmd, MonoError *error)
 434 {
 435         char *spath = NULL;
 436         char *new_cmd = NULL;
 437         char *cmd_utf8 = NULL;
 438
 439         *cmd = proc_start_info->coophandle.arguments;
 440
 441         // FIXME There are excess utf8 <=> gunichar2 conversions here.
 442         // We are either returning spath, or spath + " " + cmd.
 443         // Just use gunichar2. Maybe move logic to C#.
 444
 445         spath = process_complete_path (proc_start_info->filename);
 446
 447         /* Seems like our CreateProcess does not work as the windows one.
 448          * This hack is needed to deal with paths containing spaces */
 449         if (!MONO_HANDLE_IS_NULL (*cmd)) {
 450                 cmd_utf8 = mono_string_handle_to_utf8 (*cmd, error);
 451                 goto_if_nok (error, error);
 452                 new_cmd = g_strdup_printf ("%s %s", spath, cmd_utf8);
 453                 *cmd = mono_string_new_utf8_len (mono_domain_get (), new_cmd, strlen (new_cmd), error);
 454                 goto_if_nok (error, error);
 455         }
 456         else {
 457                 *cmd = mono_string_new_utf8_len (mono_domain_get (), spath, strlen (spath), error);
 458                 goto_if_nok (error, error);
 459         }
 460
 461 exit:
 462         g_free (spath);
 463         g_free (cmd_utf8);
 464         g_free (new_cmd);
 465         return !MONO_HANDLE_IS_NULL (*cmd);
 466 error:
 467         *cmd = NULL_HANDLE_STRING;
 468         goto exit;
 469 }
 470
 471 MonoBoolean
 472 ves_icall_System_Diagnostics_Process_CreateProcess_internal (MonoW32ProcessStartInfoHandle proc_start_info,
 473         HANDLE stdin_handle, HANDLE stdout_handle, HANDLE stderr_handle, MonoW32ProcessInfo *process_info, MonoError *error)
 474 {
 475         MonoCreateProcessCoop coop;
 476         mono_createprocess_coop_init (&coop, proc_start_info, process_info);
 477
 478         gboolean ret;
 479         gunichar2 *dir = NULL;
 480         PROCESS_INFORMATION procinfo;
 481         gunichar2 *env_vars = NULL;
 482         MonoStringHandle cmd = NULL_HANDLE_STRING;
 483         guint32 creation_flags;
 484
 485         creation_flags = CREATE_UNICODE_ENVIRONMENT;
 486         if (MONO_HANDLE_GETVAL (proc_start_info, create_no_window))
 487                 creation_flags |= CREATE_NO_WINDOW;
 488
 489         if (process_get_shell_arguments (&coop, &cmd, error) == FALSE) {
 490                 // FIXME This should be passed back separately.
 491                 process_info->pid = -ERROR_FILE_NOT_FOUND;
 492                 ret = FALSE;
 493                 goto exit;
 494         }
 495
 496         if (process_info->env_variables) {
 497                 MonoArrayHandle array = MONO_HANDLE_NEW (MonoArray, process_info->env_variables);
 498                 MonoStringHandle var = MONO_HANDLE_NEW (MonoString, NULL);
 499                 gsize const array_length = mono_array_handle_length (array);
 500
 501                 // nul-separated and nul-terminated
 502                 gsize len = array_length + 1 + !array_length;
 503
 504                 for (gsize i = 0; i < array_length; i++) {
 505                         MONO_HANDLE_ARRAY_GETREF (var, array, i);
 506                         len += mono_string_handle_length (var);
 507                 }
 508
 509                 gunichar2 *ptr = g_new0 (gunichar2, len);
 510                 env_vars = ptr;
 511
 512                 for (gsize i = 0; i < array_length; i++) {
 513                         MONO_HANDLE_ARRAY_GETREF (var, array, i);
 514                         MonoGCHandle gchandle = NULL;
 515                         memcpy (ptr, mono_string_handle_pin_chars (var, &gchandle), mono_string_handle_length (var) * sizeof (gunichar2));
 516                         mono_gchandle_free_internal (gchandle);
 517                         ptr += mono_string_handle_length (var);
 518                         ptr += 1; // Skip over the null-separator
 519                 }
 520         }
 521
 522         /* The default dir name is "".  Turn that into NULL to mean
 523          * "current directory"
 524          */
 525         if (coop.length.working_directory)
 526                 dir = coop.working_directory;
 527
 528         ret = mono_process_create_process (&coop, process_info, cmd, creation_flags, env_vars, dir, stdin_handle, stdout_handle, stderr_handle, &procinfo, error);
 529
 530         g_free (env_vars);
 531
 532         if (ret) {
 533                 process_info->process_handle = procinfo.hProcess;
 534                 /*process_info->thread_handle=procinfo.hThread;*/
 535                 if (procinfo.hThread != NULL && procinfo.hThread != INVALID_HANDLE_VALUE)
 536                         CloseHandle (procinfo.hThread);
 537                 process_info->pid = procinfo.dwProcessId;
 538         } else {
 539                 // FIXME This should be passed back separately.
 540                 process_info->pid = -GetLastError ();
 541         }
 542
 543 exit:
 544         mono_createprocess_coop_cleanup (&coop);
 545         return ret;
 546 }
 547
 548 #if HAVE_API_SUPPORT_WIN32_ENUM_PROCESSES
 549 MonoArrayHandle
 550 ves_icall_System_Diagnostics_Process_GetProcesses_internal (MonoError *error)
 551 {
 552         MonoArrayHandle procs = NULL_HANDLE_ARRAY;
 553         DWORD needed = 0;
 554         DWORD *pids = NULL;
 555         int count = 512;
 556         gboolean success;
 557
 558         do {
 559                 pids = g_new0 (DWORD, count);
 560
 561                 MONO_ENTER_GC_SAFE;
 562                 success = EnumProcesses (pids, count * sizeof (DWORD), &needed);
 563                 MONO_EXIT_GC_SAFE;
 564
 565                 if (!success)
 566                         goto exit;
 567                 if (needed < (count * sizeof (guint32)))
 568                         break;
 569                 g_free (pids);
 570                 pids = NULL;
 571                 count = (count * 3) / 2;
 572         } while (TRUE);
 573
 574         count = needed / sizeof (guint32);
 575         procs = mono_array_new_handle (mono_domain_get (), mono_get_int32_class (), count, error);
 576         if (!is_ok (error)) {
 577                 procs = NULL_HANDLE_ARRAY;
 578                 goto exit;
 579         }
 580
 581         MONO_ENTER_NO_SAFEPOINTS;
 582
 583         memcpy (mono_array_addr_internal (MONO_HANDLE_RAW (procs), guint32, 0), pids, needed);
 584
 585         MONO_EXIT_NO_SAFEPOINTS;
 586
 587 exit:
 588         g_free (pids);
 589         return procs;
 590 }
 591 #elif !HAVE_EXTERN_DEFINED_WIN32_ENUM_PROCESSES
 592 MonoArrayHandle
 593 ves_icall_System_Diagnostics_Process_GetProcesses_internal (MonoError *error)
 594 {
 595         g_unsupported_api ("EnumProcesses");
 596         mono_error_set_not_supported (error, G_UNSUPPORTED_API, "EnumProcesses");
 597         SetLastError (ERROR_NOT_SUPPORTED);
 598         return NULL_HANDLE_ARRAY;
 599 }
 600 #endif /* HAVE_API_SUPPORT_WIN32_ENUM_PROCESSES */
 601
 602 MonoBoolean
 603 ves_icall_Microsoft_Win32_NativeMethods_CloseProcess (gpointer handle)
 604 {
 605         return CloseHandle (handle);
 606 }
 607
 608 MonoBoolean
 609 ves_icall_Microsoft_Win32_NativeMethods_TerminateProcess (gpointer handle, gint32 exitcode)
 610 {
 611         return TerminateProcess (handle, exitcode);
 612 }
 613
 614 MonoBoolean
 615 ves_icall_Microsoft_Win32_NativeMethods_GetExitCodeProcess (gpointer handle, gint32 *exitcode)
 616 {
 617         return GetExitCodeProcess (handle, (PDWORD)exitcode);
 618 }
 619
 620 #if HAVE_API_SUPPORT_WIN32_GET_WORKING_SET_SIZE
 621 MonoBoolean
 622 ves_icall_Microsoft_Win32_NativeMethods_GetProcessWorkingSetSize (gpointer handle, gsize *min, gsize *max)
 623 {
 624         return GetProcessWorkingSetSize (handle, (PSIZE_T)min, (PSIZE_T)max);
 625 }
 626 #elif !HAVE_EXTERN_DEFINED_WIN32_GET_WORKING_SET_SIZE
 627 MonoBoolean
 628 ves_icall_Microsoft_Win32_NativeMethods_GetProcessWorkingSetSize (gpointer handle, gsize *min, gsize *max)
 629 {
 630         ERROR_DECL (error);
 631         g_unsupported_api ("GetProcessWorkingSetSize");
 632         mono_error_set_not_supported(error, G_UNSUPPORTED_API, "GetProcessWorkingSetSize");
 633         mono_error_set_pending_exception (error);
 634         SetLastError (ERROR_NOT_SUPPORTED);
 635         return FALSE;
 636 }
 637 #endif /* HAVE_API_SUPPORT_WIN32_GET_WORKING_SET_SIZE */
 638
 639 #if HAVE_API_SUPPORT_WIN32_SET_WORKING_SET_SIZE
 640 MonoBoolean
 641 ves_icall_Microsoft_Win32_NativeMethods_SetProcessWorkingSetSize (gpointer handle, gsize min, gsize max)
 642 {
 643         return SetProcessWorkingSetSize (handle, min, max);
 644 }
 645 #elif !HAVE_EXTERN_DEFINED_WIN32_SET_WORKING_SET_SIZE
 646 MonoBoolean
 647 ves_icall_Microsoft_Win32_NativeMethods_SetProcessWorkingSetSize (gpointer handle, gsize min, gsize max)
 648 {
 649         ERROR_DECL (error);
 650         g_unsupported_api ("SetProcessWorkingSetSize");
 651         mono_error_set_not_supported (error, G_UNSUPPORTED_API, "SetProcessWorkingSetSize");
 652         mono_error_set_pending_exception (error);
 653         SetLastError (ERROR_NOT_SUPPORTED);
 654         return FALSE;
 655 }
 656 #endif /* HAVE_API_SUPPORT_WIN32_SET_WORKING_SET_SIZE */
 657
 658 #if HAVE_API_SUPPORT_WIN32_GET_PRIORITY_CLASS
 659 gint32
 660 ves_icall_Microsoft_Win32_NativeMethods_GetPriorityClass (gpointer handle)
 661 {
 662         return GetPriorityClass (handle);
 663 }
 664 #elif !HAVE_EXTERN_DEFINED_WIN32_GET_PRIORITY_CLASS
 665 gint32
 666 ves_icall_Microsoft_Win32_NativeMethods_GetPriorityClass (gpointer handle)
 667 {
 668         ERROR_DECL (error);
 669         g_unsupported_api ("GetPriorityClass");
 670         mono_error_set_not_supported (error, G_UNSUPPORTED_API, "GetPriorityClass");
 671         mono_error_set_pending_exception (error);
 672         SetLastError (ERROR_NOT_SUPPORTED);
 673         return FALSE;
 674 }
 675 #endif /* HAVE_API_SUPPORT_WIN32_GET_PRIORITY_CLASS */
 676
 677 #if HAVE_API_SUPPORT_WIN32_SET_PRIORITY_CLASS
 678 MonoBoolean
 679 ves_icall_Microsoft_Win32_NativeMethods_SetPriorityClass (gpointer handle, gint32 priorityClass)
 680 {
 681         return SetPriorityClass (handle, (guint32) priorityClass);
 682 }
 683 #elif !HAVE_EXTERN_DEFINED_WIN32_SET_PRIORITY_CLASS
 684 MonoBoolean
 685 ves_icall_Microsoft_Win32_NativeMethods_SetPriorityClass (gpointer handle, gint32 priorityClass)
 686 {
 687         ERROR_DECL (error);
 688         g_unsupported_api ("SetPriorityClass");
 689         mono_error_set_not_supported(error, G_UNSUPPORTED_API, "SetPriorityClass");
 690         mono_error_set_pending_exception (error);
 691         SetLastError (ERROR_NOT_SUPPORTED);
 692         return FALSE;
 693 }
 694 #endif /* HAVE_API_SUPPORT_WIN32_SET_PRIORITY_CLASS */
 695
 696 MonoBoolean
 697 ves_icall_Microsoft_Win32_NativeMethods_GetProcessTimes (gpointer handle, gint64 *creationtime, gint64 *exittime, gint64 *kerneltime, gint64 *usertime)
 698 {
 699         return GetProcessTimes (handle, (LPFILETIME) creationtime, (LPFILETIME) exittime, (LPFILETIME) kerneltime, (LPFILETIME) usertime);
 700 }
 701
 702 gpointer
 703 ves_icall_Microsoft_Win32_NativeMethods_GetCurrentProcess (void)
 704 {
 705         return GetCurrentProcess ();
 706 }