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