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