mono/metadata/w32process.c

   1 /**
   2  * \file
   3  */
   4
   5 #include <glib.h>
   6
   7 #include "w32process.h"
   8 #include "w32process-internals.h"
   9 #include "w32process-win32-internals.h"
  10 #include "w32file.h"
  11 #include "object.h"
  12 #include "object-internals.h"
  13 #include "class.h"
  14 #include "class-internals.h"
  15 #include "image.h"
  16 #include "utils/mono-proclib.h"
  17 #include "utils/w32api.h"
  18 #include "icall-decl.h"
  19
  20 #define LOGDEBUG(...)
  21 /* define LOGDEBUG(...) g_message(__VA_ARGS__)  */
  22
  23 #if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT) && defined(HOST_WIN32)
  24
  25 static guint32
  26 mono_w32process_get_pid (gpointer handle)
  27 {
  28         return GetProcessId (handle);
  29 }
  30
  31 static gboolean
  32 mono_w32process_try_get_modules (gpointer process, HMODULE *modules, guint32 size, PDWORD needed)
  33 {
  34         return EnumProcessModules (process, modules, size, needed);
  35 }
  36
  37 static guint32
  38 mono_w32process_module_get_name (gpointer process, gpointer module, gunichar2 *basename, guint32 size)
  39 {
  40         return GetModuleBaseName (process, (HMODULE)module, basename, size);
  41 }
  42
  43 static guint32
  44 mono_w32process_module_get_filename (gpointer process, gpointer module, gunichar2 *basename, guint32 size)
  45 {
  46         return GetModuleFileNameEx (process, (HMODULE)module, basename, size);
  47 }
  48
  49 static gboolean
  50 mono_w32process_module_get_information (gpointer process, gpointer module, MODULEINFO *modinfo, guint32 size)
  51 {
  52         return GetModuleInformation (process, (HMODULE)module, modinfo, size);
  53 }
  54
  55 static gboolean
  56 mono_w32process_get_fileversion_info (const gunichar2 *filename, gpointer *data)
  57 {
  58         DWORD handle;
  59         gsize datasize;
  60
  61         g_assert (data);
  62         *data = NULL;
  63
  64         datasize = GetFileVersionInfoSize (filename, &handle);
  65         if (datasize <= 0)
  66                 return FALSE;
  67
  68         *data = g_malloc0 (datasize);
  69         if (!GetFileVersionInfo (filename, handle, datasize, *data)) {
  70                 g_free (*data);
  71                 return FALSE;
  72         }
  73
  74         return TRUE;
  75 }
  76
  77 static gboolean
  78 mono_w32process_ver_query_value (gconstpointer datablock, const gunichar2 *subblock, gpointer *buffer, guint32 *len)
  79 {
  80         return VerQueryValue (datablock, subblock, buffer, len);
  81 }
  82
  83 static guint32
  84 mono_w32process_ver_language_name (guint32 lang, gunichar2 *lang_out, guint32 lang_len)
  85 {
  86         return VerLanguageName (lang, lang_out, lang_len);
  87 }
  88
  89 #endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT) && defined(HOST_WIN32) */
  90
  91 static MonoImage *system_image;
  92
  93 static void
  94 stash_system_image (MonoImage *image)
  95 {
  96         system_image = image;
  97 }
  98
  99 static MonoClass*
 100 get_file_version_info_class (void)
 101 {
 102         static MonoClass *file_version_info_class;
 103
 104         if (file_version_info_class)
 105                 return file_version_info_class;
 106
 107         g_assert (system_image);
 108
 109         return file_version_info_class = mono_class_load_from_name (
 110                 system_image, "System.Diagnostics", "FileVersionInfo");
 111 }
 112
 113 static MonoClass*
 114 get_process_module_class (void)
 115 {
 116         static MonoClass *process_module_class;
 117
 118         if (process_module_class)
 119                 return process_module_class;
 120
 121         g_assert (system_image);
 122
 123         return process_module_class = mono_class_load_from_name (
 124                 system_image, "System.Diagnostics", "ProcessModule");
 125 }
 126
 127 static guint32
 128 unicode_chars (const gunichar2 *str)
 129 {
 130         guint32 len;
 131         for (len = 0; str [len] != '\0'; ++len) {}
 132         return len;
 133 }
 134
 135 static void
 136 process_set_field_object (MonoObject *obj, const gchar *fieldname, MonoObject *data)
 137 {
 138         MonoClass *klass;
 139         MonoClassField *field;
 140
 141         LOGDEBUG (g_message ("%s: Setting field %s to object at %p", __func__, fieldname, data));
 142
 143         klass = mono_object_class (obj);
 144         g_assert (klass);
 145
 146         field = mono_class_get_field_from_name_full (klass, fieldname, NULL);
 147         g_assert (field);
 148
 149         mono_gc_wbarrier_generic_store_internal (((char *)obj) + field->offset, data);
 150 }
 151
 152 static void
 153 process_set_field_string (MonoObject *obj, const gchar *fieldname, const gunichar2 *val, guint32 len, MonoError *error)
 154 {
 155         MonoDomain *domain;
 156         MonoClass *klass;
 157         MonoClassField *field;
 158         MonoString *string;
 159
 160         error_init (error);
 161
 162         LOGDEBUG (g_message ("%s: Setting field %s to [%s]", __func__, fieldname, g_utf16_to_utf8 (val, len, NULL, NULL, NULL)));
 163
 164         domain = mono_object_domain (obj);
 165         g_assert (domain);
 166
 167         klass = mono_object_class (obj);
 168         g_assert (klass);
 169
 170         field = mono_class_get_field_from_name_full (klass, fieldname, NULL);
 171         g_assert (field);
 172
 173         string = mono_string_new_utf16_checked (domain, val, len, error);
 174         return_if_nok (error);
 175
 176         mono_gc_wbarrier_generic_store_internal (((char *)obj) + field->offset, (MonoObject*)string);
 177 }
 178
 179 static void
 180 process_set_field_string_char (MonoObject *obj, const gchar *fieldname, const gchar *val, MonoError *error)
 181 {
 182         MonoDomain *domain;
 183         MonoClass *klass;
 184         MonoClassField *field;
 185         MonoString *string;
 186
 187         error_init (error);
 188         LOGDEBUG (g_message ("%s: Setting field %s to [%s]", __func__, fieldname, val));
 189
 190         domain = mono_object_domain (obj);
 191         g_assert (domain);
 192
 193         klass = mono_object_class (obj);
 194         g_assert (klass);
 195
 196         field = mono_class_get_field_from_name_full (klass, fieldname, NULL);
 197         g_assert (field);
 198
 199         string = mono_string_new_checked (domain, val, error);
 200         return_if_nok (error);
 201
 202         mono_gc_wbarrier_generic_store_internal (((char *)obj) + field->offset, (MonoObject*)string);
 203 }
 204
 205 static void
 206 process_set_field_int (MonoObject *obj, const gchar *fieldname, guint32 val)
 207 {
 208         MonoClass *klass;
 209         MonoClassField *field;
 210
 211         LOGDEBUG (g_message ("%s: Setting field %s to %d", __func__,fieldname, val));
 212
 213         klass = mono_object_class (obj);
 214         g_assert (klass);
 215
 216         field = mono_class_get_field_from_name_full (klass, fieldname, NULL);
 217         g_assert (field);
 218
 219         *(guint32 *)(((char *)obj) + field->offset)=val;
 220 }
 221
 222 static void
 223 process_set_field_intptr (MonoObject *obj, const gchar *fieldname, gpointer val)
 224 {
 225         MonoClass *klass;
 226         MonoClassField *field;
 227
 228         LOGDEBUG (g_message ("%s: Setting field %s to %p", __func__, fieldname, val));
 229
 230         klass = mono_object_class (obj);
 231         g_assert (klass);
 232
 233         field = mono_class_get_field_from_name_full (klass, fieldname, NULL);
 234         g_assert (field);
 235
 236         *(gpointer *)(((char *)obj) + field->offset) = val;
 237 }
 238
 239 static void
 240 process_set_field_bool (MonoObject *obj, const gchar *fieldname, gboolean val)
 241 {
 242         MonoClass *klass;
 243         MonoClassField *field;
 244
 245         LOGDEBUG (g_message ("%s: Setting field %s to %s", __func__, fieldname, val ? "TRUE":"FALSE"));
 246
 247         klass = mono_object_class (obj);
 248         g_assert (klass);
 249
 250         field = mono_class_get_field_from_name_full (klass, fieldname, NULL);
 251         g_assert (field);
 252
 253         *(guint8 *)(((char *)obj) + field->offset) = val;
 254 }
 255
 256 #if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT)
 257
 258 #define SFI_COMMENTS            "\\StringFileInfo\\%02X%02X%02X%02X\\Comments"
 259 #define SFI_COMPANYNAME         "\\StringFileInfo\\%02X%02X%02X%02X\\CompanyName"
 260 #define SFI_FILEDESCRIPTION     "\\StringFileInfo\\%02X%02X%02X%02X\\FileDescription"
 261 #define SFI_FILEVERSION         "\\StringFileInfo\\%02X%02X%02X%02X\\FileVersion"
 262 #define SFI_INTERNALNAME        "\\StringFileInfo\\%02X%02X%02X%02X\\InternalName"
 263 #define SFI_LEGALCOPYRIGHT      "\\StringFileInfo\\%02X%02X%02X%02X\\LegalCopyright"
 264 #define SFI_LEGALTRADEMARKS     "\\StringFileInfo\\%02X%02X%02X%02X\\LegalTrademarks"
 265 #define SFI_ORIGINALFILENAME    "\\StringFileInfo\\%02X%02X%02X%02X\\OriginalFilename"
 266 #define SFI_PRIVATEBUILD        "\\StringFileInfo\\%02X%02X%02X%02X\\PrivateBuild"
 267 #define SFI_PRODUCTNAME         "\\StringFileInfo\\%02X%02X%02X%02X\\ProductName"
 268 #define SFI_PRODUCTVERSION      "\\StringFileInfo\\%02X%02X%02X%02X\\ProductVersion"
 269 #define SFI_SPECIALBUILD        "\\StringFileInfo\\%02X%02X%02X%02X\\SpecialBuild"
 270 #define EMPTY_STRING            (gunichar2*)"\000\000"
 271
 272 typedef struct {
 273         const char *name;
 274         const char *id;
 275 } StringTableEntry;
 276
 277 static StringTableEntry stringtable_entries [] = {
 278         { "comments", SFI_COMMENTS },
 279         { "companyname", SFI_COMPANYNAME },
 280         { "filedescription", SFI_FILEDESCRIPTION },
 281         { "fileversion", SFI_FILEVERSION },
 282         { "internalname", SFI_INTERNALNAME },
 283         { "legalcopyright", SFI_LEGALCOPYRIGHT },
 284         { "legaltrademarks", SFI_LEGALTRADEMARKS },
 285         { "originalfilename", SFI_ORIGINALFILENAME },
 286         { "privatebuild", SFI_PRIVATEBUILD },
 287         { "productname", SFI_PRODUCTNAME },
 288         { "productversion", SFI_PRODUCTVERSION },
 289         { "specialbuild", SFI_SPECIALBUILD }
 290 };
 291
 292 static void
 293 process_module_string_read (MonoObject *filever, gpointer data, const gchar *fieldname,
 294                 guchar lang_hi, guchar lang_lo, const gchar *key, MonoError *error)
 295 {
 296         gchar *lang_key_utf8;
 297         gunichar2 *lang_key, *buffer;
 298         UINT chars;
 299
 300         error_init (error);
 301
 302         lang_key_utf8 = g_strdup_printf (key, lang_lo, lang_hi, 0x04, 0xb0);
 303
 304         LOGDEBUG (g_message ("%s: asking for [%s]", __func__, lang_key_utf8));
 305
 306         lang_key = g_utf8_to_utf16 (lang_key_utf8, -1, NULL, NULL, NULL);
 307
 308         if (mono_w32process_ver_query_value (data, lang_key, (gpointer *)&buffer, &chars) && chars > 0) {
 309                 LOGDEBUG (g_message ("%s: found %d chars of [%s]", __func__, chars, g_utf16_to_utf8 (buffer, chars, NULL, NULL, NULL)));
 310                 /* chars includes trailing null */
 311                 process_set_field_string (filever, fieldname, buffer, chars - 1, error);
 312         } else {
 313                 process_set_field_string (filever, fieldname, EMPTY_STRING, 0, error);
 314         }
 315
 316         g_free (lang_key);
 317         g_free (lang_key_utf8);
 318 }
 319
 320 static void
 321 process_module_stringtable (MonoObject *filever, gpointer data, guchar lang_hi, guchar lang_lo, MonoError *error)
 322 {
 323         for (int i = 0; i < G_N_ELEMENTS (stringtable_entries); ++i) {
 324                 process_module_string_read (filever, data, stringtable_entries [i].name,
 325                         lang_hi, lang_lo, stringtable_entries [i].id, error);
 326                 return_if_nok (error);
 327         }
 328 }
 329
 330 static void
 331 mono_w32process_get_fileversion (MonoObject *filever, gunichar2 *filename, MonoError *error)
 332 {
 333         VS_FIXEDFILEINFO *ffi;
 334         gpointer data;
 335         guchar *trans_data;
 336         gunichar2 *query;
 337         UINT ffi_size, trans_size;
 338         gunichar2 lang_buf[128];
 339         guint32 lang, lang_count;
 340
 341         error_init (error);
 342
 343         if (!mono_w32process_get_fileversion_info (filename, &data))
 344                 return;
 345
 346         query = g_utf8_to_utf16 ("\\", -1, NULL, NULL, NULL);
 347         if (query == NULL) {
 348                 g_free (data);
 349                 return;
 350         }
 351
 352         if (mono_w32process_ver_query_value (data, query, (gpointer *)&ffi, &ffi_size)) {
 353                 #define LOWORD(i32) ((guint16)((i32) & 0xFFFF))
 354                 #define HIWORD(i32) ((guint16)(((guint32)(i32) >> 16) & 0xFFFF))
 355
 356                 LOGDEBUG (g_message ("%s: recording assembly: FileName [%s] FileVersionInfo [%d.%d.%d.%d]",
 357                         __func__, g_utf16_to_utf8 (filename, -1, NULL, NULL, NULL), HIWORD (ffi->dwFileVersionMS),
 358                                 LOWORD (ffi->dwFileVersionMS), HIWORD (ffi->dwFileVersionLS), LOWORD (ffi->dwFileVersionLS)));
 359
 360                 process_set_field_int (filever, "filemajorpart", HIWORD (ffi->dwFileVersionMS));
 361                 process_set_field_int (filever, "fileminorpart", LOWORD (ffi->dwFileVersionMS));
 362                 process_set_field_int (filever, "filebuildpart", HIWORD (ffi->dwFileVersionLS));
 363                 process_set_field_int (filever, "fileprivatepart", LOWORD (ffi->dwFileVersionLS));
 364
 365                 process_set_field_int (filever, "productmajorpart", HIWORD (ffi->dwProductVersionMS));
 366                 process_set_field_int (filever, "productminorpart", LOWORD (ffi->dwProductVersionMS));
 367                 process_set_field_int (filever, "productbuildpart", HIWORD (ffi->dwProductVersionLS));
 368                 process_set_field_int (filever, "productprivatepart", LOWORD (ffi->dwProductVersionLS));
 369
 370                 process_set_field_bool (filever, "isdebug", ((ffi->dwFileFlags & ffi->dwFileFlagsMask) & VS_FF_DEBUG) != 0);
 371                 process_set_field_bool (filever, "isprerelease", ((ffi->dwFileFlags & ffi->dwFileFlagsMask) & VS_FF_PRERELEASE) != 0);
 372                 process_set_field_bool (filever, "ispatched", ((ffi->dwFileFlags & ffi->dwFileFlagsMask) & VS_FF_PATCHED) != 0);
 373                 process_set_field_bool (filever, "isprivatebuild", ((ffi->dwFileFlags & ffi->dwFileFlagsMask) & VS_FF_PRIVATEBUILD) != 0);
 374                 process_set_field_bool (filever, "isspecialbuild", ((ffi->dwFileFlags & ffi->dwFileFlagsMask) & VS_FF_SPECIALBUILD) != 0);
 375
 376                 #undef LOWORD
 377                 #undef HIWORD
 378         }
 379         g_free (query);
 380
 381         query = g_utf8_to_utf16 ("\\VarFileInfo\\Translation", -1, NULL, NULL, NULL);
 382         if (query == NULL) {
 383                 g_free (data);
 384                 return;
 385         }
 386
 387         if (mono_w32process_ver_query_value (data, query, (gpointer *)&trans_data, &trans_size)) {
 388                 /* use the first language ID we see */
 389                 if (trans_size >= 4) {
 390                         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]));
 391                         lang = (trans_data[0]) | (trans_data[1] << 8) | (trans_data[2] << 16) | (trans_data[3] << 24);
 392                         /* Only give the lower 16 bits to mono_w32process_ver_language_name, as Windows gets confused otherwise  */
 393                         lang_count = mono_w32process_ver_language_name (lang & 0xFFFF, lang_buf, 128);
 394                         if (lang_count) {
 395                                 process_set_field_string (filever, "language", lang_buf, lang_count, error);
 396                                 if (!is_ok (error))
 397                                         goto cleanup;
 398                         }
 399                         process_module_stringtable (filever, data, trans_data[0], trans_data[1], error);
 400                         if (!is_ok (error))
 401                                 goto cleanup;
 402                 }
 403         } else {
 404                 int i;
 405
 406                 for (i = 0; i < G_N_ELEMENTS (stringtable_entries); ++i) {
 407                         /* No strings, so set every field to the empty string */
 408                         process_set_field_string (filever, stringtable_entries [i].name, EMPTY_STRING, 0, error);
 409                         if (!is_ok (error))
 410                                 goto cleanup;
 411                 }
 412
 413                 /* And language seems to be set to en_US according to bug 374600 */
 414                 lang_count = mono_w32process_ver_language_name (0x0409, lang_buf, 128);
 415                 if (lang_count) {
 416                         process_set_field_string (filever, "language", lang_buf, lang_count, error);
 417                         if (!is_ok (error))
 418                                 goto cleanup;
 419                 }
 420         }
 421
 422 cleanup:
 423         g_free (query);
 424         g_free (data);
 425 }
 426
 427 #endif /* #if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT) */
 428
 429 void
 430 ves_icall_System_Diagnostics_FileVersionInfo_GetVersionInfo_internal (MonoObject *this_obj, MonoString *filename)
 431 {
 432         ERROR_DECL (error);
 433
 434         stash_system_image (m_class_get_image (mono_object_class (this_obj)));
 435
 436         mono_w32process_get_fileversion (this_obj, mono_string_chars_internal (filename), error);
 437         if (!mono_error_ok (error)) {
 438                 mono_error_set_pending_exception (error);
 439                 return;
 440         }
 441
 442         process_set_field_string (this_obj, "filename", mono_string_chars_internal (filename), mono_string_length_internal (filename), error);
 443         if (!mono_error_ok (error)) {
 444                 mono_error_set_pending_exception (error);
 445         }
 446 }
 447
 448 #if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT)
 449
 450 static GPtrArray*
 451 get_domain_assemblies (MonoDomain *domain)
 452 {
 453         GSList *tmp;
 454         GPtrArray *assemblies;
 455
 456         /*
 457          * Make a copy of the list of assemblies because we can't hold the assemblies
 458          * lock while creating objects etc.
 459          */
 460         assemblies = g_ptr_array_new ();
 461         mono_domain_assemblies_lock (domain);
 462         for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
 463                 MonoAssembly *ass = (MonoAssembly *)tmp->data;
 464                 if (ass->image->fileio_used)
 465                         continue;
 466                 g_ptr_array_add (assemblies, ass);
 467         }
 468         mono_domain_assemblies_unlock (domain);
 469
 470         return assemblies;
 471 }
 472
 473 static MonoObject*
 474 process_add_module (HANDLE process, HMODULE mod, gunichar2 *filename, gunichar2 *modulename, MonoClass *proc_class, MonoError *error)
 475 {
 476         MonoObject *item, *filever;
 477         MonoDomain *domain = mono_domain_get ();
 478         MODULEINFO modinfo;
 479         BOOL ok;
 480
 481         error_init (error);
 482
 483         /* Build a System.Diagnostics.ProcessModule with the data. */
 484         item = mono_object_new_checked (domain, proc_class, error);
 485         return_val_if_nok (error, NULL);
 486
 487         filever = mono_object_new_checked (domain, get_file_version_info_class (), error);
 488         return_val_if_nok (error, NULL);
 489
 490         mono_w32process_get_fileversion (filever, filename, error);
 491         return_val_if_nok (error, NULL);
 492
 493         process_set_field_string (filever, "filename", filename, unicode_chars (filename), error);
 494         return_val_if_nok (error, NULL);
 495
 496         ok = mono_w32process_module_get_information (process, mod, &modinfo, sizeof(MODULEINFO));
 497         if (ok) {
 498                 process_set_field_intptr (item, "baseaddr", modinfo.lpBaseOfDll);
 499                 process_set_field_intptr (item, "entryaddr", modinfo.EntryPoint);
 500                 process_set_field_int (item, "memory_size", modinfo.SizeOfImage);
 501         }
 502
 503         process_set_field_string (item, "filename", filename, unicode_chars (filename), error);
 504         return_val_if_nok (error, NULL);
 505
 506         process_set_field_string (item, "modulename", modulename, unicode_chars (modulename), error);
 507         return_val_if_nok (error, NULL);
 508
 509         process_set_field_object (item, "version_info", filever);
 510
 511         return item;
 512 }
 513
 514 static void
 515 process_get_assembly_fileversion (MonoObject *filever, MonoAssembly *assembly)
 516 {
 517         process_set_field_int (filever, "filemajorpart", assembly->aname.major);
 518         process_set_field_int (filever, "fileminorpart", assembly->aname.minor);
 519         process_set_field_int (filever, "filebuildpart", assembly->aname.build);
 520 }
 521
 522 static MonoObject*
 523 process_get_module (MonoAssembly *assembly, MonoClass *proc_class, MonoError *error)
 524 {
 525         MonoObject *item, *filever;
 526         MonoDomain *domain;
 527         char *filename = NULL;
 528         const gchar *modulename;
 529
 530         error_init (error);
 531
 532         domain = mono_domain_get ();
 533
 534         modulename = assembly->aname.name;
 535
 536         /* Build a System.Diagnostics.ProcessModule with the data. */
 537         item = mono_object_new_checked (domain, proc_class, error);
 538         goto_if_nok (error, return_null);
 539
 540         filever = mono_object_new_checked (domain, get_file_version_info_class (), error);
 541         goto_if_nok (error, return_null);
 542
 543         filename = g_strdup_printf ("[In Memory] %s", modulename);
 544
 545         process_get_assembly_fileversion (filever, assembly);
 546         process_set_field_string_char (filever, "filename", filename, error);
 547         goto_if_nok (error, return_null);
 548         process_set_field_object (item, "version_info", filever);
 549
 550         process_set_field_intptr (item, "baseaddr", assembly->image->raw_data);
 551         process_set_field_int (item, "memory_size", assembly->image->raw_data_len);
 552         process_set_field_string_char (item, "filename", filename, error);
 553         goto_if_nok (error, return_null);
 554         process_set_field_string_char (item, "modulename", modulename, error);
 555         goto_if_nok (error, return_null);
 556
 557         goto exit;
 558 return_null:
 559         item = NULL;
 560 exit:
 561         g_free (filename);
 562         return item;
 563 }
 564
 565 /* Returns an array of System.Diagnostics.ProcessModule */
 566 MonoArray *
 567 ves_icall_System_Diagnostics_Process_GetModules_internal (MonoObject *this_obj, HANDLE process)
 568 {
 569         ERROR_DECL (error);
 570         MonoArray *temp_arr = NULL;
 571         MonoArray *arr;
 572         HMODULE mods[1024];
 573         gunichar2 filename[MAX_PATH];
 574         gunichar2 modname[MAX_PATH];
 575         DWORD needed;
 576         guint32 count = 0, module_count = 0, assembly_count = 0;
 577         guint32 i, num_added = 0;
 578         GPtrArray *assemblies = NULL;
 579
 580         stash_system_image (m_class_get_image (mono_object_class (this_obj)));
 581
 582         if (mono_w32process_get_pid (process) == mono_process_current_pid ()) {
 583                 assemblies = get_domain_assemblies (mono_domain_get ());
 584                 assembly_count = assemblies->len;
 585         }
 586
 587         if (mono_w32process_try_get_modules (process, mods, sizeof(mods), &needed))
 588                 module_count += needed / sizeof(HMODULE);
 589
 590         count = module_count + assembly_count;
 591         temp_arr = mono_array_new_checked (mono_domain_get (), get_process_module_class (), count, error);
 592         if (mono_error_set_pending_exception (error))
 593                 return NULL;
 594
 595         for (i = 0; i < module_count; i++) {
 596                 if (mono_w32process_module_get_name (process, mods[i], modname, MAX_PATH)
 597                          && mono_w32process_module_get_filename (process, mods[i], filename, MAX_PATH))
 598                 {
 599                         MonoObject *module = process_add_module (process, mods[i], filename, modname, get_process_module_class (), error);
 600                         if (!mono_error_ok (error)) {
 601                                 mono_error_set_pending_exception (error);
 602                                 return NULL;
 603                         }
 604                         mono_array_setref_internal (temp_arr, num_added++, module);
 605                 }
 606         }
 607
 608         if (assemblies) {
 609                 for (i = 0; i < assembly_count; i++) {
 610                         MonoAssembly *ass = (MonoAssembly *)g_ptr_array_index (assemblies, i);
 611                         MonoObject *module = process_get_module (ass, get_process_module_class (), error);
 612                         if (!mono_error_ok (error)) {
 613                                 mono_error_set_pending_exception (error);
 614                                 return NULL;
 615                         }
 616                         mono_array_setref_internal (temp_arr, num_added++, module);
 617                 }
 618                 g_ptr_array_free (assemblies, TRUE);
 619         }
 620
 621         if (count == num_added) {
 622                 arr = temp_arr;
 623         } else {
 624                 /* shorter version of the array */
 625                 arr = mono_array_new_checked (mono_domain_get (), get_process_module_class (), num_added, error);
 626                 if (mono_error_set_pending_exception (error))
 627                         return NULL;
 628
 629                 for (i = 0; i < num_added; i++)
 630                         mono_array_setref_internal (arr, i, mono_array_get_internal (temp_arr, MonoObject*, i));
 631         }
 632
 633         return arr;
 634 }
 635
 636 #endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT) */
 637
 638 #if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT)
 639
 640 MonoString *
 641 ves_icall_System_Diagnostics_Process_ProcessName_internal (HANDLE process)
 642 {
 643         ERROR_DECL (error);
 644         MonoString *string;
 645         gunichar2 name[MAX_PATH];
 646         guint32 len;
 647         gboolean ok;
 648         HMODULE mod;
 649         DWORD needed;
 650
 651         ok = mono_w32process_try_get_modules (process, &mod, sizeof(mod), &needed);
 652         if (!ok)
 653                 return NULL;
 654
 655         len = mono_w32process_module_get_name (process, mod, name, MAX_PATH);
 656         if (len == 0)
 657                 return NULL;
 658
 659         string = mono_string_new_utf16_checked (mono_domain_get (), name, len, error);
 660         if (!mono_error_ok (error))
 661                 mono_error_set_pending_exception (error);
 662
 663         return string;
 664 }
 665
 666 #endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT) */
 667
 668 gint64
 669 ves_icall_System_Diagnostics_Process_GetProcessData (int pid, gint32 data_type, gint32 *error)
 670 {
 671         MonoProcessError perror;
 672         guint64 res;
 673
 674         res = mono_process_get_data_with_error (GINT_TO_POINTER (pid), (MonoProcessData)data_type, &perror);
 675         if (error)
 676                 *error = perror;
 677         return res;
 678 }
 679
 680 static void
 681 mono_pin_string (MonoStringHandle in_coophandle, MonoStringHandle *out_coophandle, gunichar2 **chars, gsize *length, gchandle_t *gchandle)
 682 {
 683         *out_coophandle = in_coophandle;
 684         if (!MONO_HANDLE_IS_NULL (in_coophandle)) {
 685                 *chars = mono_string_handle_pin_chars (in_coophandle, gchandle);
 686                 *length = mono_string_handle_length (in_coophandle);
 687         }
 688 }
 689
 690 void
 691 mono_createprocess_coop_init (MonoCreateProcessCoop *coop, MonoW32ProcessStartInfoHandle proc_start_info, MonoW32ProcessInfo *process_info)
 692 {
 693         memset (coop, 0, sizeof (*coop));
 694
 695 #define PIN_STRING(h, x) (mono_pin_string (h, &coop->coophandle.x, &coop->x, &coop->length.x, &coop->gchandle.x))
 696
 697 #define PIN(x) PIN_STRING (MONO_HANDLE_NEW_GET (MonoString, proc_start_info, x), x)
 698         PIN (filename);
 699         PIN (arguments);
 700         PIN (working_directory);
 701         PIN (verb);
 702 #undef PIN
 703 #define PIN(x) PIN_STRING (MONO_HANDLE_NEW (MonoString, process_info->x), x)
 704         PIN (username);
 705         PIN (domain);
 706 #undef PIN
 707 }
 708
 709 static void
 710 mono_unpin_array (gchandle_t *gchandles, gsize count)
 711 {
 712         for (gsize i = 0; i < count; ++i) {
 713                 mono_gchandle_free_internal (gchandles [i]);
 714                 gchandles [i] = 0;
 715         }
 716 }
 717
 718 void
 719 mono_createprocess_coop_cleanup (MonoCreateProcessCoop *coop)
 720 {
 721         mono_unpin_array ((gchandle_t*)&coop->gchandle, sizeof (coop->gchandle) / sizeof (gchandle_t));
 722         memset (coop, 0, sizeof (*coop));
 723 }