mono/metadata/w32process.c

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