mono/metadata/process.c

   1 /*
   2  * process.c: System.Diagnostics.Process support
   3  *
   4  * Author:
   5  *      Dick Porter (dick@ximian.com)
   6  *
   7  * Copyright 2002 Ximian, Inc.
   8  * Copyright 2002-2006 Novell, Inc.
   9  */
  10
  11 #include <config.h>
  12
  13 #include <glib.h>
  14 #include <string.h>
  15
  16 #include <mono/metadata/object-internals.h>
  17 #include <mono/metadata/process.h>
  18 #include <mono/metadata/assembly.h>
  19 #include <mono/metadata/appdomain.h>
  20 #include <mono/metadata/image.h>
  21 #include <mono/metadata/cil-coff.h>
  22 #include <mono/metadata/exception.h>
  23 #include <mono/utils/strenc.h>
  24 #include <mono/utils/mono-proclib.h>
  25 #include <mono/io-layer/io-layer.h>
  26 /* FIXME: fix this code to not depend so much on the internals */
  27 #include <mono/metadata/class-internals.h>
  28
  29 #define LOGDEBUG(...)
  30 /* define LOGDEBUG(...) g_message(__VA_ARGS__)  */
  31
  32
  33 HANDLE ves_icall_System_Diagnostics_Process_GetProcess_internal (guint32 pid)
  34 {
  35         HANDLE handle;
  36
  37         MONO_ARCH_SAVE_REGS;
  38
  39         /* GetCurrentProcess returns a pseudo-handle, so use
  40          * OpenProcess instead
  41          */
  42         handle=OpenProcess (PROCESS_ALL_ACCESS, TRUE, pid);
  43
  44         if(handle==NULL) {
  45                 /* FIXME: Throw an exception */
  46                 return(NULL);
  47         }
  48
  49         return(handle);
  50 }
  51
  52 guint32
  53 ves_icall_System_Diagnostics_Process_GetPid_internal (void)
  54 {
  55         MONO_ARCH_SAVE_REGS;
  56
  57         return mono_process_current_pid ();
  58 }
  59
  60 void ves_icall_System_Diagnostics_Process_Process_free_internal (MonoObject *this,
  61                                                                  HANDLE process)
  62 {
  63         MONO_ARCH_SAVE_REGS;
  64
  65 #ifdef THREAD_DEBUG
  66         g_message ("%s: Closing process %p, handle %p", __func__, this, process);
  67 #endif
  68
  69 #if defined(TARGET_WIN32) || defined(HOST_WIN32)
  70         CloseHandle (process);
  71 #else
  72         CloseProcess (process);
  73 #endif
  74 }
  75
  76 #define STASH_SYS_ASS(this) \
  77         if(system_assembly == NULL) { \
  78                 system_assembly=this->vtable->klass->image; \
  79         }
  80
  81 static MonoImage *system_assembly=NULL;
  82
  83 static guint32 unicode_chars (const gunichar2 *str)
  84 {
  85         guint32 len=0;
  86
  87         do {
  88                 if(str[len]=='\0') {
  89                         return(len);
  90                 }
  91                 len++;
  92         } while(1);
  93 }
  94
  95 static void process_set_field_object (MonoObject *obj, const gchar *fieldname,
  96                                       MonoObject *data)
  97 {
  98         MonoClassField *field;
  99
 100         LOGDEBUG (g_message ("%s: Setting field %s to object at %p", __func__, fieldname, data));
 101
 102         field=mono_class_get_field_from_name (mono_object_class (obj),
 103                                               fieldname);
 104         mono_gc_wbarrier_generic_store (((char *)obj) + field->offset, data);
 105 }
 106
 107 static void process_set_field_string (MonoObject *obj, const gchar *fieldname,
 108                                       const gunichar2 *val, guint32 len)
 109 {
 110         MonoClassField *field;
 111         MonoString *string;
 112
 113         LOGDEBUG (g_message ("%s: Setting field %s to [%s]", __func__, fieldname, g_utf16_to_utf8 (val, len, NULL, NULL, NULL)));
 114
 115         string=mono_string_new_utf16 (mono_object_domain (obj), val, len);
 116
 117         field=mono_class_get_field_from_name (mono_object_class (obj),
 118                                               fieldname);
 119         mono_gc_wbarrier_generic_store (((char *)obj) + field->offset, (MonoObject*)string);
 120 }
 121
 122 static void process_set_field_int (MonoObject *obj, const gchar *fieldname,
 123                                    guint32 val)
 124 {
 125         MonoClassField *field;
 126
 127         LOGDEBUG (g_message ("%s: Setting field %s to %d", __func__,fieldname, val));
 128
 129         field=mono_class_get_field_from_name (mono_object_class (obj),
 130                                               fieldname);
 131         *(guint32 *)(((char *)obj) + field->offset)=val;
 132 }
 133
 134 static void process_set_field_intptr (MonoObject *obj, const gchar *fieldname,
 135                                       gpointer val)
 136 {
 137         MonoClassField *field;
 138
 139         LOGDEBUG (g_message ("%s: Setting field %s to %p", __func__, fieldname, val));
 140
 141         field=mono_class_get_field_from_name (mono_object_class (obj),
 142                                               fieldname);
 143         *(gpointer *)(((char *)obj) + field->offset)=val;
 144 }
 145
 146 static void process_set_field_bool (MonoObject *obj, const gchar *fieldname,
 147                                     gboolean val)
 148 {
 149         MonoClassField *field;
 150
 151         LOGDEBUG (g_message ("%s: Setting field %s to %s", __func__, fieldname, val?"TRUE":"FALSE"));
 152
 153         field=mono_class_get_field_from_name (mono_object_class (obj),
 154                                               fieldname);
 155         *(guint8 *)(((char *)obj) + field->offset)=val;
 156 }
 157
 158 #define SFI_COMMENTS            "\\StringFileInfo\\%02X%02X%02X%02X\\Comments"
 159 #define SFI_COMPANYNAME         "\\StringFileInfo\\%02X%02X%02X%02X\\CompanyName"
 160 #define SFI_FILEDESCRIPTION     "\\StringFileInfo\\%02X%02X%02X%02X\\FileDescription"
 161 #define SFI_FILEVERSION         "\\StringFileInfo\\%02X%02X%02X%02X\\FileVersion"
 162 #define SFI_INTERNALNAME        "\\StringFileInfo\\%02X%02X%02X%02X\\InternalName"
 163 #define SFI_LEGALCOPYRIGHT      "\\StringFileInfo\\%02X%02X%02X%02X\\LegalCopyright"
 164 #define SFI_LEGALTRADEMARKS     "\\StringFileInfo\\%02X%02X%02X%02X\\LegalTrademarks"
 165 #define SFI_ORIGINALFILENAME    "\\StringFileInfo\\%02X%02X%02X%02X\\OriginalFilename"
 166 #define SFI_PRIVATEBUILD        "\\StringFileInfo\\%02X%02X%02X%02X\\PrivateBuild"
 167 #define SFI_PRODUCTNAME         "\\StringFileInfo\\%02X%02X%02X%02X\\ProductName"
 168 #define SFI_PRODUCTVERSION      "\\StringFileInfo\\%02X%02X%02X%02X\\ProductVersion"
 169 #define SFI_SPECIALBUILD        "\\StringFileInfo\\%02X%02X%02X%02X\\SpecialBuild"
 170 #define EMPTY_STRING            (gunichar2*)"\000\000"
 171
 172 static void process_module_string_read (MonoObject *filever, gpointer data,
 173                                         const gchar *fieldname,
 174                                         guchar lang_hi, guchar lang_lo,
 175                                         const gchar *key)
 176 {
 177         gchar *lang_key_utf8;
 178         gunichar2 *lang_key, *buffer;
 179         UINT chars;
 180
 181         lang_key_utf8 = g_strdup_printf (key, lang_lo, lang_hi, 0x04, 0xb0);
 182
 183         LOGDEBUG (g_message ("%s: asking for [%s]", __func__, lang_key_utf8));
 184
 185         lang_key = g_utf8_to_utf16 (lang_key_utf8, -1, NULL, NULL, NULL);
 186
 187         if (VerQueryValue (data, lang_key, (gpointer *)&buffer, &chars) && chars > 0) {
 188                 LOGDEBUG (g_message ("%s: found %d chars of [%s]", __func__, chars, g_utf16_to_utf8 (buffer, chars, NULL, NULL, NULL)));
 189                 /* chars includes trailing null */
 190                 process_set_field_string (filever, fieldname, buffer, chars - 1);
 191         } else {
 192                 process_set_field_string (filever, fieldname, EMPTY_STRING, 0);
 193         }
 194
 195         g_free (lang_key);
 196         g_free (lang_key_utf8);
 197 }
 198
 199 static void process_module_stringtable (MonoObject *filever, gpointer data,
 200                                         guchar lang_hi, guchar lang_lo)
 201 {
 202         process_module_string_read (filever, data, "comments", lang_hi, lang_lo,
 203                                     SFI_COMMENTS);
 204         process_module_string_read (filever, data, "companyname", lang_hi,
 205                                     lang_lo, SFI_COMPANYNAME);
 206         process_module_string_read (filever, data, "filedescription", lang_hi,
 207                                     lang_lo, SFI_FILEDESCRIPTION);
 208         process_module_string_read (filever, data, "fileversion", lang_hi,
 209                                     lang_lo, SFI_FILEVERSION);
 210         process_module_string_read (filever, data, "internalname", lang_hi,
 211                                     lang_lo, SFI_INTERNALNAME);
 212         process_module_string_read (filever, data, "legalcopyright", lang_hi,
 213                                     lang_lo, SFI_LEGALCOPYRIGHT);
 214         process_module_string_read (filever, data, "legaltrademarks", lang_hi,
 215                                     lang_lo, SFI_LEGALTRADEMARKS);
 216         process_module_string_read (filever, data, "originalfilename", lang_hi,
 217                                     lang_lo, SFI_ORIGINALFILENAME);
 218         process_module_string_read (filever, data, "privatebuild", lang_hi,
 219                                     lang_lo, SFI_PRIVATEBUILD);
 220         process_module_string_read (filever, data, "productname", lang_hi,
 221                                     lang_lo, SFI_PRODUCTNAME);
 222         process_module_string_read (filever, data, "productversion", lang_hi,
 223                                     lang_lo, SFI_PRODUCTVERSION);
 224         process_module_string_read (filever, data, "specialbuild", lang_hi,
 225                                     lang_lo, SFI_SPECIALBUILD);
 226 }
 227
 228 static void process_get_fileversion (MonoObject *filever, gunichar2 *filename)
 229 {
 230         DWORD verinfohandle;
 231         VS_FIXEDFILEINFO *ffi;
 232         gpointer data;
 233         DWORD datalen;
 234         guchar *trans_data;
 235         gunichar2 *query;
 236         UINT ffi_size, trans_size;
 237         BOOL ok;
 238         gunichar2 lang_buf[128];
 239         guint32 lang, lang_count;
 240
 241         datalen = GetFileVersionInfoSize (filename, &verinfohandle);
 242         if (datalen) {
 243                 data = g_malloc0 (datalen);
 244                 ok = GetFileVersionInfo (filename, verinfohandle, datalen,
 245                                          data);
 246                 if (ok) {
 247                         query = g_utf8_to_utf16 ("\\", -1, NULL, NULL, NULL);
 248                         if (query == NULL) {
 249                                 g_free (data);
 250                                 return;
 251                         }
 252
 253                         if (VerQueryValue (data, query, (gpointer *)&ffi,
 254                             &ffi_size)) {
 255                                 LOGDEBUG (g_message ("%s: recording assembly: FileName [%s] FileVersionInfo [%d.%d.%d.%d]", __func__, g_utf16_to_utf8 (filename, -1, NULL, NULL, NULL), HIWORD (ffi->dwFileVersionMS), LOWORD (ffi->dwFileVersionMS), HIWORD (ffi->dwFileVersionLS), LOWORD (ffi->dwFileVersionLS)));
 256
 257                                 process_set_field_int (filever, "filemajorpart", HIWORD (ffi->dwFileVersionMS));
 258                                 process_set_field_int (filever, "fileminorpart", LOWORD (ffi->dwFileVersionMS));
 259                                 process_set_field_int (filever, "filebuildpart", HIWORD (ffi->dwFileVersionLS));
 260                                 process_set_field_int (filever, "fileprivatepart", LOWORD (ffi->dwFileVersionLS));
 261
 262                                 process_set_field_int (filever, "productmajorpart", HIWORD (ffi->dwProductVersionMS));
 263                                 process_set_field_int (filever, "productminorpart", LOWORD (ffi->dwProductVersionMS));
 264                                 process_set_field_int (filever, "productbuildpart", HIWORD (ffi->dwProductVersionLS));
 265                                 process_set_field_int (filever, "productprivatepart", LOWORD (ffi->dwProductVersionLS));
 266
 267                                 process_set_field_bool (filever, "isdebug", (ffi->dwFileFlags & ffi->dwFileFlagsMask) & VS_FF_DEBUG);
 268                                 process_set_field_bool (filever, "isprerelease", (ffi->dwFileFlags & ffi->dwFileFlagsMask) & VS_FF_PRERELEASE);
 269                                 process_set_field_bool (filever, "ispatched", (ffi->dwFileFlags & ffi->dwFileFlagsMask) & VS_FF_PATCHED);
 270                                 process_set_field_bool (filever, "isprivatebuild", (ffi->dwFileFlags & ffi->dwFileFlagsMask) & VS_FF_PRIVATEBUILD);
 271                                 process_set_field_bool (filever, "isspecialbuild", (ffi->dwFileFlags & ffi->dwFileFlagsMask) & VS_FF_SPECIALBUILD);
 272                         }
 273                         g_free (query);
 274
 275                         query = g_utf8_to_utf16 ("\\VarFileInfo\\Translation", -1, NULL, NULL, NULL);
 276                         if (query == NULL) {
 277                                 g_free (data);
 278                                 return;
 279                         }
 280
 281                         if (VerQueryValue (data, query,
 282                                            (gpointer *)&trans_data,
 283                                            &trans_size)) {
 284                                 /* use the first language ID we see
 285                                  */
 286                                 if (trans_size >= 4) {
 287                                         LOGDEBUG (g_message("%s: %s has 0x%0x 0x%0x 0x%0x 0x%0x", __func__, g_utf16_to_utf8 (filename, -1, NULL, NULL, NULL), trans_data[0], trans_data[1], trans_data[2], trans_data[3]));
 288                                         lang = (trans_data[0]) |
 289                                                 (trans_data[1] << 8) |
 290                                                 (trans_data[2] << 16) |
 291                                                 (trans_data[3] << 24);
 292                                         /* Only give the lower 16 bits
 293                                          * to VerLanguageName, as
 294                                          * Windows gets confused
 295                                          * otherwise
 296                                          */
 297                                         lang_count = VerLanguageName (lang & 0xFFFF, lang_buf, 128);
 298                                         if (lang_count) {
 299                                                 process_set_field_string (filever, "language", lang_buf, lang_count);
 300                                         }
 301                                         process_module_stringtable (filever, data, trans_data[0], trans_data[1]);
 302                                 }
 303                         } else {
 304                                 /* No strings, so set every field to
 305                                  * the empty string
 306                                  */
 307                                 process_set_field_string (filever,
 308                                                           "comments",
 309                                                           EMPTY_STRING, 0);
 310                                 process_set_field_string (filever,
 311                                                           "companyname",
 312                                                           EMPTY_STRING, 0);
 313                                 process_set_field_string (filever,
 314                                                           "filedescription",
 315                                                           EMPTY_STRING, 0);
 316                                 process_set_field_string (filever,
 317                                                           "fileversion",
 318                                                           EMPTY_STRING, 0);
 319                                 process_set_field_string (filever,
 320                                                           "internalname",
 321                                                           EMPTY_STRING, 0);
 322                                 process_set_field_string (filever,
 323                                                           "legalcopyright",
 324                                                           EMPTY_STRING, 0);
 325                                 process_set_field_string (filever,
 326                                                           "legaltrademarks",
 327                                                           EMPTY_STRING, 0);
 328                                 process_set_field_string (filever,
 329                                                           "originalfilename",
 330                                                           EMPTY_STRING, 0);
 331                                 process_set_field_string (filever,
 332                                                           "privatebuild",
 333                                                           EMPTY_STRING, 0);
 334                                 process_set_field_string (filever,
 335                                                           "productname",
 336                                                           EMPTY_STRING, 0);
 337                                 process_set_field_string (filever,
 338                                                           "productversion",
 339                                                           EMPTY_STRING, 0);
 340                                 process_set_field_string (filever,
 341                                                           "specialbuild",
 342                                                           EMPTY_STRING, 0);
 343
 344                                 /* And language seems to be set to
 345                                  * en_US according to bug 374600
 346                                  */
 347                                 lang_count = VerLanguageName (0x0409, lang_buf, 128);
 348                                 if (lang_count) {
 349                                         process_set_field_string (filever, "language", lang_buf, lang_count);
 350                                 }
 351                         }
 352
 353                         g_free (query);
 354                 }
 355                 g_free (data);
 356         }
 357 }
 358
 359 static MonoObject* process_add_module (HANDLE process, HMODULE mod, gunichar2 *filename, gunichar2 *modulename)
 360 {
 361         MonoClass *proc_class, *filever_class;
 362         MonoObject *item, *filever;
 363         MonoDomain *domain=mono_domain_get ();
 364         MODULEINFO modinfo;
 365         BOOL ok;
 366
 367         /* Build a System.Diagnostics.ProcessModule with the data.
 368          */
 369         proc_class=mono_class_from_name (system_assembly, "System.Diagnostics",
 370                                          "ProcessModule");
 371         item=mono_object_new (domain, proc_class);
 372
 373         filever_class=mono_class_from_name (system_assembly,
 374                                             "System.Diagnostics",
 375                                             "FileVersionInfo");
 376         filever=mono_object_new (domain, filever_class);
 377
 378         process_get_fileversion (filever, filename);
 379
 380         process_set_field_string (filever, "filename", filename,
 381                                   unicode_chars (filename));
 382
 383         ok = GetModuleInformation (process, mod, &modinfo, sizeof(MODULEINFO));
 384         if (ok) {
 385                 process_set_field_intptr (item, "baseaddr",
 386                                           modinfo.lpBaseOfDll);
 387                 process_set_field_intptr (item, "entryaddr",
 388                                           modinfo.EntryPoint);
 389                 process_set_field_int (item, "memory_size",
 390                                        modinfo.SizeOfImage);
 391         }
 392         process_set_field_string (item, "filename", filename,
 393                                   unicode_chars (filename));
 394         process_set_field_string (item, "modulename", modulename,
 395                                   unicode_chars (modulename));
 396         process_set_field_object (item, "version_info", filever);
 397
 398         return item;
 399 }
 400
 401 /* Returns an array of System.Diagnostics.ProcessModule */
 402 MonoArray *ves_icall_System_Diagnostics_Process_GetModules_internal (MonoObject *this, HANDLE process)
 403 {
 404         MonoArray *temp_arr = NULL;
 405         MonoArray *arr;
 406         HMODULE mods[1024];
 407         gunichar2 filename[MAX_PATH];
 408         gunichar2 modname[MAX_PATH];
 409         DWORD needed;
 410         guint32 count = 0;
 411         guint32 i, num_added = 0;
 412
 413         STASH_SYS_ASS (this);
 414
 415         if (EnumProcessModules (process, mods, sizeof(mods), &needed)) {
 416                 count = needed / sizeof(HMODULE);
 417                 temp_arr = mono_array_new (mono_domain_get (), mono_get_object_class (), count);
 418                 for (i = 0; i < count; i++) {
 419                         if (GetModuleBaseName (process, mods[i], modname, MAX_PATH) &&
 420                                         GetModuleFileNameEx (process, mods[i], filename, MAX_PATH)) {
 421                                 MonoObject *module = process_add_module (process, mods[i],
 422                                                 filename, modname);
 423                                 mono_array_setref (temp_arr, num_added++, module);
 424                         }
 425                 }
 426         }
 427
 428         if (count == num_added) {
 429                 arr = temp_arr;
 430         } else {
 431                 /* shorter version of the array */
 432                 arr = mono_array_new (mono_domain_get (), mono_get_object_class (), num_added);
 433
 434                 for (i = 0; i < num_added; i++)
 435                         mono_array_setref (arr, i, mono_array_get (temp_arr, MonoObject*, i));
 436         }
 437
 438         return arr;
 439 }
 440
 441 void ves_icall_System_Diagnostics_FileVersionInfo_GetVersionInfo_internal (MonoObject *this, MonoString *filename)
 442 {
 443         MONO_ARCH_SAVE_REGS;
 444
 445         STASH_SYS_ASS (this);
 446
 447         process_get_fileversion (this, mono_string_chars (filename));
 448         process_set_field_string (this, "filename",
 449                                   mono_string_chars (filename),
 450                                   mono_string_length (filename));
 451 }
 452
 453 /* Only used when UseShellExecute is false */
 454 static gchar *
 455 quote_path (const gchar *path)
 456 {
 457         gchar *res = g_shell_quote (path);
 458 #ifdef TARGET_WIN32
 459         {
 460         gchar *q = res;
 461         while (*q) {
 462                 if (*q == '\'')
 463                         *q = '\"';
 464                 q++;
 465         }
 466         }
 467 #endif
 468         return res;
 469 }
 470
 471 /* Only used when UseShellExecute is false */
 472 static gboolean
 473 complete_path (const gunichar2 *appname, gchar **completed)
 474 {
 475         gchar *utf8app, *utf8appmemory;
 476         gchar *found;
 477
 478         utf8appmemory = utf8app = g_utf16_to_utf8 (appname, -1, NULL, NULL, NULL);
 479 #ifdef TARGET_WIN32 // Should this happen on all platforms?
 480         {
 481                 // remove the quotes around utf8app.
 482                 size_t len;
 483                 len = strlen (utf8app);
 484                 if (len) {
 485                         if (utf8app[len-1] == '\"')
 486                                 utf8app[len-1] = '\0';
 487                         if (utf8app[0] == '\"')
 488                                 utf8app++;
 489                 }
 490         }
 491 #endif
 492
 493         if (g_path_is_absolute (utf8app)) {
 494                 *completed = quote_path (utf8app);
 495                 g_free (utf8appmemory);
 496                 return TRUE;
 497         }
 498
 499         if (g_file_test (utf8app, G_FILE_TEST_IS_EXECUTABLE) && !g_file_test (utf8app, G_FILE_TEST_IS_DIR)) {
 500                 *completed = quote_path (utf8app);
 501                 g_free (utf8appmemory);
 502                 return TRUE;
 503         }
 504
 505         found = g_find_program_in_path (utf8app);
 506         if (found == NULL) {
 507                 *completed = NULL;
 508                 g_free (utf8appmemory);
 509                 return FALSE;
 510         }
 511
 512         *completed = quote_path (found);
 513         g_free (found);
 514         g_free (utf8appmemory);
 515         return TRUE;
 516 }
 517
 518 MonoBoolean ves_icall_System_Diagnostics_Process_ShellExecuteEx_internal (MonoProcessStartInfo *proc_start_info, MonoProcInfo *process_info)
 519 {
 520         SHELLEXECUTEINFO shellex = {0};
 521         gboolean ret;
 522
 523         shellex.cbSize = sizeof(SHELLEXECUTEINFO);
 524         shellex.fMask = SEE_MASK_FLAG_DDEWAIT | SEE_MASK_NOCLOSEPROCESS | SEE_MASK_UNICODE;
 525         shellex.nShow = proc_start_info->window_style;
 526         shellex.nShow = (shellex.nShow == 0) ? 1 : (shellex.nShow == 1 ? 0 : shellex.nShow);
 527
 528
 529         if (proc_start_info->filename != NULL) {
 530                 shellex.lpFile = mono_string_chars (proc_start_info->filename);
 531         }
 532
 533         if (proc_start_info->arguments != NULL) {
 534                 shellex.lpParameters = mono_string_chars (proc_start_info->arguments);
 535         }
 536
 537         if (proc_start_info->verb != NULL &&
 538             mono_string_length (proc_start_info->verb) != 0) {
 539                 shellex.lpVerb = mono_string_chars (proc_start_info->verb);
 540         }
 541
 542         if (proc_start_info->working_directory != NULL &&
 543             mono_string_length (proc_start_info->working_directory) != 0) {
 544                 shellex.lpDirectory = mono_string_chars (proc_start_info->working_directory);
 545         }
 546
 547         if (proc_start_info->error_dialog) {
 548                 shellex.hwnd = proc_start_info->error_dialog_parent_handle;
 549         } else {
 550                 shellex.fMask |= SEE_MASK_FLAG_NO_UI;
 551         }
 552
 553         ret = ShellExecuteEx (&shellex);
 554         if (ret == FALSE) {
 555                 process_info->pid = -GetLastError ();
 556         } else {
 557                 process_info->process_handle = shellex.hProcess;
 558                 process_info->thread_handle = NULL;
 559                 /* It appears that there's no way to get the pid from a
 560                  * process handle before windows xp.  Really.
 561                  */
 562 #if defined(HAVE_GETPROCESSID) && !defined(MONO_CROSS_COMPILE)
 563                 process_info->pid = GetProcessId (shellex.hProcess);
 564 #else
 565                 process_info->pid = 0;
 566 #endif
 567                 process_info->tid = 0;
 568         }
 569
 570         return (ret);
 571 }
 572
 573 MonoBoolean ves_icall_System_Diagnostics_Process_CreateProcess_internal (MonoProcessStartInfo *proc_start_info, HANDLE stdin_handle, HANDLE stdout_handle, HANDLE stderr_handle, MonoProcInfo *process_info)
 574 {
 575         gboolean ret;
 576         gunichar2 *dir;
 577         STARTUPINFO startinfo={0};
 578         PROCESS_INFORMATION procinfo;
 579         gunichar2 *shell_path = NULL;
 580         gchar *env_vars = NULL;
 581         gboolean free_shell_path = TRUE;
 582         gchar *spath = NULL;
 583         MonoString *cmd = proc_start_info->arguments;
 584         guint32 creation_flags, logon_flags;
 585
 586         startinfo.cb=sizeof(STARTUPINFO);
 587         startinfo.dwFlags=STARTF_USESTDHANDLES;
 588         startinfo.hStdInput=stdin_handle;
 589         startinfo.hStdOutput=stdout_handle;
 590         startinfo.hStdError=stderr_handle;
 591
 592         creation_flags = CREATE_UNICODE_ENVIRONMENT;
 593         if (proc_start_info->create_no_window)
 594                 creation_flags |= CREATE_NO_WINDOW;
 595
 596         shell_path = mono_string_chars (proc_start_info->filename);
 597         complete_path (shell_path, &spath);
 598         if (spath == NULL) {
 599                 process_info->pid = -ERROR_FILE_NOT_FOUND;
 600                 return FALSE;
 601         }
 602 #ifdef TARGET_WIN32
 603         /* Seems like our CreateProcess does not work as the windows one.
 604          * This hack is needed to deal with paths containing spaces */
 605         shell_path = NULL;
 606         free_shell_path = FALSE;
 607         if (cmd) {
 608                 gchar *newcmd, *tmp;
 609                 tmp = mono_string_to_utf8 (cmd);
 610                 newcmd = g_strdup_printf ("%s %s", spath, tmp);
 611                 cmd = mono_string_new_wrapper (newcmd);
 612                 g_free (tmp);
 613                 g_free (newcmd);
 614         }
 615         else {
 616                 cmd = mono_string_new_wrapper (spath);
 617         }
 618 #else
 619         shell_path = g_utf8_to_utf16 (spath, -1, NULL, NULL, NULL);
 620 #endif
 621         g_free (spath);
 622
 623         if (process_info->env_keys != NULL) {
 624                 gint i, len;
 625                 MonoString *ms;
 626                 MonoString *key, *value;
 627                 gunichar2 *str, *ptr;
 628                 gunichar2 *equals16;
 629
 630                 for (len = 0, i = 0; i < mono_array_length (process_info->env_keys); i++) {
 631                         ms = mono_array_get (process_info->env_values, MonoString *, i);
 632                         if (ms == NULL)
 633                                 continue;
 634
 635                         len += mono_string_length (ms) * sizeof (gunichar2);
 636                         ms = mono_array_get (process_info->env_keys, MonoString *, i);
 637                         len += mono_string_length (ms) * sizeof (gunichar2);
 638                         len += 2 * sizeof (gunichar2);
 639                 }
 640
 641                 equals16 = g_utf8_to_utf16 ("=", 1, NULL, NULL, NULL);
 642                 ptr = str = g_new0 (gunichar2, len + 1);
 643                 for (i = 0; i < mono_array_length (process_info->env_keys); i++) {
 644                         value = mono_array_get (process_info->env_values, MonoString *, i);
 645                         if (value == NULL)
 646                                 continue;
 647
 648                         key = mono_array_get (process_info->env_keys, MonoString *, i);
 649                         memcpy (ptr, mono_string_chars (key), mono_string_length (key) * sizeof (gunichar2));
 650                         ptr += mono_string_length (key);
 651
 652                         memcpy (ptr, equals16, sizeof (gunichar2));
 653                         ptr++;
 654
 655                         memcpy (ptr, mono_string_chars (value), mono_string_length (value) * sizeof (gunichar2));
 656                         ptr += mono_string_length (value);
 657                         ptr++;
 658                 }
 659
 660                 g_free (equals16);
 661                 env_vars = (gchar *) str;
 662         }
 663
 664         /* The default dir name is "".  Turn that into NULL to mean
 665          * "current directory"
 666          */
 667         if(proc_start_info->working_directory == NULL || mono_string_length (proc_start_info->working_directory)==0) {
 668                 dir=NULL;
 669         } else {
 670                 dir=mono_string_chars (proc_start_info->working_directory);
 671         }
 672
 673         if (process_info->username) {
 674                 logon_flags = process_info->load_user_profile ? LOGON_WITH_PROFILE : 0;
 675                 ret=CreateProcessWithLogonW (mono_string_chars (process_info->username), process_info->domain ? mono_string_chars (process_info->domain) : NULL, process_info->password, logon_flags, shell_path, cmd? mono_string_chars (cmd): NULL, creation_flags, env_vars, dir, &startinfo, &procinfo);
 676         } else {
 677                 ret=CreateProcess (shell_path, cmd? mono_string_chars (cmd): NULL, NULL, NULL, TRUE, creation_flags, env_vars, dir, &startinfo, &procinfo);
 678         }
 679
 680         g_free (env_vars);
 681         if (free_shell_path)
 682                 g_free (shell_path);
 683
 684         if(ret) {
 685                 process_info->process_handle=procinfo.hProcess;
 686                 /*process_info->thread_handle=procinfo.hThread;*/
 687                 process_info->thread_handle=NULL;
 688                 if (procinfo.hThread != NULL && procinfo.hThread != INVALID_HANDLE_VALUE)
 689                         CloseHandle(procinfo.hThread);
 690                 process_info->pid=procinfo.dwProcessId;
 691                 process_info->tid=procinfo.dwThreadId;
 692         } else {
 693                 process_info->pid = -GetLastError ();
 694         }
 695
 696         return(ret);
 697 }
 698
 699 MonoBoolean ves_icall_System_Diagnostics_Process_WaitForExit_internal (MonoObject *this, HANDLE process, gint32 ms)
 700 {
 701         guint32 ret;
 702
 703         MONO_ARCH_SAVE_REGS;
 704
 705         if(ms<0) {
 706                 /* Wait forever */
 707                 ret=WaitForSingleObjectEx (process, INFINITE, TRUE);
 708         } else {
 709                 ret=WaitForSingleObjectEx (process, ms, TRUE);
 710         }
 711         if(ret==WAIT_OBJECT_0) {
 712                 return(TRUE);
 713         } else {
 714                 return(FALSE);
 715         }
 716 }
 717
 718 MonoBoolean ves_icall_System_Diagnostics_Process_WaitForInputIdle_internal (MonoObject *this, HANDLE process, gint32 ms)
 719 {
 720         guint32 ret;
 721
 722         MONO_ARCH_SAVE_REGS;
 723
 724         if(ms<0) {
 725                 /* Wait forever */
 726                 ret=WaitForInputIdle (process, INFINITE);
 727         } else {
 728                 ret=WaitForInputIdle (process, ms);
 729         }
 730
 731         return (ret) ? FALSE : TRUE;
 732 }
 733
 734 static guint64
 735 file_time_to_guint64 (FILETIME *time)
 736 {
 737         return ((guint64)time->dwHighDateTime << 32) | ((guint64)time->dwLowDateTime);
 738 }
 739
 740 gint64 ves_icall_System_Diagnostics_Process_ExitTime_internal (HANDLE process)
 741 {
 742         gboolean ret;
 743         FILETIME create_time, exit_time, kernel_time, user_time;
 744
 745         MONO_ARCH_SAVE_REGS;
 746
 747         ret = GetProcessTimes (process, &create_time, &exit_time, &kernel_time,
 748                                                    &user_time);
 749         if (ret)
 750                 return file_time_to_guint64 (&exit_time);
 751         else
 752                 return 0;
 753 }
 754
 755 gint64 ves_icall_System_Diagnostics_Process_StartTime_internal (HANDLE process)
 756 {
 757         gboolean ret;
 758         FILETIME create_time, exit_time, kernel_time, user_time;
 759
 760         MONO_ARCH_SAVE_REGS;
 761
 762         ret = GetProcessTimes (process, &create_time, &exit_time, &kernel_time,
 763                                                    &user_time);
 764         if (ret)
 765                 return file_time_to_guint64 (&create_time);
 766         else
 767                 return 0;
 768 }
 769
 770 gint32 ves_icall_System_Diagnostics_Process_ExitCode_internal (HANDLE process)
 771 {
 772         DWORD code;
 773
 774         MONO_ARCH_SAVE_REGS;
 775
 776         GetExitCodeProcess (process, &code);
 777
 778         LOGDEBUG (g_message ("%s: process exit code is %d", __func__, code));
 779
 780         return(code);
 781 }
 782
 783 MonoString *ves_icall_System_Diagnostics_Process_ProcessName_internal (HANDLE process)
 784 {
 785         MonoString *string;
 786         gboolean ok;
 787         HMODULE mod;
 788         gunichar2 name[MAX_PATH];
 789         DWORD needed;
 790         guint32 len;
 791
 792         MONO_ARCH_SAVE_REGS;
 793
 794         ok=EnumProcessModules (process, &mod, sizeof(mod), &needed);
 795         if(ok==FALSE) {
 796                 return(NULL);
 797         }
 798
 799         len=GetModuleBaseName (process, mod, name, MAX_PATH);
 800         if(len==0) {
 801                 return(NULL);
 802         }
 803
 804         LOGDEBUG (g_message ("%s: process name is [%s]", __func__, g_utf16_to_utf8 (name, -1, NULL, NULL, NULL)));
 805
 806         string=mono_string_new_utf16 (mono_domain_get (), name, len);
 807
 808         return(string);
 809 }
 810
 811 /* Returns an array of pids */
 812 MonoArray *ves_icall_System_Diagnostics_Process_GetProcesses_internal (void)
 813 {
 814 #if !defined(HOST_WIN32)
 815         MonoArray *procs;
 816         gpointer *pidarray;
 817         int i, count;
 818
 819         MONO_ARCH_SAVE_REGS;
 820
 821         pidarray = mono_process_list (&count);
 822         if (!pidarray)
 823                 mono_raise_exception (mono_get_exception_not_supported ("This system does not support EnumProcesses"));
 824         procs = mono_array_new (mono_domain_get (), mono_get_int32_class (), count);
 825         if (sizeof (guint32) == sizeof (gpointer)) {
 826                 memcpy (mono_array_addr (procs, guint32, 0), pidarray, count);
 827         } else {
 828                 for (i = 0; i < count; ++i)
 829                         *(mono_array_addr (procs, guint32, i)) = GPOINTER_TO_UINT (pidarray [i]);
 830         }
 831         g_free (pidarray);
 832
 833         return procs;
 834 #else
 835         MonoArray *procs;
 836         gboolean ret;
 837         DWORD needed;
 838         int count;
 839         guint32 *pids;
 840
 841         count = 512;
 842         do {
 843                 pids = g_new0 (guint32, count);
 844                 ret = EnumProcesses (pids, count * sizeof (guint32), &needed);
 845                 if (ret == FALSE) {
 846                         MonoException *exc;
 847
 848                         g_free (pids);
 849                         pids = NULL;
 850                         exc = mono_get_exception_not_supported ("This system does not support EnumProcesses");
 851                         mono_raise_exception (exc);
 852                         g_assert_not_reached ();
 853                 }
 854                 if (needed < (count * sizeof (guint32)))
 855                         break;
 856                 g_free (pids);
 857                 pids = NULL;
 858                 count = (count * 3) / 2;
 859         } while (TRUE);
 860
 861         count = needed / sizeof (guint32);
 862         procs = mono_array_new (mono_domain_get (), mono_get_int32_class (), count);
 863         memcpy (mono_array_addr (procs, guint32, 0), pids, needed);
 864         g_free (pids);
 865         pids = NULL;
 866
 867         return procs;
 868 #endif
 869 }
 870
 871 MonoBoolean ves_icall_System_Diagnostics_Process_GetWorkingSet_internal (HANDLE process, guint32 *min, guint32 *max)
 872 {
 873         gboolean ret;
 874         SIZE_T ws_min, ws_max;
 875
 876         MONO_ARCH_SAVE_REGS;
 877
 878         ret=GetProcessWorkingSetSize (process, &ws_min, &ws_max);
 879         *min=(guint32)ws_min;
 880         *max=(guint32)ws_max;
 881
 882         return(ret);
 883 }
 884
 885 MonoBoolean ves_icall_System_Diagnostics_Process_SetWorkingSet_internal (HANDLE process, guint32 min, guint32 max, MonoBoolean use_min)
 886 {
 887         gboolean ret;
 888         SIZE_T ws_min;
 889         SIZE_T ws_max;
 890
 891         MONO_ARCH_SAVE_REGS;
 892
 893         ret=GetProcessWorkingSetSize (process, &ws_min, &ws_max);
 894         if(ret==FALSE) {
 895                 return(FALSE);
 896         }
 897
 898         if(use_min==TRUE) {
 899                 ws_min=(SIZE_T)min;
 900         } else {
 901                 ws_max=(SIZE_T)max;
 902         }
 903
 904         ret=SetProcessWorkingSetSize (process, ws_min, ws_max);
 905
 906         return(ret);
 907 }
 908
 909 MonoBoolean
 910 ves_icall_System_Diagnostics_Process_Kill_internal (HANDLE process, gint32 sig)
 911 {
 912         MONO_ARCH_SAVE_REGS;
 913
 914         /* sig == 1 -> Kill, sig == 2 -> CloseMainWindow */
 915
 916         return TerminateProcess (process, -sig);
 917 }
 918
 919 gint64
 920 ves_icall_System_Diagnostics_Process_Times (HANDLE process, gint32 type)
 921 {
 922         FILETIME create_time, exit_time, kernel_time, user_time;
 923
 924         if (GetProcessTimes (process, &create_time, &exit_time, &kernel_time, &user_time)) {
 925                 guint64 ktime = file_time_to_guint64 (&kernel_time);
 926                 guint64 utime = file_time_to_guint64 (&user_time);
 927
 928                 if (type == 0)
 929                         return utime;
 930                 else if (type == 1)
 931                         return ktime;
 932                 else
 933                         return ktime + utime;
 934         }
 935         return 0;
 936 }
 937
 938 gint32
 939 ves_icall_System_Diagnostics_Process_GetPriorityClass (HANDLE process, gint32 *error)
 940 {
 941         gint32 ret = GetPriorityClass (process);
 942         *error = ret == 0 ? GetLastError () : 0;
 943         return ret;
 944 }
 945
 946 MonoBoolean
 947 ves_icall_System_Diagnostics_Process_SetPriorityClass (HANDLE process, gint32 priority_class, gint32 *error)
 948 {
 949         gboolean ret = SetPriorityClass (process, priority_class);
 950         *error = ret == 0 ? GetLastError () : 0;
 951         return ret;
 952 }
 953
 954 HANDLE
 955 ves_icall_System_Diagnostics_Process_ProcessHandle_duplicate (HANDLE process)
 956 {
 957         HANDLE ret;
 958
 959         MONO_ARCH_SAVE_REGS;
 960
 961         LOGDEBUG (g_message ("%s: Duplicating process handle %p", __func__, process));
 962
 963         DuplicateHandle (GetCurrentProcess (), process, GetCurrentProcess (),
 964                          &ret, THREAD_ALL_ACCESS, TRUE, 0);
 965
 966         return ret;
 967 }
 968
 969 void
 970 ves_icall_System_Diagnostics_Process_ProcessHandle_close (HANDLE process)
 971 {
 972         MONO_ARCH_SAVE_REGS;
 973
 974         LOGDEBUG (g_message ("%s: Closing process handle %p", __func__, process));
 975
 976         CloseHandle (process);
 977 }
 978
 979 gint64
 980 ves_icall_System_Diagnostics_Process_GetProcessData (int pid, gint32 data_type, gint32 *error)
 981 {
 982         MonoProcessError perror;
 983         guint64 res;
 984
 985         res = mono_process_get_data_with_error (GINT_TO_POINTER (pid), data_type, &perror);
 986         if (error)
 987                 *error = perror;
 988         return res;
 989 }
 990