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