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