mono/metadata/w32process-unix.c

   1 /**
   2  * \file
   3  * System.Diagnostics.Process support
   4  *
   5  * Author:
   6  *      Dick Porter (dick@ximian.com)
   7  *
   8  * Copyright 2002 Ximian, Inc.
   9  * Copyright 2002-2006 Novell, Inc.
  10  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  11  */
  12
  13 #include <config.h>
  14 #include <glib.h>
  15
  16 #include <stdio.h>
  17 #include <string.h>
  18 #include <pthread.h>
  19 #include <sched.h>
  20 #include <sys/time.h>
  21 #include <errno.h>
  22 #include <sys/types.h>
  23 #include <sys/stat.h>
  24 #include <unistd.h>
  25 #ifdef HAVE_SIGNAL_H
  26 #include <signal.h>
  27 #endif
  28 #include <sys/time.h>
  29 #include <fcntl.h>
  30 #ifdef HAVE_SYS_PARAM_H
  31 #include <sys/param.h>
  32 #endif
  33 #include <ctype.h>
  34
  35 #ifdef HAVE_SYS_WAIT_H
  36 #include <sys/wait.h>
  37 #endif
  38 #ifdef HAVE_SYS_RESOURCE_H
  39 #include <sys/resource.h>
  40 #endif
  41
  42 #ifdef HAVE_SYS_MKDEV_H
  43 #include <sys/mkdev.h>
  44 #endif
  45
  46 #ifdef HAVE_UTIME_H
  47 #include <utime.h>
  48 #endif
  49
  50 #include <mono/metadata/w32process.h>
  51 #include <mono/metadata/w32process-internals.h>
  52 #include <mono/metadata/w32process-unix-internals.h>
  53 #include <mono/metadata/w32error.h>
  54 #include <mono/metadata/class.h>
  55 #include <mono/metadata/class-internals.h>
  56 #include <mono/metadata/object.h>
  57 #include <mono/metadata/object-internals.h>
  58 #include <mono/metadata/metadata.h>
  59 #include <mono/metadata/metadata-internals.h>
  60 #include <mono/metadata/exception.h>
  61 #include <mono/metadata/w32handle.h>
  62 #include <mono/metadata/w32file.h>
  63 #include <mono/utils/mono-membar.h>
  64 #include <mono/utils/mono-logger-internals.h>
  65 #include <mono/utils/strenc.h>
  66 #include <mono/utils/mono-proclib.h>
  67 #include <mono/utils/mono-path.h>
  68 #include <mono/utils/mono-lazy-init.h>
  69 #include <mono/utils/mono-signal-handler.h>
  70 #include <mono/utils/mono-time.h>
  71 #include <mono/utils/mono-mmap.h>
  72 #include <mono/utils/strenc.h>
  73 #include <mono/utils/mono-io-portability.h>
  74 #include <mono/utils/w32api.h>
  75
  76 #ifndef MAXPATHLEN
  77 #define MAXPATHLEN 242
  78 #endif
  79
  80 #define STILL_ACTIVE ((int) 0x00000103)
  81
  82 #define LOGDEBUG(...)
  83 /* define LOGDEBUG(...) g_message(__VA_ARGS__)  */
  84
  85 /* The process' environment strings */
  86 #if defined(__APPLE__)
  87 #if defined (TARGET_OSX)
  88 /* Apple defines this in crt_externs.h but doesn't provide that header for
  89  * arm-apple-darwin9.  We'll manually define the symbol on Apple as it does
  90  * in fact exist on all implementations (so far)
  91  */
  92 gchar ***_NSGetEnviron(void);
  93 #define environ (*_NSGetEnviron())
  94 #else
  95 static char *mono_environ[1] = { NULL };
  96 #define environ mono_environ
  97 #endif /* defined (TARGET_OSX) */
  98 #else
  99 extern char **environ;
 100 #endif
 101
 102 typedef enum {
 103         STARTF_USESHOWWINDOW=0x001,
 104         STARTF_USESIZE=0x002,
 105         STARTF_USEPOSITION=0x004,
 106         STARTF_USECOUNTCHARS=0x008,
 107         STARTF_USEFILLATTRIBUTE=0x010,
 108         STARTF_RUNFULLSCREEN=0x020,
 109         STARTF_FORCEONFEEDBACK=0x040,
 110         STARTF_FORCEOFFFEEDBACK=0x080,
 111         STARTF_USESTDHANDLES=0x100
 112 } StartupFlags;
 113
 114 typedef struct {
 115         gpointer input;
 116         gpointer output;
 117         gpointer error;
 118 } StartupHandles;
 119
 120 typedef struct {
 121 #if G_BYTE_ORDER == G_BIG_ENDIAN
 122         guint32 highDateTime;
 123         guint32 lowDateTime;
 124 #else
 125         guint32 lowDateTime;
 126         guint32 highDateTime;
 127 #endif
 128 } ProcessTime;
 129
 130 /*
 131  * Process describes processes we create.
 132  * It contains a semaphore that can be waited on in order to wait
 133  * for process termination. It's accessed in our SIGCHLD handler,
 134  * when status is updated (and pid cleared, to not clash with
 135  * subsequent processes that may get executed).
 136  */
 137 typedef struct _Process {
 138         pid_t pid; /* the pid of the process. This value is only valid until the process has exited. */
 139         MonoSemType exit_sem; /* this semaphore will be released when the process exits */
 140         int status; /* the exit status */
 141         gint32 handle_count; /* the number of handles to this process instance */
 142         /* we keep a ref to the creating _WapiHandle_process handle until
 143          * the process has exited, so that the information there isn't lost.
 144          */
 145         gpointer handle;
 146         gboolean freeable;
 147         gboolean signalled;
 148         struct _Process *next;
 149 } Process;
 150
 151 /* MonoW32HandleProcess is a structure containing all the required information for process handling. */
 152 typedef struct {
 153         pid_t pid;
 154         gboolean child;
 155         guint32 exitstatus;
 156         gpointer main_thread;
 157         guint64 create_time;
 158         guint64 exit_time;
 159         char *pname;
 160         size_t min_working_set;
 161         size_t max_working_set;
 162         gboolean exited;
 163         Process *process;
 164 } MonoW32HandleProcess;
 165
 166 /*
 167  * VS_VERSIONINFO:
 168  *
 169  * 2 bytes: Length in bytes (this block, and all child blocks. does _not_ include alignment padding between blocks)
 170  * 2 bytes: Length in bytes of VS_FIXEDFILEINFO struct
 171  * 2 bytes: Type (contains 1 if version resource contains text data and 0 if version resource contains binary data)
 172  * Variable length unicode string (null terminated): Key (currently "VS_VERSION_INFO")
 173  * Variable length padding to align VS_FIXEDFILEINFO on a 32-bit boundary
 174  * VS_FIXEDFILEINFO struct
 175  * Variable length padding to align Child struct on a 32-bit boundary
 176  * Child struct (zero or one StringFileInfo structs, zero or one VarFileInfo structs)
 177  */
 178
 179 /*
 180  * StringFileInfo:
 181  *
 182  * 2 bytes: Length in bytes (includes this block, as well as all Child blocks)
 183  * 2 bytes: Value length (always zero)
 184  * 2 bytes: Type (contains 1 if version resource contains text data and 0 if version resource contains binary data)
 185  * Variable length unicode string: Key (currently "StringFileInfo")
 186  * Variable length padding to align Child struct on a 32-bit boundary
 187  * Child structs ( one or more StringTable structs.  Each StringTable struct's Key member indicates the appropriate language and code page for displaying the text in that StringTable struct.)
 188  */
 189
 190 /*
 191  * StringTable:
 192  *
 193  * 2 bytes: Length in bytes (includes this block as well as all Child blocks, but excludes any padding between String blocks)
 194  * 2 bytes: Value length (always zero)
 195  * 2 bytes: Type (contains 1 if version resource contains text data and 0 if version resource contains binary data)
 196  * Variable length unicode string: Key. An 8-digit hex number stored as a unicode string.  The four most significant digits represent the language identifier.  The four least significant digits represent the code page for which the data is formatted.
 197  * Variable length padding to align Child struct on a 32-bit boundary
 198  * Child structs (an array of one or more String structs (each aligned on a 32-bit boundary)
 199  */
 200
 201 /*
 202  * String:
 203  *
 204  * 2 bytes: Length in bytes (of this block)
 205  * 2 bytes: Value length (the length in words of the Value member)
 206  * 2 bytes: Type (contains 1 if version resource contains text data and 0 if version resource contains binary data)
 207  * Variable length unicode string: Key. arbitrary string, identifies data.
 208  * Variable length padding to align Value on a 32-bit boundary
 209  * Value: Variable length unicode string, holding data.
 210  */
 211
 212 /*
 213  * VarFileInfo:
 214  *
 215  * 2 bytes: Length in bytes (includes this block, as well as all Child blocks)
 216  * 2 bytes: Value length (always zero)
 217  * 2 bytes: Type (contains 1 if version resource contains text data and 0 if version resource contains binary data)
 218  * Variable length unicode string: Key (currently "VarFileInfo")
 219  * Variable length padding to align Child struct on a 32-bit boundary
 220  * Child structs (a Var struct)
 221  */
 222
 223 /*
 224  * Var:
 225  *
 226  * 2 bytes: Length in bytes of this block
 227  * 2 bytes: Value length in bytes of the Value
 228  * 2 bytes: Type (contains 1 if version resource contains text data and 0 if version resource contains binary data)
 229  * Variable length unicode string: Key ("Translation")
 230  * Variable length padding to align Value on a 32-bit boundary
 231  * Value: an array of one or more 4 byte values that are language and code page identifier pairs, low-order word containing a language identifier, and the high-order word containing a code page number.  Either word can be zero, indicating that the file is language or code page independent.
 232  */
 233
 234 #if G_BYTE_ORDER == G_BIG_ENDIAN
 235 #define VS_FFI_SIGNATURE        0xbd04effe
 236 #define VS_FFI_STRUCVERSION     0x00000100
 237 #else
 238 #define VS_FFI_SIGNATURE        0xfeef04bd
 239 #define VS_FFI_STRUCVERSION     0x00010000
 240 #endif
 241
 242 #define IMAGE_NUMBEROF_DIRECTORY_ENTRIES 16
 243
 244 #define IMAGE_DIRECTORY_ENTRY_EXPORT    0
 245 #define IMAGE_DIRECTORY_ENTRY_IMPORT    1
 246 #define IMAGE_DIRECTORY_ENTRY_RESOURCE  2
 247
 248 #define IMAGE_SIZEOF_SHORT_NAME 8
 249
 250 #if G_BYTE_ORDER != G_LITTLE_ENDIAN
 251 #define IMAGE_DOS_SIGNATURE     0x4d5a
 252 #define IMAGE_NT_SIGNATURE      0x50450000
 253 #define IMAGE_NT_OPTIONAL_HDR32_MAGIC   0xb10
 254 #define IMAGE_NT_OPTIONAL_HDR64_MAGIC   0xb20
 255 #else
 256 #define IMAGE_DOS_SIGNATURE     0x5a4d
 257 #define IMAGE_NT_SIGNATURE      0x00004550
 258 #define IMAGE_NT_OPTIONAL_HDR32_MAGIC   0x10b
 259 #define IMAGE_NT_OPTIONAL_HDR64_MAGIC   0x20b
 260 #endif
 261
 262 typedef struct {
 263         guint16 e_magic;
 264         guint16 e_cblp;
 265         guint16 e_cp;
 266         guint16 e_crlc;
 267         guint16 e_cparhdr;
 268         guint16 e_minalloc;
 269         guint16 e_maxalloc;
 270         guint16 e_ss;
 271         guint16 e_sp;
 272         guint16 e_csum;
 273         guint16 e_ip;
 274         guint16 e_cs;
 275         guint16 e_lfarlc;
 276         guint16 e_ovno;
 277         guint16 e_res[4];
 278         guint16 e_oemid;
 279         guint16 e_oeminfo;
 280         guint16 e_res2[10];
 281         guint32 e_lfanew;
 282 } IMAGE_DOS_HEADER;
 283
 284 typedef struct {
 285         guint16 Machine;
 286         guint16 NumberOfSections;
 287         guint32 TimeDateStamp;
 288         guint32 PointerToSymbolTable;
 289         guint32 NumberOfSymbols;
 290         guint16 SizeOfOptionalHeader;
 291         guint16 Characteristics;
 292 } IMAGE_FILE_HEADER;
 293
 294 typedef struct {
 295         guint32 VirtualAddress;
 296         guint32 Size;
 297 } IMAGE_DATA_DIRECTORY;
 298
 299 typedef struct {
 300         guint16 Magic;
 301         guint8 MajorLinkerVersion;
 302         guint8 MinorLinkerVersion;
 303         guint32 SizeOfCode;
 304         guint32 SizeOfInitializedData;
 305         guint32 SizeOfUninitializedData;
 306         guint32 AddressOfEntryPoint;
 307         guint32 BaseOfCode;
 308         guint32 BaseOfData;
 309         guint32 ImageBase;
 310         guint32 SectionAlignment;
 311         guint32 FileAlignment;
 312         guint16 MajorOperatingSystemVersion;
 313         guint16 MinorOperatingSystemVersion;
 314         guint16 MajorImageVersion;
 315         guint16 MinorImageVersion;
 316         guint16 MajorSubsystemVersion;
 317         guint16 MinorSubsystemVersion;
 318         guint32 Win32VersionValue;
 319         guint32 SizeOfImage;
 320         guint32 SizeOfHeaders;
 321         guint32 CheckSum;
 322         guint16 Subsystem;
 323         guint16 DllCharacteristics;
 324         guint32 SizeOfStackReserve;
 325         guint32 SizeOfStackCommit;
 326         guint32 SizeOfHeapReserve;
 327         guint32 SizeOfHeapCommit;
 328         guint32 LoaderFlags;
 329         guint32 NumberOfRvaAndSizes;
 330         IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
 331 } IMAGE_OPTIONAL_HEADER32;
 332
 333 typedef struct {
 334         guint16 Magic;
 335         guint8 MajorLinkerVersion;
 336         guint8 MinorLinkerVersion;
 337         guint32 SizeOfCode;
 338         guint32 SizeOfInitializedData;
 339         guint32 SizeOfUninitializedData;
 340         guint32 AddressOfEntryPoint;
 341         guint32 BaseOfCode;
 342         guint64 ImageBase;
 343         guint32 SectionAlignment;
 344         guint32 FileAlignment;
 345         guint16 MajorOperatingSystemVersion;
 346         guint16 MinorOperatingSystemVersion;
 347         guint16 MajorImageVersion;
 348         guint16 MinorImageVersion;
 349         guint16 MajorSubsystemVersion;
 350         guint16 MinorSubsystemVersion;
 351         guint32 Win32VersionValue;
 352         guint32 SizeOfImage;
 353         guint32 SizeOfHeaders;
 354         guint32 CheckSum;
 355         guint16 Subsystem;
 356         guint16 DllCharacteristics;
 357         guint64 SizeOfStackReserve;
 358         guint64 SizeOfStackCommit;
 359         guint64 SizeOfHeapReserve;
 360         guint64 SizeOfHeapCommit;
 361         guint32 LoaderFlags;
 362         guint32 NumberOfRvaAndSizes;
 363         IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
 364 } IMAGE_OPTIONAL_HEADER64;
 365
 366 #if SIZEOF_VOID_P == 8
 367 typedef IMAGE_OPTIONAL_HEADER64 IMAGE_OPTIONAL_HEADER;
 368 #else
 369 typedef IMAGE_OPTIONAL_HEADER32 IMAGE_OPTIONAL_HEADER;
 370 #endif
 371
 372 typedef struct {
 373         guint32 Signature;
 374         IMAGE_FILE_HEADER FileHeader;
 375         IMAGE_OPTIONAL_HEADER32 OptionalHeader;
 376 } IMAGE_NT_HEADERS32;
 377
 378 typedef struct {
 379         guint32 Signature;
 380         IMAGE_FILE_HEADER FileHeader;
 381         IMAGE_OPTIONAL_HEADER64 OptionalHeader;
 382 } IMAGE_NT_HEADERS64;
 383
 384 #if SIZEOF_VOID_P == 8
 385 typedef IMAGE_NT_HEADERS64 IMAGE_NT_HEADERS;
 386 #else
 387 typedef IMAGE_NT_HEADERS32 IMAGE_NT_HEADERS;
 388 #endif
 389
 390 typedef struct {
 391         guint8 Name[IMAGE_SIZEOF_SHORT_NAME];
 392         union {
 393                 guint32 PhysicalAddress;
 394                 guint32 VirtualSize;
 395         } Misc;
 396         guint32 VirtualAddress;
 397         guint32 SizeOfRawData;
 398         guint32 PointerToRawData;
 399         guint32 PointerToRelocations;
 400         guint32 PointerToLinenumbers;
 401         guint16 NumberOfRelocations;
 402         guint16 NumberOfLinenumbers;
 403         guint32 Characteristics;
 404 } IMAGE_SECTION_HEADER;
 405
 406 #define IMAGE_FIRST_SECTION32(header) ((IMAGE_SECTION_HEADER *)((gsize)(header) + G_STRUCT_OFFSET (IMAGE_NT_HEADERS32, OptionalHeader) + GUINT16_FROM_LE (((IMAGE_NT_HEADERS32 *)(header))->FileHeader.SizeOfOptionalHeader)))
 407
 408 #define RT_CURSOR       0x01
 409 #define RT_BITMAP       0x02
 410 #define RT_ICON         0x03
 411 #define RT_MENU         0x04
 412 #define RT_DIALOG       0x05
 413 #define RT_STRING       0x06
 414 #define RT_FONTDIR      0x07
 415 #define RT_FONT         0x08
 416 #define RT_ACCELERATOR  0x09
 417 #define RT_RCDATA       0x0a
 418 #define RT_MESSAGETABLE 0x0b
 419 #define RT_GROUP_CURSOR 0x0c
 420 #define RT_GROUP_ICON   0x0e
 421 #define RT_VERSION      0x10
 422 #define RT_DLGINCLUDE   0x11
 423 #define RT_PLUGPLAY     0x13
 424 #define RT_VXD          0x14
 425 #define RT_ANICURSOR    0x15
 426 #define RT_ANIICON      0x16
 427 #define RT_HTML         0x17
 428 #define RT_MANIFEST     0x18
 429
 430 typedef struct {
 431         guint32 Characteristics;
 432         guint32 TimeDateStamp;
 433         guint16 MajorVersion;
 434         guint16 MinorVersion;
 435         guint16 NumberOfNamedEntries;
 436         guint16 NumberOfIdEntries;
 437 } IMAGE_RESOURCE_DIRECTORY;
 438
 439 typedef struct {
 440         union {
 441                 struct {
 442 #if G_BYTE_ORDER == G_BIG_ENDIAN
 443                         guint32 NameIsString:1;
 444                         guint32 NameOffset:31;
 445 #else
 446                         guint32 NameOffset:31;
 447                         guint32 NameIsString:1;
 448 #endif
 449                 };
 450                 guint32 Name;
 451 #if G_BYTE_ORDER == G_BIG_ENDIAN
 452                 struct {
 453                         guint16 __wapi_big_endian_padding;
 454                         guint16 Id;
 455                 };
 456 #else
 457                 guint16 Id;
 458 #endif
 459         };
 460         union {
 461                 guint32 OffsetToData;
 462                 struct {
 463 #if G_BYTE_ORDER == G_BIG_ENDIAN
 464                         guint32 DataIsDirectory:1;
 465                         guint32 OffsetToDirectory:31;
 466 #else
 467                         guint32 OffsetToDirectory:31;
 468                         guint32 DataIsDirectory:1;
 469 #endif
 470                 };
 471         };
 472 } IMAGE_RESOURCE_DIRECTORY_ENTRY;
 473
 474 typedef struct {
 475         guint32 OffsetToData;
 476         guint32 Size;
 477         guint32 CodePage;
 478         guint32 Reserved;
 479 } IMAGE_RESOURCE_DATA_ENTRY;
 480
 481 #define VOS_UNKNOWN             0x00000000
 482 #define VOS_DOS                 0x00010000
 483 #define VOS_OS216               0x00020000
 484 #define VOS_OS232               0x00030000
 485 #define VOS_NT                  0x00040000
 486 #define VOS__BASE               0x00000000
 487 #define VOS__WINDOWS16          0x00000001
 488 #define VOS__PM16               0x00000002
 489 #define VOS__PM32               0x00000003
 490 #define VOS__WINDOWS32          0x00000004
 491 /* Should "embrace and extend" here with some entries for linux etc */
 492
 493 #define VOS_DOS_WINDOWS16       0x00010001
 494 #define VOS_DOS_WINDOWS32       0x00010004
 495 #define VOS_OS216_PM16          0x00020002
 496 #define VOS_OS232_PM32          0x00030003
 497 #define VOS_NT_WINDOWS32        0x00040004
 498
 499 #define VFT_UNKNOWN             0x0000
 500 #define VFT_APP                 0x0001
 501 #define VFT_DLL                 0x0002
 502 #define VFT_DRV                 0x0003
 503 #define VFT_FONT                0x0004
 504 #define VFT_VXD                 0x0005
 505 #define VFT_STATIC_LIB          0x0007
 506
 507 #define VFT2_UNKNOWN            0x0000
 508 #define VFT2_DRV_PRINTER        0x0001
 509 #define VFT2_DRV_KEYBOARD       0x0002
 510 #define VFT2_DRV_LANGUAGE       0x0003
 511 #define VFT2_DRV_DISPLAY        0x0004
 512 #define VFT2_DRV_MOUSE          0x0005
 513 #define VFT2_DRV_NETWORK        0x0006
 514 #define VFT2_DRV_SYSTEM         0x0007
 515 #define VFT2_DRV_INSTALLABLE    0x0008
 516 #define VFT2_DRV_SOUND          0x0009
 517 #define VFT2_DRV_COMM           0x000a
 518 #define VFT2_DRV_INPUTMETHOD    0x000b
 519 #define VFT2_FONT_RASTER        0x0001
 520 #define VFT2_FONT_VECTOR        0x0002
 521 #define VFT2_FONT_TRUETYPE      0x0003
 522
 523 #define MAKELANGID(primary,secondary) ((guint16)((secondary << 10) | (primary)))
 524
 525 #define ALIGN32(ptr) ptr = (gpointer)((char *)ptr + 3); ptr = (gpointer)((char *)ptr - ((gsize)ptr & 3));
 526
 527 #if HAVE_SIGACTION
 528 static mono_lazy_init_t process_sig_chld_once = MONO_LAZY_INIT_STATUS_NOT_INITIALIZED;
 529 #endif
 530
 531 static gchar *cli_launcher;
 532
 533 /* The signal-safe logic to use processes goes like this:
 534  * - The list must be safe to traverse for the signal handler at all times.
 535  *   It's safe to: prepend an entry (which is a single store to 'processes'),
 536  *   unlink an entry (assuming the unlinked entry isn't freed and doesn't
 537  *   change its 'next' pointer so that it can still be traversed).
 538  * When cleaning up we first unlink an entry, then we verify that
 539  * the read lock isn't locked. Then we can free the entry, since
 540  * we know that nobody is using the old version of the list (including
 541  * the unlinked entry).
 542  * We also need to lock when adding and cleaning up so that those two
 543  * operations don't mess with eachother. (This lock is not used in the
 544  * signal handler) */
 545 static Process *processes;
 546 static mono_mutex_t processes_mutex;
 547
 548 static pid_t current_pid;
 549 static gpointer current_process;
 550
 551 static const gunichar2 utf16_space_bytes [2] = { 0x20, 0 };
 552 static const gunichar2 *utf16_space = utf16_space_bytes;
 553 static const gunichar2 utf16_quote_bytes [2] = { 0x22, 0 };
 554 static const gunichar2 *utf16_quote = utf16_quote_bytes;
 555
 556 /* Check if a pid is valid - i.e. if a process exists with this pid. */
 557 static gboolean
 558 process_is_alive (pid_t pid)
 559 {
 560 #if defined(HOST_WATCHOS)
 561         return TRUE; // TODO: Rewrite using sysctl
 562 #elif defined(PLATFORM_MACOSX) || defined(__OpenBSD__) || defined(__FreeBSD__)
 563         if (pid == 0)
 564                 return FALSE;
 565         if (kill (pid, 0) == 0)
 566                 return TRUE;
 567         if (errno == EPERM)
 568                 return TRUE;
 569         return FALSE;
 570 #elif defined(__HAIKU__)
 571         team_info teamInfo;
 572         if (get_team_info ((team_id)pid, &teamInfo) == B_OK)
 573                 return TRUE;
 574         return FALSE;
 575 #else
 576         gchar *dir = g_strdup_printf ("/proc/%d", pid);
 577         gboolean result = access (dir, F_OK) == 0;
 578         g_free (dir);
 579         return result;
 580 #endif
 581 }
 582
 583 static void
 584 process_details (gpointer data)
 585 {
 586         MonoW32HandleProcess *process_handle = (MonoW32HandleProcess *) data;
 587         g_print ("pid: %d, exited: %s, exitstatus: %d",
 588                 process_handle->pid, process_handle->exited ? "true" : "false", process_handle->exitstatus);
 589 }
 590
 591 static const gchar*
 592 process_typename (void)
 593 {
 594         return "Process";
 595 }
 596
 597 static gsize
 598 process_typesize (void)
 599 {
 600         return sizeof (MonoW32HandleProcess);
 601 }
 602
 603 static MonoW32HandleWaitRet
 604 process_wait (gpointer handle, guint32 timeout, gboolean *alerted)
 605 {
 606         MonoW32HandleProcess *process_handle;
 607         pid_t pid G_GNUC_UNUSED, ret;
 608         int status;
 609         gint64 start, now;
 610         Process *process;
 611         gboolean res;
 612
 613         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s (%p, %" G_GUINT32_FORMAT ")", __func__, handle, timeout);
 614
 615         if (alerted)
 616                 *alerted = FALSE;
 617
 618         res = mono_w32handle_lookup (handle, MONO_W32HANDLE_PROCESS, (gpointer*) &process_handle);
 619         if (!res) {
 620                 g_warning ("%s: error looking up process handle %p", __func__, handle);
 621                 return MONO_W32HANDLE_WAIT_RET_FAILED;
 622         }
 623
 624         if (process_handle->exited) {
 625                 /* We've already done this one */
 626                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s (%p, %" G_GUINT32_FORMAT "): Process already exited", __func__, handle, timeout);
 627                 return MONO_W32HANDLE_WAIT_RET_SUCCESS_0;
 628         }
 629
 630         pid = process_handle->pid;
 631
 632         if (pid == mono_process_current_pid ()) {
 633                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s (%p, %" G_GUINT32_FORMAT "): waiting on current process", __func__, handle, timeout);
 634                 return MONO_W32HANDLE_WAIT_RET_TIMEOUT;
 635         }
 636
 637         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s (%p, %" G_GUINT32_FORMAT "): PID: %d", __func__, handle, timeout, pid);
 638
 639         if (!process_handle->child) {
 640                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s (%p, %" G_GUINT32_FORMAT "): waiting on non-child process", __func__, handle, timeout);
 641
 642                 if (!process_is_alive (pid)) {
 643                         /* assume the process has exited */
 644                         process_handle->exited = TRUE;
 645                         process_handle->exitstatus = -1;
 646                         mono_w32handle_set_signal_state (handle, TRUE, TRUE);
 647
 648                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s (%p, %" G_GUINT32_FORMAT "): non-child process is not alive anymore (2)", __func__, handle, timeout);
 649                         return MONO_W32HANDLE_WAIT_RET_SUCCESS_0;
 650                 }
 651
 652                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s (%p, %" G_GUINT32_FORMAT "): non-child process wait failed, error : %s (%d))", __func__, handle, timeout, g_strerror (errno), errno);
 653                 return MONO_W32HANDLE_WAIT_RET_FAILED;
 654         }
 655
 656         /* We don't need to lock processes here, the entry
 657          * has a handle_count > 0 which means it will not be freed. */
 658         process = process_handle->process;
 659         g_assert (process);
 660
 661         start = mono_msec_ticks ();
 662         now = start;
 663
 664         while (1) {
 665                 if (timeout != MONO_INFINITE_WAIT) {
 666                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s (%p, %" G_GUINT32_FORMAT "): waiting on semaphore for %" G_GINT64_FORMAT " ms...",
 667                                 __func__, handle, timeout, timeout - (now - start));
 668                         ret = mono_os_sem_timedwait (&process->exit_sem, (timeout - (now - start)), alerted ? MONO_SEM_FLAGS_ALERTABLE : MONO_SEM_FLAGS_NONE);
 669                 } else {
 670                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s (%p, %" G_GUINT32_FORMAT "): waiting on semaphore forever...",
 671                                 __func__, handle, timeout);
 672                         ret = mono_os_sem_wait (&process->exit_sem, alerted ? MONO_SEM_FLAGS_ALERTABLE : MONO_SEM_FLAGS_NONE);
 673                 }
 674
 675                 if (ret == MONO_SEM_TIMEDWAIT_RET_SUCCESS) {
 676                         /* Success, process has exited */
 677                         mono_os_sem_post (&process->exit_sem);
 678                         break;
 679                 }
 680
 681                 if (ret == MONO_SEM_TIMEDWAIT_RET_TIMEDOUT) {
 682                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s (%p, %" G_GUINT32_FORMAT "): wait timeout (timeout = 0)", __func__, handle, timeout);
 683                         return MONO_W32HANDLE_WAIT_RET_TIMEOUT;
 684                 }
 685
 686                 now = mono_msec_ticks ();
 687                 if (now - start >= timeout) {
 688                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s (%p, %" G_GUINT32_FORMAT "): wait timeout", __func__, handle, timeout);
 689                         return MONO_W32HANDLE_WAIT_RET_TIMEOUT;
 690                 }
 691
 692                 if (alerted && ret == MONO_SEM_TIMEDWAIT_RET_ALERTED) {
 693                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s (%p, %" G_GUINT32_FORMAT "): wait alerted", __func__, handle, timeout);
 694                         *alerted = TRUE;
 695                         return MONO_W32HANDLE_WAIT_RET_ALERTED;
 696                 }
 697         }
 698
 699         /* Process must have exited */
 700         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s (%p, %" G_GUINT32_FORMAT "): Waited successfully", __func__, handle, timeout);
 701
 702         status = process->status;
 703         if (WIFSIGNALED (status))
 704                 process_handle->exitstatus = 128 + WTERMSIG (status);
 705         else
 706                 process_handle->exitstatus = WEXITSTATUS (status);
 707
 708         process_handle->exit_time = mono_100ns_datetime ();
 709
 710         process_handle->exited = TRUE;
 711
 712         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s (%p, %" G_GUINT32_FORMAT "): Setting pid %d signalled, exit status %d",
 713                    __func__, handle, timeout, process_handle->pid, process_handle->exitstatus);
 714
 715         mono_w32handle_set_signal_state (handle, TRUE, TRUE);
 716
 717         return MONO_W32HANDLE_WAIT_RET_SUCCESS_0;
 718 }
 719
 720 static void
 721 processes_cleanup (void)
 722 {
 723         static gint32 cleaning_up;
 724         Process *process;
 725         Process *prev = NULL;
 726         GSList *finished = NULL;
 727         GSList *l;
 728
 729         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s", __func__);
 730
 731         /* Ensure we're not in here in multiple threads at once, nor recursive. */
 732         if (InterlockedCompareExchange (&cleaning_up, 1, 0) != 0)
 733                 return;
 734
 735         for (process = processes; process; process = process->next) {
 736                 if (process->signalled && process->handle) {
 737                         /* This process has exited and we need to remove the artifical ref
 738                          * on the handle */
 739                         mono_w32handle_unref (process->handle);
 740                         process->handle = NULL;
 741                 }
 742         }
 743
 744         /*
 745          * Remove processes which exited from the processes list.
 746          * We need to synchronize with the sigchld handler here, which runs
 747          * asynchronously. The handler requires that the processes list
 748          * remain valid.
 749          */
 750         mono_os_mutex_lock (&processes_mutex);
 751
 752         for (process = processes; process; process = process->next) {
 753                 if (process->handle_count == 0 && process->freeable) {
 754                         /*
 755                          * Unlink the entry.
 756                          * This code can run parallel with the sigchld handler, but the
 757                          * modifications it makes are safe.
 758                          */
 759                         if (process == processes)
 760                                 processes = process->next;
 761                         else
 762                                 prev->next = process->next;
 763                         finished = g_slist_prepend (finished, process);
 764                 } else {
 765                         prev = process;
 766                 }
 767         }
 768
 769         mono_memory_barrier ();
 770
 771         for (l = finished; l; l = l->next) {
 772                 /*
 773                  * All the entries in the finished list are unlinked from processes, and
 774                  * they have the 'finished' flag set, which means the sigchld handler is done
 775                  * accessing them.
 776                  */
 777                 process = (Process *)l->data;
 778                 mono_os_sem_destroy (&process->exit_sem);
 779                 g_free (process);
 780         }
 781         g_slist_free (finished);
 782
 783         mono_os_mutex_unlock (&processes_mutex);
 784
 785         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s done", __func__);
 786
 787         InterlockedExchange (&cleaning_up, 0);
 788 }
 789
 790 static void
 791 process_close (gpointer handle, gpointer data)
 792 {
 793         MonoW32HandleProcess *process_handle;
 794
 795         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s", __func__);
 796
 797         process_handle = (MonoW32HandleProcess *) data;
 798         g_free (process_handle->pname);
 799         process_handle->pname = NULL;
 800         if (process_handle->process)
 801                 InterlockedDecrement (&process_handle->process->handle_count);
 802         processes_cleanup ();
 803 }
 804
 805 static MonoW32HandleOps process_ops = {
 806         process_close,          /* close_shared */
 807         NULL,                           /* signal */
 808         NULL,                           /* own */
 809         NULL,                           /* is_owned */
 810         process_wait,                   /* special_wait */
 811         NULL,                           /* prewait */
 812         process_details,        /* details */
 813         process_typename,       /* typename */
 814         process_typesize,       /* typesize */
 815 };
 816
 817 static void
 818 process_set_defaults (MonoW32HandleProcess *process_handle)
 819 {
 820         /* These seem to be the defaults on w2k */
 821         process_handle->min_working_set = 204800;
 822         process_handle->max_working_set = 1413120;
 823
 824         process_handle->create_time = mono_100ns_datetime ();
 825 }
 826
 827 static void
 828 process_set_name (MonoW32HandleProcess *process_handle)
 829 {
 830         char *progname, *utf8_progname, *slash;
 831
 832         progname = g_get_prgname ();
 833         utf8_progname = mono_utf8_from_external (progname);
 834
 835         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: using [%s] as prog name", __func__, progname);
 836
 837         if (utf8_progname) {
 838                 slash = strrchr (utf8_progname, '/');
 839                 if (slash)
 840                         process_handle->pname = g_strdup (slash+1);
 841                 else
 842                         process_handle->pname = g_strdup (utf8_progname);
 843                 g_free (utf8_progname);
 844         }
 845 }
 846
 847 void
 848 mono_w32process_init (void)
 849 {
 850         MonoW32HandleProcess process_handle;
 851
 852         mono_w32handle_register_ops (MONO_W32HANDLE_PROCESS, &process_ops);
 853
 854         mono_w32handle_register_capabilities (MONO_W32HANDLE_PROCESS,
 855                 (MonoW32HandleCapability)(MONO_W32HANDLE_CAP_WAIT | MONO_W32HANDLE_CAP_SPECIAL_WAIT));
 856
 857         current_pid = getpid ();
 858
 859         memset (&process_handle, 0, sizeof (process_handle));
 860         process_handle.pid = current_pid;
 861         process_set_defaults (&process_handle);
 862         process_set_name (&process_handle);
 863
 864         current_process = mono_w32handle_new (MONO_W32HANDLE_PROCESS, &process_handle);
 865         g_assert (current_process);
 866
 867         mono_os_mutex_init (&processes_mutex);
 868 }
 869
 870 void
 871 mono_w32process_cleanup (void)
 872 {
 873         g_free (cli_launcher);
 874 }
 875
 876 static int
 877 len16 (const gunichar2 *str)
 878 {
 879         int len = 0;
 880
 881         while (*str++ != 0)
 882                 len++;
 883
 884         return len;
 885 }
 886
 887 static gunichar2 *
 888 utf16_concat (const gunichar2 *first, ...)
 889 {
 890         va_list args;
 891         int total = 0, i;
 892         const gunichar2 *s;
 893         const gunichar2 *p;
 894         gunichar2 *ret;
 895
 896         va_start (args, first);
 897         total += len16 (first);
 898         for (s = va_arg (args, gunichar2 *); s != NULL; s = va_arg(args, gunichar2 *))
 899                 total += len16 (s);
 900         va_end (args);
 901
 902         ret = g_new (gunichar2, total + 1);
 903         if (ret == NULL)
 904                 return NULL;
 905
 906         ret [total] = 0;
 907         i = 0;
 908         for (s = first; *s != 0; s++)
 909                 ret [i++] = *s;
 910         va_start (args, first);
 911         for (s = va_arg (args, gunichar2 *); s != NULL; s = va_arg (args, gunichar2 *)){
 912                 for (p = s; *p != 0; p++)
 913                         ret [i++] = *p;
 914         }
 915         va_end (args);
 916
 917         return ret;
 918 }
 919
 920 guint32
 921 mono_w32process_get_pid (gpointer handle)
 922 {
 923         MonoW32HandleProcess *process_handle;
 924         gboolean res;
 925
 926         res = mono_w32handle_lookup (handle, MONO_W32HANDLE_PROCESS, (gpointer*) &process_handle);
 927         if (!res) {
 928                 mono_w32error_set_last (ERROR_INVALID_HANDLE);
 929                 return 0;
 930         }
 931
 932         return process_handle->pid;
 933 }
 934
 935 typedef struct {
 936         guint32 pid;
 937         gpointer handle;
 938 } GetProcessForeachData;
 939
 940 static gboolean
 941 get_process_foreach_callback (gpointer handle, gpointer handle_specific, gpointer user_data)
 942 {
 943         GetProcessForeachData *foreach_data;
 944         MonoW32HandleProcess *process_handle;
 945         pid_t pid;
 946
 947         foreach_data = (GetProcessForeachData*) user_data;
 948
 949         if (mono_w32handle_get_type (handle) != MONO_W32HANDLE_PROCESS)
 950                 return FALSE;
 951
 952         process_handle = (MonoW32HandleProcess*) handle_specific;
 953
 954         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: looking at process %d", __func__, process_handle->pid);
 955
 956         pid = process_handle->pid;
 957         if (pid == 0)
 958                 return FALSE;
 959
 960         /* It's possible to have more than one process handle with the
 961          * same pid, but only the one running process can be
 962          * unsignalled. */
 963         if (foreach_data->pid != pid)
 964                 return FALSE;
 965         if (mono_w32handle_issignalled (handle))
 966                 return FALSE;
 967
 968         mono_w32handle_ref (handle);
 969         foreach_data->handle = handle;
 970         return TRUE;
 971 }
 972
 973 HANDLE
 974 ves_icall_System_Diagnostics_Process_GetProcess_internal (guint32 pid)
 975 {
 976         GetProcessForeachData foreach_data;
 977         gpointer handle;
 978
 979         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: looking for process %d", __func__, pid);
 980
 981         memset (&foreach_data, 0, sizeof (foreach_data));
 982         foreach_data.pid = pid;
 983         mono_w32handle_foreach (get_process_foreach_callback, &foreach_data);
 984         handle = foreach_data.handle;
 985         if (handle) {
 986                 /* get_process_foreach_callback already added a ref */
 987                 return handle;
 988         }
 989
 990         if (process_is_alive (pid)) {
 991                 /* non-child process */
 992                 MonoW32HandleProcess process_handle;
 993
 994                 memset (&process_handle, 0, sizeof (process_handle));
 995                 process_handle.pid = pid;
 996                 process_handle.pname = mono_w32process_get_name (pid);
 997
 998                 handle = mono_w32handle_new (MONO_W32HANDLE_PROCESS, &process_handle);
 999                 if (handle == INVALID_HANDLE_VALUE) {
1000                         g_warning ("%s: error creating process handle", __func__);
1001
1002                         mono_w32error_set_last (ERROR_OUTOFMEMORY);
1003                         return NULL;
1004                 }
1005
1006                 return handle;
1007         }
1008
1009         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Can't find pid %d", __func__, pid);
1010
1011         mono_w32error_set_last (ERROR_PROC_NOT_FOUND);
1012         return NULL;
1013 }
1014
1015 static gboolean
1016 match_procname_to_modulename (char *procname, char *modulename)
1017 {
1018         char* lastsep = NULL;
1019         char* lastsep2 = NULL;
1020         char* pname = NULL;
1021         char* mname = NULL;
1022         gboolean result = FALSE;
1023
1024         if (procname == NULL || modulename == NULL)
1025                 return (FALSE);
1026
1027         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: procname=\"%s\", modulename=\"%s\"", __func__, procname, modulename);
1028         pname = mono_path_resolve_symlinks (procname);
1029         mname = mono_path_resolve_symlinks (modulename);
1030
1031         if (!strcmp (pname, mname))
1032                 result = TRUE;
1033
1034         if (!result) {
1035                 lastsep = strrchr (mname, '/');
1036                 if (lastsep)
1037                         if (!strcmp (lastsep+1, pname))
1038                                 result = TRUE;
1039                 if (!result) {
1040                         lastsep2 = strrchr (pname, '/');
1041                         if (lastsep2){
1042                                 if (lastsep) {
1043                                         if (!strcmp (lastsep+1, lastsep2+1))
1044                                                 result = TRUE;
1045                                 } else {
1046                                         if (!strcmp (mname, lastsep2+1))
1047                                                 result = TRUE;
1048                                 }
1049                         }
1050                 }
1051         }
1052
1053         g_free (pname);
1054         g_free (mname);
1055
1056         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: result is %" G_GINT32_FORMAT, __func__, result);
1057         return result;
1058 }
1059
1060 gboolean
1061 mono_w32process_try_get_modules (gpointer process, gpointer *modules, guint32 size, guint32 *needed)
1062 {
1063         MonoW32HandleProcess *process_handle;
1064         GSList *mods = NULL, *mods_iter;
1065         MonoW32ProcessModule *module;
1066         guint32 count, avail = size / sizeof(gpointer);
1067         int i;
1068         pid_t pid;
1069         char *pname = NULL;
1070         gboolean res;
1071
1072         /* Store modules in an array of pointers (main module as
1073          * modules[0]), using the load address for each module as a
1074          * token.  (Use 'NULL' as an alternative for the main module
1075          * so that the simple implementation can just return one item
1076          * for now.)  Get the info from /proc/<pid>/maps on linux,
1077          * /proc/<pid>/map on FreeBSD, other systems will have to
1078          * implement /dev/kmem reading or whatever other horrid
1079          * technique is needed.
1080          */
1081         if (size < sizeof(gpointer))
1082                 return FALSE;
1083
1084         res = mono_w32handle_lookup (process, MONO_W32HANDLE_PROCESS, (gpointer*) &process_handle);
1085         if (!res) {
1086                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Can't find process %p", __func__, process);
1087                 return FALSE;
1088         }
1089
1090         pid = process_handle->pid;
1091         pname = g_strdup (process_handle->pname);
1092
1093         if (!pname) {
1094                 modules[0] = NULL;
1095                 *needed = sizeof(gpointer);
1096                 return TRUE;
1097         }
1098
1099         mods = mono_w32process_get_modules (pid);
1100         if (!mods) {
1101                 modules[0] = NULL;
1102                 *needed = sizeof(gpointer);
1103                 g_free (pname);
1104                 return TRUE;
1105         }
1106
1107         count = 0;
1108
1109         /*
1110          * Use the NULL shortcut, as the first line in
1111          * /proc/<pid>/maps isn't the executable, and we need
1112          * that first in the returned list. Check the module name
1113          * to see if it ends with the proc name and substitute
1114          * the first entry with it.  FIXME if this turns out to
1115          * be a problem.
1116          */
1117         modules[0] = NULL;
1118         mods_iter = mods;
1119         for (i = 0; mods_iter; i++) {
1120                 if (i < avail - 1) {
1121                         module = (MonoW32ProcessModule *)mods_iter->data;
1122                         if (modules[0] != NULL)
1123                                 modules[i] = module->address_start;
1124                         else if (match_procname_to_modulename (pname, module->filename))
1125                                 modules[0] = module->address_start;
1126                         else
1127                                 modules[i + 1] = module->address_start;
1128                 }
1129                 mono_w32process_module_free ((MonoW32ProcessModule *)mods_iter->data);
1130                 mods_iter = g_slist_next (mods_iter);
1131                 count++;
1132         }
1133
1134         /* count + 1 to leave slot 0 for the main module */
1135         *needed = sizeof(gpointer) * (count + 1);
1136
1137         g_slist_free (mods);
1138         g_free (pname);
1139
1140         return TRUE;
1141 }
1142
1143 guint32
1144 mono_w32process_module_get_filename (gpointer process, gpointer module, gunichar2 *basename, guint32 size)
1145 {
1146         gint pid, len;
1147         gsize bytes;
1148         gchar *path;
1149         gunichar2 *proc_path;
1150
1151         size *= sizeof (gunichar2); /* adjust for unicode characters */
1152
1153         if (basename == NULL || size == 0)
1154                 return 0;
1155
1156         pid = mono_w32process_get_pid (process);
1157
1158         path = mono_w32process_get_path (pid);
1159         if (path == NULL)
1160                 return 0;
1161
1162         proc_path = mono_unicode_from_external (path, &bytes);
1163         g_free (path);
1164
1165         if (proc_path == NULL)
1166                 return 0;
1167
1168         len = (bytes / 2);
1169
1170         /* Add the terminator */
1171         bytes += 2;
1172
1173         if (size < bytes) {
1174                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Size %" G_GUINT32_FORMAT " smaller than needed (%zd); truncating", __func__, size, bytes);
1175                 memcpy (basename, proc_path, size);
1176         } else {
1177                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Size %" G_GUINT32_FORMAT " larger than needed (%zd)", __func__, size, bytes);
1178                 memcpy (basename, proc_path, bytes);
1179         }
1180
1181         g_free (proc_path);
1182
1183         return len;
1184 }
1185
1186 guint32
1187 mono_w32process_module_get_name (gpointer process, gpointer module, gunichar2 *basename, guint32 size)
1188 {
1189         MonoW32HandleProcess *process_handle;
1190         pid_t pid;
1191         gunichar2 *procname;
1192         char *procname_ext = NULL;
1193         glong len;
1194         gsize bytes;
1195         GSList *mods = NULL, *mods_iter;
1196         MonoW32ProcessModule *found_module;
1197         char *pname = NULL;
1198         gboolean res;
1199
1200         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Getting module base name, process handle %p module %p basename %p size %" G_GUINT32_FORMAT,
1201                    __func__, process, module, basename, size);
1202
1203         size = size * sizeof (gunichar2); /* adjust for unicode characters */
1204
1205         if (basename == NULL || size == 0)
1206                 return 0;
1207
1208         res = mono_w32handle_lookup (process, MONO_W32HANDLE_PROCESS, (gpointer*) &process_handle);
1209         if (!res) {
1210                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Can't find process %p", __func__, process);
1211                 return 0;
1212         }
1213
1214         pid = process_handle->pid;
1215         pname = g_strdup (process_handle->pname);
1216
1217         mods = mono_w32process_get_modules (pid);
1218         if (!mods && module != NULL) {
1219                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Can't get modules %p", __func__, process);
1220                 g_free (pname);
1221                 return 0;
1222         }
1223
1224         /* If module != NULL compare the address.
1225          * If module == NULL we are looking for the main module.
1226          * The best we can do for now check it the module name end with the process name.
1227          */
1228         for (mods_iter = mods; mods_iter; mods_iter = g_slist_next (mods_iter)) {
1229                 found_module = (MonoW32ProcessModule *)mods_iter->data;
1230                 if (procname_ext == NULL &&
1231                         ((module == NULL && match_procname_to_modulename (pname, found_module->filename)) ||
1232                          (module != NULL && found_module->address_start == module))) {
1233                         procname_ext = g_path_get_basename (found_module->filename);
1234                 }
1235
1236                 mono_w32process_module_free (found_module);
1237         }
1238
1239         if (procname_ext == NULL) {
1240                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Can't find procname_ext from procmods %p", __func__, process);
1241                 /* If it's *still* null, we might have hit the
1242                  * case where reading /proc/$pid/maps gives an
1243                  * empty file for this user.
1244                  */
1245                 procname_ext = mono_w32process_get_name (pid);
1246                 if (!procname_ext)
1247                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Can't find procname_ext from proc_get_name %p pid %d", __func__, process, pid);
1248         }
1249
1250         g_slist_free (mods);
1251         g_free (pname);
1252
1253         if (procname_ext) {
1254                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Process name is [%s]", __func__,
1255                            procname_ext);
1256
1257                 procname = mono_unicode_from_external (procname_ext, &bytes);
1258                 if (procname == NULL) {
1259                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Can't get procname %p", __func__, process);
1260                         /* bugger */
1261                         g_free (procname_ext);
1262                         return 0;
1263                 }
1264
1265                 len = (bytes / 2);
1266
1267                 /* Add the terminator */
1268                 bytes += 2;
1269
1270                 if (size < bytes) {
1271                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Size %" G_GUINT32_FORMAT " smaller than needed (%zd); truncating", __func__, size, bytes);
1272
1273                         memcpy (basename, procname, size);
1274                 } else {
1275                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Size %" G_GUINT32_FORMAT " larger than needed (%zd)",
1276                                    __func__, size, bytes);
1277
1278                         memcpy (basename, procname, bytes);
1279                 }
1280
1281                 g_free (procname);
1282                 g_free (procname_ext);
1283
1284                 return len;
1285         }
1286
1287         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Can't find procname_ext %p", __func__, process);
1288         return 0;
1289 }
1290
1291 gboolean
1292 mono_w32process_module_get_information (gpointer process, gpointer module, MODULEINFO *modinfo, guint32 size)
1293 {
1294         MonoW32HandleProcess *process_handle;
1295         pid_t pid;
1296         GSList *mods = NULL, *mods_iter;
1297         MonoW32ProcessModule *found_module;
1298         gboolean ret = FALSE;
1299         char *pname = NULL;
1300         gboolean res;
1301
1302         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Getting module info, process handle %p module %p",
1303                    __func__, process, module);
1304
1305         if (modinfo == NULL || size < sizeof (MODULEINFO))
1306                 return FALSE;
1307
1308         res = mono_w32handle_lookup (process, MONO_W32HANDLE_PROCESS, (gpointer*) &process_handle);
1309         if (!res) {
1310                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Can't find process %p", __func__, process);
1311                 return FALSE;
1312         }
1313
1314         pid = process_handle->pid;
1315         pname = g_strdup (process_handle->pname);
1316
1317         mods = mono_w32process_get_modules (pid);
1318         if (!mods) {
1319                 g_free (pname);
1320                 return FALSE;
1321         }
1322
1323         /* If module != NULL compare the address.
1324          * If module == NULL we are looking for the main module.
1325          * The best we can do for now check it the module name end with the process name.
1326          */
1327         for (mods_iter = mods; mods_iter; mods_iter = g_slist_next (mods_iter)) {
1328                         found_module = (MonoW32ProcessModule *)mods_iter->data;
1329                         if (ret == FALSE &&
1330                                 ((module == NULL && match_procname_to_modulename (pname, found_module->filename)) ||
1331                                  (module != NULL && found_module->address_start == module))) {
1332                                 modinfo->lpBaseOfDll = found_module->address_start;
1333                                 modinfo->SizeOfImage = (gsize)(found_module->address_end) - (gsize)(found_module->address_start);
1334                                 modinfo->EntryPoint = found_module->address_offset;
1335                                 ret = TRUE;
1336                         }
1337
1338                         mono_w32process_module_free (found_module);
1339         }
1340
1341         g_slist_free (mods);
1342         g_free (pname);
1343
1344         return ret;
1345 }
1346
1347 static void
1348 switch_dir_separators (char *path)
1349 {
1350         size_t i, pathLength = strlen(path);
1351
1352         /* Turn all the slashes round the right way, except for \' */
1353         /* There are probably other characters that need to be excluded as well. */
1354         for (i = 0; i < pathLength; i++) {
1355                 if (path[i] == '\\' && i < pathLength - 1 && path[i+1] != '\'' )
1356                         path[i] = '/';
1357         }
1358 }
1359
1360 #if HAVE_SIGACTION
1361
1362 MONO_SIGNAL_HANDLER_FUNC (static, mono_sigchld_signal_handler, (int _dummy, siginfo_t *info, void *context))
1363 {
1364         int status;
1365         int pid;
1366         Process *process;
1367
1368         do {
1369                 do {
1370                         pid = waitpid (-1, &status, WNOHANG);
1371                 } while (pid == -1 && errno == EINTR);
1372
1373                 if (pid <= 0)
1374                         break;
1375
1376                 /*
1377                  * This can run concurrently with the code in the rest of this module.
1378                  */
1379                 for (process = processes; process; process = process->next) {
1380                         if (process->pid != pid)
1381                                 continue;
1382                         if (process->signalled)
1383                                 continue;
1384
1385                         process->signalled = TRUE;
1386                         process->status = status;
1387                         mono_os_sem_post (&process->exit_sem);
1388                         mono_memory_barrier ();
1389                         /* Mark this as freeable, the pointer becomes invalid afterwards */
1390                         process->freeable = TRUE;
1391                         break;
1392                 }
1393         } while (1);
1394 }
1395
1396 static void
1397 process_add_sigchld_handler (void)
1398 {
1399         struct sigaction sa;
1400
1401         sa.sa_sigaction = mono_sigchld_signal_handler;
1402         sigemptyset (&sa.sa_mask);
1403         sa.sa_flags = SA_NOCLDSTOP | SA_SIGINFO;
1404         g_assert (sigaction (SIGCHLD, &sa, NULL) != -1);
1405         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "Added SIGCHLD handler");
1406 }
1407
1408 #endif
1409
1410 static gboolean
1411 is_readable_or_executable (const char *prog)
1412 {
1413         struct stat buf;
1414         int a = access (prog, R_OK);
1415         int b = access (prog, X_OK);
1416         if (a != 0 && b != 0)
1417                 return FALSE;
1418         if (stat (prog, &buf))
1419                 return FALSE;
1420         if (S_ISREG (buf.st_mode))
1421                 return TRUE;
1422         return FALSE;
1423 }
1424
1425 static gboolean
1426 is_executable (const char *prog)
1427 {
1428         struct stat buf;
1429         if (access (prog, X_OK) != 0)
1430                 return FALSE;
1431         if (stat (prog, &buf))
1432                 return FALSE;
1433         if (S_ISREG (buf.st_mode))
1434                 return TRUE;
1435         return FALSE;
1436 }
1437
1438 static gboolean
1439 is_managed_binary (const char *filename)
1440 {
1441         int original_errno = errno;
1442 #if defined(HAVE_LARGE_FILE_SUPPORT) && defined(O_LARGEFILE)
1443         int file = open (filename, O_RDONLY | O_LARGEFILE);
1444 #else
1445         int file = open (filename, O_RDONLY);
1446 #endif
1447         off_t new_offset;
1448         unsigned char buffer[8];
1449         off_t file_size, optional_header_offset;
1450         off_t pe_header_offset, clr_header_offset;
1451         gboolean managed = FALSE;
1452         int num_read;
1453         guint32 first_word, second_word, magic_number;
1454
1455         /* If we are unable to open the file, then we definitely
1456          * can't say that it is managed. The child mono process
1457          * probably wouldn't be able to open it anyway.
1458          */
1459         if (file < 0) {
1460                 errno = original_errno;
1461                 return FALSE;
1462         }
1463
1464         /* Retrieve the length of the file for future sanity checks. */
1465         file_size = lseek (file, 0, SEEK_END);
1466         lseek (file, 0, SEEK_SET);
1467
1468         /* We know we need to read a header field at offset 60. */
1469         if (file_size < 64)
1470                 goto leave;
1471
1472         num_read = read (file, buffer, 2);
1473
1474         if ((num_read != 2) || (buffer[0] != 'M') || (buffer[1] != 'Z'))
1475                 goto leave;
1476
1477         new_offset = lseek (file, 60, SEEK_SET);
1478
1479         if (new_offset != 60)
1480                 goto leave;
1481
1482         num_read = read (file, buffer, 4);
1483
1484         if (num_read != 4)
1485                 goto leave;
1486         pe_header_offset =  buffer[0]
1487                 | (buffer[1] <<  8)
1488                 | (buffer[2] << 16)
1489                 | (buffer[3] << 24);
1490
1491         if (pe_header_offset + 24 > file_size)
1492                 goto leave;
1493
1494         new_offset = lseek (file, pe_header_offset, SEEK_SET);
1495
1496         if (new_offset != pe_header_offset)
1497                 goto leave;
1498
1499         num_read = read (file, buffer, 4);
1500
1501         if ((num_read != 4) || (buffer[0] != 'P') || (buffer[1] != 'E') || (buffer[2] != 0) || (buffer[3] != 0))
1502                 goto leave;
1503
1504         /*
1505          * Verify that the header we want in the optional header data
1506          * is present in this binary.
1507          */
1508         new_offset = lseek (file, pe_header_offset + 20, SEEK_SET);
1509
1510         if (new_offset != pe_header_offset + 20)
1511                 goto leave;
1512
1513         num_read = read (file, buffer, 2);
1514
1515         if ((num_read != 2) || ((buffer[0] | (buffer[1] << 8)) < 216))
1516                 goto leave;
1517
1518         optional_header_offset = pe_header_offset + 24;
1519
1520         /* Read the PE magic number */
1521         new_offset = lseek (file, optional_header_offset, SEEK_SET);
1522
1523         if (new_offset != optional_header_offset)
1524                 goto leave;
1525
1526         num_read = read (file, buffer, 2);
1527
1528         if (num_read != 2)
1529                 goto leave;
1530
1531         magic_number = (buffer[0] | (buffer[1] << 8));
1532
1533         if (magic_number == 0x10B)  // PE32
1534                 clr_header_offset = 208;
1535         else if (magic_number == 0x20B)  // PE32+
1536                 clr_header_offset = 224;
1537         else
1538                 goto leave;
1539
1540         /* Read the CLR header address and size fields. These will be
1541          * zero if the binary is not managed.
1542          */
1543         new_offset = lseek (file, optional_header_offset + clr_header_offset, SEEK_SET);
1544
1545         if (new_offset != optional_header_offset + clr_header_offset)
1546                 goto leave;
1547
1548         num_read = read (file, buffer, 8);
1549
1550         /* We are not concerned with endianness, only with
1551          * whether it is zero or not.
1552          */
1553         first_word = *(guint32 *)&buffer[0];
1554         second_word = *(guint32 *)&buffer[4];
1555
1556         if ((num_read != 8) || (first_word == 0) || (second_word == 0))
1557                 goto leave;
1558
1559         managed = TRUE;
1560
1561 leave:
1562         close (file);
1563         errno = original_errno;
1564         return managed;
1565 }
1566
1567 static gboolean
1568 process_create (const gunichar2 *appname, const gunichar2 *cmdline,
1569         const gunichar2 *cwd, StartupHandles *startup_handles, MonoW32ProcessInfo *process_info)
1570 {
1571 #if defined (HAVE_FORK) && defined (HAVE_EXECVE)
1572         char *cmd = NULL, *prog = NULL, *full_prog = NULL, *args = NULL, *args_after_prog = NULL;
1573         char *dir = NULL, **env_strings = NULL, **argv = NULL;
1574         guint32 i;
1575         gboolean ret = FALSE;
1576         gpointer handle = NULL;
1577         GError *gerr = NULL;
1578         int in_fd, out_fd, err_fd;
1579         pid_t pid = 0;
1580         int startup_pipe [2] = {-1, -1};
1581         int dummy;
1582         Process *process;
1583
1584 #if HAVE_SIGACTION
1585         mono_lazy_initialize (&process_sig_chld_once, process_add_sigchld_handler);
1586 #endif
1587
1588         /* appname and cmdline specify the executable and its args:
1589          *
1590          * If appname is not NULL, it is the name of the executable.
1591          * Otherwise the executable is the first token in cmdline.
1592          *
1593          * Executable searching:
1594          *
1595          * If appname is not NULL, it can specify the full path and
1596          * file name, or else a partial name and the current directory
1597          * will be used.  There is no additional searching.
1598          *
1599          * If appname is NULL, the first whitespace-delimited token in
1600          * cmdline is used.  If the name does not contain a full
1601          * directory path, the search sequence is:
1602          *
1603          * 1) The directory containing the current process
1604          * 2) The current working directory
1605          * 3) The windows system directory  (Ignored)
1606          * 4) The windows directory (Ignored)
1607          * 5) $PATH
1608          *
1609          * Just to make things more interesting, tokens can contain
1610          * white space if they are surrounded by quotation marks.  I'm
1611          * beginning to understand just why windows apps are generally
1612          * so crap, with an API like this :-(
1613          */
1614         if (appname != NULL) {
1615                 cmd = mono_unicode_to_external (appname);
1616                 if (cmd == NULL) {
1617                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: unicode conversion returned NULL",
1618                                    __func__);
1619
1620                         mono_w32error_set_last (ERROR_PATH_NOT_FOUND);
1621                         goto free_strings;
1622                 }
1623
1624                 switch_dir_separators(cmd);
1625         }
1626
1627         if (cmdline != NULL) {
1628                 args = mono_unicode_to_external (cmdline);
1629                 if (args == NULL) {
1630                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: unicode conversion returned NULL", __func__);
1631
1632                         mono_w32error_set_last (ERROR_PATH_NOT_FOUND);
1633                         goto free_strings;
1634                 }
1635         }
1636
1637         if (cwd != NULL) {
1638                 dir = mono_unicode_to_external (cwd);
1639                 if (dir == NULL) {
1640                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: unicode conversion returned NULL", __func__);
1641
1642                         mono_w32error_set_last (ERROR_PATH_NOT_FOUND);
1643                         goto free_strings;
1644                 }
1645
1646                 /* Turn all the slashes round the right way */
1647                 switch_dir_separators(dir);
1648         }
1649
1650
1651         /* We can't put off locating the executable any longer :-( */
1652         if (cmd != NULL) {
1653                 char *unquoted;
1654                 if (g_ascii_isalpha (cmd[0]) && (cmd[1] == ':')) {
1655                         /* Strip off the drive letter.  I can't
1656                          * believe that CP/M holdover is still
1657                          * visible...
1658                          */
1659                         g_memmove (cmd, cmd+2, strlen (cmd)-2);
1660                         cmd[strlen (cmd)-2] = '\0';
1661                 }
1662
1663                 unquoted = g_shell_unquote (cmd, NULL);
1664                 if (unquoted[0] == '/') {
1665                         /* Assume full path given */
1666                         prog = g_strdup (unquoted);
1667
1668                         /* Executable existing ? */
1669                         if (!is_readable_or_executable (prog)) {
1670                                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Couldn't find executable %s",
1671                                            __func__, prog);
1672                                 g_free (unquoted);
1673                                 mono_w32error_set_last (ERROR_FILE_NOT_FOUND);
1674                                 goto free_strings;
1675                         }
1676                 } else {
1677                         /* Search for file named by cmd in the current
1678                          * directory
1679                          */
1680                         char *curdir = g_get_current_dir ();
1681
1682                         prog = g_strdup_printf ("%s/%s", curdir, unquoted);
1683                         g_free (curdir);
1684
1685                         /* And make sure it's readable */
1686                         if (!is_readable_or_executable (prog)) {
1687                                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Couldn't find executable %s",
1688                                            __func__, prog);
1689                                 g_free (unquoted);
1690                                 mono_w32error_set_last (ERROR_FILE_NOT_FOUND);
1691                                 goto free_strings;
1692                         }
1693                 }
1694                 g_free (unquoted);
1695
1696                 args_after_prog = args;
1697         } else {
1698                 char *token = NULL;
1699                 char quote;
1700
1701                 /* Dig out the first token from args, taking quotation
1702                  * marks into account
1703                  */
1704
1705                 /* First, strip off all leading whitespace */
1706                 args = g_strchug (args);
1707
1708                 /* args_after_prog points to the contents of args
1709                  * after token has been set (otherwise argv[0] is
1710                  * duplicated)
1711                  */
1712                 args_after_prog = args;
1713
1714                 /* Assume the opening quote will always be the first
1715                  * character
1716                  */
1717                 if (args[0] == '\"' || args [0] == '\'') {
1718                         quote = args [0];
1719                         for (i = 1; args[i] != '\0' && args[i] != quote; i++);
1720                         if (args [i + 1] == '\0' || g_ascii_isspace (args[i+1])) {
1721                                 /* We found the first token */
1722                                 token = g_strndup (args+1, i-1);
1723                                 args_after_prog = g_strchug (args + i + 1);
1724                         } else {
1725                                 /* Quotation mark appeared in the
1726                                  * middle of the token.  Just give the
1727                                  * whole first token, quotes and all,
1728                                  * to exec.
1729                                  */
1730                         }
1731                 }
1732
1733                 if (token == NULL) {
1734                         /* No quote mark, or malformed */
1735                         for (i = 0; args[i] != '\0'; i++) {
1736                                 if (g_ascii_isspace (args[i])) {
1737                                         token = g_strndup (args, i);
1738                                         args_after_prog = args + i + 1;
1739                                         break;
1740                                 }
1741                         }
1742                 }
1743
1744                 if (token == NULL && args[0] != '\0') {
1745                         /* Must be just one token in the string */
1746                         token = g_strdup (args);
1747                         args_after_prog = NULL;
1748                 }
1749
1750                 if (token == NULL) {
1751                         /* Give up */
1752                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Couldn't find what to exec", __func__);
1753
1754                         mono_w32error_set_last (ERROR_PATH_NOT_FOUND);
1755                         goto free_strings;
1756                 }
1757
1758                 /* Turn all the slashes round the right way. Only for
1759                  * the prg. name
1760                  */
1761                 switch_dir_separators(token);
1762
1763                 if (g_ascii_isalpha (token[0]) && (token[1] == ':')) {
1764                         /* Strip off the drive letter.  I can't
1765                          * believe that CP/M holdover is still
1766                          * visible...
1767                          */
1768                         g_memmove (token, token+2, strlen (token)-2);
1769                         token[strlen (token)-2] = '\0';
1770                 }
1771
1772                 if (token[0] == '/') {
1773                         /* Assume full path given */
1774                         prog = g_strdup (token);
1775
1776                         /* Executable existing ? */
1777                         if (!is_readable_or_executable (prog)) {
1778                                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Couldn't find executable %s",
1779                                            __func__, token);
1780                                 g_free (token);
1781                                 mono_w32error_set_last (ERROR_FILE_NOT_FOUND);
1782                                 goto free_strings;
1783                         }
1784                 } else {
1785                         char *curdir = g_get_current_dir ();
1786
1787                         /* FIXME: Need to record the directory
1788                          * containing the current process, and check
1789                          * that for the new executable as the first
1790                          * place to look
1791                          */
1792
1793                         prog = g_strdup_printf ("%s/%s", curdir, token);
1794                         g_free (curdir);
1795
1796                         /* I assume X_OK is the criterion to use,
1797                          * rather than F_OK
1798                          *
1799                          * X_OK is too strict *if* the target is a CLR binary
1800                          */
1801                         if (!is_readable_or_executable (prog)) {
1802                                 g_free (prog);
1803                                 prog = g_find_program_in_path (token);
1804                                 if (prog == NULL) {
1805                                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Couldn't find executable %s", __func__, token);
1806
1807                                         g_free (token);
1808                                         mono_w32error_set_last (ERROR_FILE_NOT_FOUND);
1809                                         goto free_strings;
1810                                 }
1811                         }
1812                 }
1813
1814                 g_free (token);
1815         }
1816
1817         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Exec prog [%s] args [%s]",
1818                 __func__, prog, args_after_prog);
1819
1820         /* Check for CLR binaries; if found, we will try to invoke
1821          * them using the same mono binary that started us.
1822          */
1823         if (is_managed_binary (prog)) {
1824                 gunichar2 *newapp, *newcmd;
1825                 gsize bytes_ignored;
1826
1827                 newapp = mono_unicode_from_external (cli_launcher ? cli_launcher : "mono", &bytes_ignored);
1828                 if (newapp) {
1829                         if (appname)
1830                                 newcmd = utf16_concat (utf16_quote, newapp, utf16_quote, utf16_space, appname, utf16_space, cmdline, NULL);
1831                         else
1832                                 newcmd = utf16_concat (utf16_quote, newapp, utf16_quote, utf16_space, cmdline, NULL);
1833
1834                         g_free (newapp);
1835
1836                         if (newcmd) {
1837                                 ret = process_create (NULL, newcmd, cwd, startup_handles, process_info);
1838
1839                                 g_free (newcmd);
1840
1841                                 goto free_strings;
1842                         }
1843                 }
1844         } else {
1845                 if (!is_executable (prog)) {
1846                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Executable permisson not set on %s", __func__, prog);
1847                         mono_w32error_set_last (ERROR_ACCESS_DENIED);
1848                         goto free_strings;
1849                 }
1850         }
1851
1852         if (args_after_prog != NULL && *args_after_prog) {
1853                 char *qprog;
1854
1855                 qprog = g_shell_quote (prog);
1856                 full_prog = g_strconcat (qprog, " ", args_after_prog, NULL);
1857                 g_free (qprog);
1858         } else {
1859                 full_prog = g_shell_quote (prog);
1860         }
1861
1862         ret = g_shell_parse_argv (full_prog, NULL, &argv, &gerr);
1863         if (ret == FALSE) {
1864                 g_message ("process_create: %s\n", gerr->message);
1865                 g_error_free (gerr);
1866                 gerr = NULL;
1867                 goto free_strings;
1868         }
1869
1870         if (startup_handles) {
1871                 in_fd = GPOINTER_TO_UINT (startup_handles->input);
1872                 out_fd = GPOINTER_TO_UINT (startup_handles->output);
1873                 err_fd = GPOINTER_TO_UINT (startup_handles->error);
1874         } else {
1875                 in_fd = GPOINTER_TO_UINT (mono_w32file_get_console_input ());
1876                 out_fd = GPOINTER_TO_UINT (mono_w32file_get_console_output ());
1877                 err_fd = GPOINTER_TO_UINT (mono_w32file_get_console_error ());
1878         }
1879
1880         /*
1881          * process->env_variables is a an array of MonoString*
1882          *
1883          * If new_environ is not NULL it specifies the entire set of
1884          * environment variables in the new process.  Otherwise the
1885          * new process inherits the same environment.
1886          */
1887         if (process_info->env_variables) {
1888                 gint i, str_length, var_length;
1889                 MonoString *var;
1890                 gunichar2 *str;
1891
1892                 /* +2: one for the process handle value, and the last one is NULL */
1893                 env_strings = g_new0 (gchar*, mono_array_length (process_info->env_variables) + 2);
1894
1895                 str = NULL;
1896                 str_length = 0;
1897
1898                 /* Copy each environ string into 'strings' turning it into utf8 (or the requested encoding) at the same time */
1899                 for (i = 0; i < mono_array_length (process_info->env_variables); ++i) {
1900                         var = mono_array_get (process_info->env_variables, MonoString*, i);
1901                         var_length = mono_string_length (var);
1902
1903                         /* str is a null-terminated copy of var */
1904
1905                         if (var_length + 1 > str_length) {
1906                                 str_length = var_length + 1;
1907                                 str = g_renew (gunichar2, str, str_length);
1908                         }
1909
1910                         memcpy (str, mono_string_chars (var), var_length * sizeof (gunichar2));
1911                         str [var_length] = '\0';
1912
1913                         env_strings [i] = mono_unicode_to_external (str);
1914                 }
1915
1916                 g_free (str);
1917         } else {
1918                 guint32 env_count;
1919
1920                 env_count = 0;
1921                 for (i = 0; environ[i] != NULL; i++)
1922                         env_count++;
1923
1924                 /* +2: one for the process handle value, and the last one is NULL */
1925                 env_strings = g_new0 (gchar*, env_count + 2);
1926
1927                 /* Copy each environ string into 'strings' turning it into utf8 (or the requested encoding) at the same time */
1928                 for (i = 0; i < env_count; i++)
1929                         env_strings [i] = g_strdup (environ[i]);
1930         }
1931
1932         /* Create a pipe to make sure the child doesn't exit before
1933          * we can add the process to the linked list of processes */
1934         if (pipe (startup_pipe) == -1) {
1935                 /* Could not create the pipe to synchroniz process startup. We'll just not synchronize.
1936                  * This is just for a very hard to hit race condition in the first place */
1937                 startup_pipe [0] = startup_pipe [1] = -1;
1938                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: new process startup not synchronized. We may not notice if the newly created process exits immediately.", __func__);
1939         }
1940
1941         switch (pid = fork ()) {
1942         case -1: /* Error */ {
1943                 mono_w32error_set_last (ERROR_OUTOFMEMORY);
1944                 ret = FALSE;
1945                 break;
1946         }
1947         case 0: /* Child */ {
1948                 if (startup_pipe [0] != -1) {
1949                         /* Wait until the parent has updated it's internal data */
1950                         ssize_t _i G_GNUC_UNUSED = read (startup_pipe [0], &dummy, 1);
1951                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: child: parent has completed its setup", __func__);
1952                         close (startup_pipe [0]);
1953                         close (startup_pipe [1]);
1954                 }
1955
1956                 /* should we detach from the process group? */
1957
1958                 /* Connect stdin, stdout and stderr */
1959                 dup2 (in_fd, 0);
1960                 dup2 (out_fd, 1);
1961                 dup2 (err_fd, 2);
1962
1963                 /* Close all file descriptors */
1964                 for (i = mono_w32handle_fd_reserve - 1; i > 2; i--)
1965                         close (i);
1966
1967 #ifdef DEBUG_ENABLED
1968                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: exec()ing [%s] in dir [%s]", __func__, cmd,
1969                            dir == NULL?".":dir);
1970                 for (i = 0; argv[i] != NULL; i++)
1971                         g_message ("arg %" G_GUINT32_FORMAT ": [%s]", i, argv[i]);
1972
1973                 for (i = 0; env_strings[i] != NULL; i++)
1974                         g_message ("env %" G_GUINT32_FORMAT ": [%s]", i, env_strings[i]);
1975 #endif
1976
1977                 /* set cwd */
1978                 if (dir != NULL && chdir (dir) == -1) {
1979                         /* set error */
1980                         _exit (-1);
1981                 }
1982
1983                 /* exec */
1984                 execve (argv[0], argv, env_strings);
1985
1986                 /* set error */
1987                 _exit (-1);
1988
1989                 break;
1990         }
1991         default: /* Parent */ {
1992                 MonoW32HandleProcess process_handle;
1993
1994                 memset (&process_handle, 0, sizeof (process_handle));
1995                 process_handle.pid = pid;
1996                 process_handle.child = TRUE;
1997                 process_handle.pname = g_strdup (prog);
1998                 process_set_defaults (&process_handle);
1999
2000                 /* Add our process into the linked list of processes */
2001                 process = (Process *) g_malloc0 (sizeof (Process));
2002                 process->pid = pid;
2003                 process->handle_count = 1;
2004                 mono_os_sem_init (&process->exit_sem, 0);
2005
2006                 process_handle.process = process;
2007
2008                 handle = mono_w32handle_new (MONO_W32HANDLE_PROCESS, &process_handle);
2009                 if (handle == INVALID_HANDLE_VALUE) {
2010                         g_warning ("%s: error creating process handle", __func__);
2011
2012                         mono_os_sem_destroy (&process->exit_sem);
2013                         g_free (process);
2014
2015                         mono_w32error_set_last (ERROR_OUTOFMEMORY);
2016                         ret = FALSE;
2017                         break;
2018                 }
2019
2020                 /* Keep the process handle artificially alive until the process
2021                  * exits so that the information in the handle isn't lost. */
2022                 mono_w32handle_ref (handle);
2023                 process->handle = handle;
2024
2025                 mono_os_mutex_lock (&processes_mutex);
2026                 process->next = processes;
2027                 mono_memory_barrier ();
2028                 processes = process;
2029                 mono_os_mutex_unlock (&processes_mutex);
2030
2031                 if (process_info != NULL) {
2032                         process_info->process_handle = handle;
2033                         process_info->pid = pid;
2034
2035                         /* FIXME: we might need to handle the thread info some day */
2036                         process_info->thread_handle = INVALID_HANDLE_VALUE;
2037                         process_info->tid = 0;
2038                 }
2039
2040                 break;
2041         }
2042         }
2043
2044         if (startup_pipe [1] != -1) {
2045                 /* Write 1 byte, doesn't matter what */
2046                 ssize_t _i G_GNUC_UNUSED = write (startup_pipe [1], startup_pipe, 1);
2047                 close (startup_pipe [0]);
2048                 close (startup_pipe [1]);
2049         }
2050
2051 free_strings:
2052         if (cmd)
2053                 g_free (cmd);
2054         if (full_prog)
2055                 g_free (full_prog);
2056         if (prog)
2057                 g_free (prog);
2058         if (args)
2059                 g_free (args);
2060         if (dir)
2061                 g_free (dir);
2062         if (env_strings)
2063                 g_strfreev (env_strings);
2064         if (argv)
2065                 g_strfreev (argv);
2066
2067         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: returning handle %p for pid %d", __func__, handle, pid);
2068
2069         /* Check if something needs to be cleaned up. */
2070         processes_cleanup ();
2071
2072         return ret;
2073 #else
2074         mono_w32error_set_last (ERROR_NOT_SUPPORTED);
2075         return FALSE;
2076 #endif // defined (HAVE_FORK) && defined (HAVE_EXECVE)
2077 }
2078
2079 MonoBoolean
2080 ves_icall_System_Diagnostics_Process_ShellExecuteEx_internal (MonoW32ProcessStartInfo *proc_start_info, MonoW32ProcessInfo *process_info)
2081 {
2082         const gunichar2 *lpFile;
2083         const gunichar2 *lpParameters;
2084         const gunichar2 *lpDirectory;
2085         gunichar2 *args;
2086         gboolean ret;
2087
2088         if (!proc_start_info->filename) {
2089                 /* w2k returns TRUE for this, for some reason. */
2090                 ret = TRUE;
2091                 goto done;
2092         }
2093
2094         lpFile = proc_start_info->filename ? mono_string_chars (proc_start_info->filename) : NULL;
2095         lpParameters = proc_start_info->arguments ? mono_string_chars (proc_start_info->arguments) : NULL;
2096         lpDirectory = proc_start_info->working_directory && mono_string_length (proc_start_info->working_directory) != 0 ?
2097                 mono_string_chars (proc_start_info->working_directory) : NULL;
2098
2099         /* Put both executable and parameters into the second argument
2100          * to process_create (), so it searches $PATH.  The conversion
2101          * into and back out of utf8 is because there is no
2102          * g_strdup_printf () equivalent for gunichar2 :-(
2103          */
2104         args = utf16_concat (utf16_quote, lpFile, utf16_quote, lpParameters == NULL ? NULL : utf16_space, lpParameters, NULL);
2105         if (args == NULL) {
2106                 mono_w32error_set_last (ERROR_INVALID_DATA);
2107                 ret = FALSE;
2108                 goto done;
2109         }
2110         ret = process_create (NULL, args, lpDirectory, NULL, process_info);
2111         g_free (args);
2112
2113         if (!ret && mono_w32error_get_last () == ERROR_OUTOFMEMORY)
2114                 goto done;
2115
2116         if (!ret) {
2117                 static char *handler;
2118                 static gunichar2 *handler_utf16;
2119
2120                 if (handler_utf16 == (gunichar2 *)-1) {
2121                         ret = FALSE;
2122                         goto done;
2123                 }
2124
2125 #ifdef PLATFORM_MACOSX
2126                 handler = g_strdup ("/usr/bin/open");
2127 #else
2128                 /*
2129                  * On Linux, try: xdg-open, the FreeDesktop standard way of doing it,
2130                  * if that fails, try to use gnome-open, then kfmclient
2131                  */
2132                 handler = g_find_program_in_path ("xdg-open");
2133                 if (handler == NULL){
2134                         handler = g_find_program_in_path ("gnome-open");
2135                         if (handler == NULL){
2136                                 handler = g_find_program_in_path ("kfmclient");
2137                                 if (handler == NULL){
2138                                         handler_utf16 = (gunichar2 *) -1;
2139                                         ret = FALSE;
2140                                         goto done;
2141                                 } else {
2142                                         /* kfmclient needs exec argument */
2143                                         char *old = handler;
2144                                         handler = g_strconcat (old, " exec",
2145                                                                NULL);
2146                                         g_free (old);
2147                                 }
2148                         }
2149                 }
2150 #endif
2151                 handler_utf16 = g_utf8_to_utf16 (handler, -1, NULL, NULL, NULL);
2152                 g_free (handler);
2153
2154                 /* Put quotes around the filename, in case it's a url
2155                  * that contains #'s (process_create() calls
2156                  * g_shell_parse_argv(), which deliberately throws
2157                  * away anything after an unquoted #).  Fixes bug
2158                  * 371567.
2159                  */
2160                 args = utf16_concat (handler_utf16, utf16_space, utf16_quote, lpFile, utf16_quote,
2161                         lpParameters == NULL ? NULL : utf16_space, lpParameters, NULL);
2162                 if (args == NULL) {
2163                         mono_w32error_set_last (ERROR_INVALID_DATA);
2164                         ret = FALSE;
2165                         goto done;
2166                 }
2167                 ret = process_create (NULL, args, lpDirectory, NULL, process_info);
2168                 g_free (args);
2169                 if (!ret) {
2170                         if (mono_w32error_get_last () != ERROR_OUTOFMEMORY)
2171                                 mono_w32error_set_last (ERROR_INVALID_DATA);
2172                         ret = FALSE;
2173                         goto done;
2174                 }
2175                 /* Shell exec should not return a process handle when it spawned a GUI thing, like a browser. */
2176                 mono_w32handle_close (process_info->process_handle);
2177                 process_info->process_handle = NULL;
2178         }
2179
2180 done:
2181         if (ret == FALSE) {
2182                 process_info->pid = -mono_w32error_get_last ();
2183         } else {
2184                 process_info->thread_handle = NULL;
2185 #if !defined(MONO_CROSS_COMPILE)
2186                 process_info->pid = mono_w32process_get_pid (process_info->process_handle);
2187 #else
2188                 process_info->pid = 0;
2189 #endif
2190                 process_info->tid = 0;
2191         }
2192
2193         return ret;
2194 }
2195
2196 /* Only used when UseShellExecute is false */
2197 static gboolean
2198 process_get_complete_path (const gunichar2 *appname, gchar **completed)
2199 {
2200         gchar *utf8app;
2201         gchar *found;
2202
2203         utf8app = g_utf16_to_utf8 (appname, -1, NULL, NULL, NULL);
2204
2205         if (g_path_is_absolute (utf8app)) {
2206                 *completed = g_shell_quote (utf8app);
2207                 g_free (utf8app);
2208                 return TRUE;
2209         }
2210
2211         if (g_file_test (utf8app, G_FILE_TEST_IS_EXECUTABLE) && !g_file_test (utf8app, G_FILE_TEST_IS_DIR)) {
2212                 *completed = g_shell_quote (utf8app);
2213                 g_free (utf8app);
2214                 return TRUE;
2215         }
2216
2217         found = g_find_program_in_path (utf8app);
2218         if (found == NULL) {
2219                 *completed = NULL;
2220                 g_free (utf8app);
2221                 return FALSE;
2222         }
2223
2224         *completed = g_shell_quote (found);
2225         g_free (found);
2226         g_free (utf8app);
2227         return TRUE;
2228 }
2229
2230 static gboolean
2231 process_get_shell_arguments (MonoW32ProcessStartInfo *proc_start_info, gunichar2 **shell_path)
2232 {
2233         gchar *complete_path = NULL;
2234
2235         *shell_path = NULL;
2236
2237         if (process_get_complete_path (mono_string_chars (proc_start_info->filename), &complete_path)) {
2238                 *shell_path = g_utf8_to_utf16 (complete_path, -1, NULL, NULL, NULL);
2239                 g_free (complete_path);
2240         }
2241
2242         return *shell_path != NULL;
2243 }
2244
2245 MonoBoolean
2246 ves_icall_System_Diagnostics_Process_CreateProcess_internal (MonoW32ProcessStartInfo *proc_start_info,
2247         HANDLE stdin_handle, HANDLE stdout_handle, HANDLE stderr_handle, MonoW32ProcessInfo *process_info)
2248 {
2249         gboolean ret;
2250         gunichar2 *dir;
2251         StartupHandles startup_handles;
2252         gunichar2 *shell_path = NULL;
2253         gunichar2 *args = NULL;
2254
2255         memset (&startup_handles, 0, sizeof (startup_handles));
2256         startup_handles.input = stdin_handle;
2257         startup_handles.output = stdout_handle;
2258         startup_handles.error = stderr_handle;
2259
2260         if (!process_get_shell_arguments (proc_start_info, &shell_path)) {
2261                 process_info->pid = -ERROR_FILE_NOT_FOUND;
2262                 return FALSE;
2263         }
2264
2265         args = proc_start_info->arguments && mono_string_length (proc_start_info->arguments) > 0 ?
2266                         mono_string_chars (proc_start_info->arguments): NULL;
2267
2268         /* The default dir name is "".  Turn that into NULL to mean "current directory" */
2269         dir = proc_start_info->working_directory && mono_string_length (proc_start_info->working_directory) > 0 ?
2270                         mono_string_chars (proc_start_info->working_directory) : NULL;
2271
2272         ret = process_create (shell_path, args, dir, &startup_handles, process_info);
2273
2274         if (shell_path != NULL)
2275                 g_free (shell_path);
2276
2277         if (!ret)
2278                 process_info->pid = -mono_w32error_get_last ();
2279
2280         return ret;
2281 }
2282
2283 /* Returns an array of pids */
2284 MonoArray *
2285 ves_icall_System_Diagnostics_Process_GetProcesses_internal (void)
2286 {
2287         MonoError error;
2288         MonoArray *procs;
2289         gpointer *pidarray;
2290         int i, count;
2291
2292         pidarray = mono_process_list (&count);
2293         if (!pidarray) {
2294                 mono_set_pending_exception (mono_get_exception_not_supported ("This system does not support EnumProcesses"));
2295                 return NULL;
2296         }
2297         procs = mono_array_new_checked (mono_domain_get (), mono_get_int32_class (), count, &error);
2298         if (mono_error_set_pending_exception (&error)) {
2299                 g_free (pidarray);
2300                 return NULL;
2301         }
2302         if (sizeof (guint32) == sizeof (gpointer)) {
2303                 memcpy (mono_array_addr (procs, guint32, 0), pidarray, count * sizeof (gint32));
2304         } else {
2305                 for (i = 0; i < count; ++i)
2306                         *(mono_array_addr (procs, guint32, i)) = GPOINTER_TO_UINT (pidarray [i]);
2307         }
2308         g_free (pidarray);
2309
2310         return procs;
2311 }
2312
2313 void
2314 mono_w32process_set_cli_launcher (gchar *path)
2315 {
2316         g_free (cli_launcher);
2317         cli_launcher = g_strdup (path);
2318 }
2319
2320 gpointer
2321 ves_icall_Microsoft_Win32_NativeMethods_GetCurrentProcess (void)
2322 {
2323         return current_process;
2324 }
2325
2326 MonoBoolean
2327 ves_icall_Microsoft_Win32_NativeMethods_GetExitCodeProcess (gpointer handle, gint32 *exitcode)
2328 {
2329         MonoW32HandleProcess *process_handle;
2330         gboolean res;
2331
2332         if (!exitcode)
2333                 return FALSE;
2334
2335         res = mono_w32handle_lookup (handle, MONO_W32HANDLE_PROCESS, (gpointer*) &process_handle);
2336         if (!res) {
2337                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Can't find process %p", __func__, handle);
2338                 return FALSE;
2339         }
2340
2341         if (process_handle->pid == current_pid) {
2342                 *exitcode = STILL_ACTIVE;
2343                 return TRUE;
2344         }
2345
2346         /* A process handle is only signalled if the process has exited
2347          * and has been waited for. Make sure any process exit has been
2348          * noticed before checking if the process is signalled.
2349          * Fixes bug 325463. */
2350         mono_w32handle_wait_one (handle, 0, TRUE);
2351
2352         *exitcode = mono_w32handle_issignalled (handle) ? process_handle->exitstatus : STILL_ACTIVE;
2353         return TRUE;
2354 }
2355
2356 MonoBoolean
2357 ves_icall_Microsoft_Win32_NativeMethods_CloseProcess (gpointer handle)
2358 {
2359         return mono_w32handle_close (handle);
2360 }
2361
2362 MonoBoolean
2363 ves_icall_Microsoft_Win32_NativeMethods_TerminateProcess (gpointer handle, gint32 exitcode)
2364 {
2365 #ifdef HAVE_KILL
2366         MonoW32HandleProcess *process_handle;
2367         int ret;
2368         pid_t pid;
2369         gboolean res;
2370
2371         res = mono_w32handle_lookup (handle, MONO_W32HANDLE_PROCESS, (gpointer*) &process_handle);
2372         if (!res) {
2373                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Can't find process %p", __func__, handle);
2374                 mono_w32error_set_last (ERROR_INVALID_HANDLE);
2375                 return FALSE;
2376         }
2377
2378         pid = process_handle->pid;
2379
2380         ret = kill (pid, exitcode == -1 ? SIGKILL : SIGTERM);
2381         if (ret == 0)
2382                 return TRUE;
2383
2384         switch (errno) {
2385         case EINVAL: mono_w32error_set_last (ERROR_INVALID_PARAMETER); break;
2386         case EPERM:  mono_w32error_set_last (ERROR_ACCESS_DENIED);     break;
2387         case ESRCH:  mono_w32error_set_last (ERROR_PROC_NOT_FOUND);    break;
2388         default:     mono_w32error_set_last (ERROR_GEN_FAILURE);       break;
2389         }
2390
2391         return FALSE;
2392 #else
2393         g_error ("kill() is not supported by this platform");
2394 #endif
2395 }
2396
2397 MonoBoolean
2398 ves_icall_Microsoft_Win32_NativeMethods_GetProcessWorkingSetSize (gpointer handle, gsize *min, gsize *max)
2399 {
2400         MonoW32HandleProcess *process_handle;
2401         gboolean res;
2402
2403         if (!min || !max)
2404                 return FALSE;
2405
2406         res = mono_w32handle_lookup (handle, MONO_W32HANDLE_PROCESS, (gpointer*) &process_handle);
2407         if (!res) {
2408                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Can't find process %p", __func__, handle);
2409                 return FALSE;
2410         }
2411
2412         if (!process_handle->child)
2413                 return FALSE;
2414
2415         *min = process_handle->min_working_set;
2416         *max = process_handle->max_working_set;
2417         return TRUE;
2418 }
2419
2420 MonoBoolean
2421 ves_icall_Microsoft_Win32_NativeMethods_SetProcessWorkingSetSize (gpointer handle, gsize min, gsize max)
2422 {
2423         MonoW32HandleProcess *process_handle;
2424         gboolean res;
2425
2426         res = mono_w32handle_lookup (handle, MONO_W32HANDLE_PROCESS, (gpointer*) &process_handle);
2427         if (!res) {
2428                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Can't find process %p", __func__, handle);
2429                 return FALSE;
2430         }
2431
2432         if (!process_handle->child)
2433                 return FALSE;
2434
2435         process_handle->min_working_set = min;
2436         process_handle->max_working_set = max;
2437         return TRUE;
2438 }
2439
2440 gint32
2441 ves_icall_Microsoft_Win32_NativeMethods_GetPriorityClass (gpointer handle)
2442 {
2443 #ifdef HAVE_GETPRIORITY
2444         MonoW32HandleProcess *process_handle;
2445         gint ret;
2446         pid_t pid;
2447         gboolean res;
2448
2449         res = mono_w32handle_lookup (handle, MONO_W32HANDLE_PROCESS, (gpointer*) &process_handle);
2450         if (!res) {
2451                 mono_w32error_set_last (ERROR_INVALID_HANDLE);
2452                 return 0;
2453         }
2454
2455         pid = process_handle->pid;
2456
2457         errno = 0;
2458         ret = getpriority (PRIO_PROCESS, pid);
2459         if (ret == -1 && errno != 0) {
2460                 switch (errno) {
2461                 case EPERM:
2462                 case EACCES:
2463                         mono_w32error_set_last (ERROR_ACCESS_DENIED);
2464                         break;
2465                 case ESRCH:
2466                         mono_w32error_set_last (ERROR_PROC_NOT_FOUND);
2467                         break;
2468                 default:
2469                         mono_w32error_set_last (ERROR_GEN_FAILURE);
2470                 }
2471                 return 0;
2472         }
2473
2474         if (ret == 0)
2475                 return MONO_W32PROCESS_PRIORITY_CLASS_NORMAL;
2476         else if (ret < -15)
2477                 return MONO_W32PROCESS_PRIORITY_CLASS_REALTIME;
2478         else if (ret < -10)
2479                 return MONO_W32PROCESS_PRIORITY_CLASS_HIGH;
2480         else if (ret < 0)
2481                 return MONO_W32PROCESS_PRIORITY_CLASS_ABOVE_NORMAL;
2482         else if (ret > 10)
2483                 return MONO_W32PROCESS_PRIORITY_CLASS_IDLE;
2484         else if (ret > 0)
2485                 return MONO_W32PROCESS_PRIORITY_CLASS_BELOW_NORMAL;
2486
2487         return MONO_W32PROCESS_PRIORITY_CLASS_NORMAL;
2488 #else
2489         mono_w32error_set_last (ERROR_NOT_SUPPORTED);
2490         return 0;
2491 #endif
2492 }
2493
2494 MonoBoolean
2495 ves_icall_Microsoft_Win32_NativeMethods_SetPriorityClass (gpointer handle, gint32 priorityClass)
2496 {
2497 #ifdef HAVE_SETPRIORITY
2498         MonoW32HandleProcess *process_handle;
2499         int ret;
2500         int prio;
2501         pid_t pid;
2502         gboolean res;
2503
2504         res = mono_w32handle_lookup (handle, MONO_W32HANDLE_PROCESS, (gpointer*) &process_handle);
2505         if (!res) {
2506                 mono_w32error_set_last (ERROR_INVALID_HANDLE);
2507                 return FALSE;
2508         }
2509
2510         pid = process_handle->pid;
2511
2512         switch (priorityClass) {
2513         case MONO_W32PROCESS_PRIORITY_CLASS_IDLE:
2514                 prio = 19;
2515                 break;
2516         case MONO_W32PROCESS_PRIORITY_CLASS_BELOW_NORMAL:
2517                 prio = 10;
2518                 break;
2519         case MONO_W32PROCESS_PRIORITY_CLASS_NORMAL:
2520                 prio = 0;
2521                 break;
2522         case MONO_W32PROCESS_PRIORITY_CLASS_ABOVE_NORMAL:
2523                 prio = -5;
2524                 break;
2525         case MONO_W32PROCESS_PRIORITY_CLASS_HIGH:
2526                 prio = -11;
2527                 break;
2528         case MONO_W32PROCESS_PRIORITY_CLASS_REALTIME:
2529                 prio = -20;
2530                 break;
2531         default:
2532                 mono_w32error_set_last (ERROR_INVALID_PARAMETER);
2533                 return FALSE;
2534         }
2535
2536         ret = setpriority (PRIO_PROCESS, pid, prio);
2537         if (ret == -1) {
2538                 switch (errno) {
2539                 case EPERM:
2540                 case EACCES:
2541                         mono_w32error_set_last (ERROR_ACCESS_DENIED);
2542                         break;
2543                 case ESRCH:
2544                         mono_w32error_set_last (ERROR_PROC_NOT_FOUND);
2545                         break;
2546                 default:
2547                         mono_w32error_set_last (ERROR_GEN_FAILURE);
2548                 }
2549         }
2550
2551         return ret == 0;
2552 #else
2553         mono_w32error_set_last (ERROR_NOT_SUPPORTED);
2554         return FALSE;
2555 #endif
2556 }
2557
2558 static void
2559 ticks_to_processtime (guint64 ticks, ProcessTime *processtime)
2560 {
2561         processtime->lowDateTime = ticks & 0xFFFFFFFF;
2562         processtime->highDateTime = ticks >> 32;
2563 }
2564
2565 MonoBoolean
2566 ves_icall_Microsoft_Win32_NativeMethods_GetProcessTimes (gpointer handle, gint64 *creation_time, gint64 *exit_time, gint64 *kernel_time, gint64 *user_time)
2567 {
2568         MonoW32HandleProcess *process_handle;
2569         ProcessTime *creation_processtime, *exit_processtime, *kernel_processtime, *user_processtime;
2570         gboolean res;
2571
2572         if (!creation_time || !exit_time || !kernel_time || !user_time) {
2573                 /* Not sure if w32 allows NULLs here or not */
2574                 return FALSE;
2575         }
2576
2577         creation_processtime = (ProcessTime*) creation_time;
2578         exit_processtime = (ProcessTime*) exit_time;
2579         kernel_processtime = (ProcessTime*) kernel_time;
2580         user_processtime = (ProcessTime*) user_time;
2581
2582         memset (creation_processtime, 0, sizeof (ProcessTime));
2583         memset (exit_processtime, 0, sizeof (ProcessTime));
2584         memset (kernel_processtime, 0, sizeof (ProcessTime));
2585         memset (user_processtime, 0, sizeof (ProcessTime));
2586
2587         res = mono_w32handle_lookup (handle, MONO_W32HANDLE_PROCESS, (gpointer*) &process_handle);
2588         if (!res) {
2589                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Can't find process %p", __func__, handle);
2590                 return FALSE;
2591         }
2592
2593         if (!process_handle->child) {
2594                 gint64 start_ticks, user_ticks, kernel_ticks;
2595
2596                 mono_process_get_times (GINT_TO_POINTER (process_handle->pid),
2597                         &start_ticks, &user_ticks, &kernel_ticks);
2598
2599                 ticks_to_processtime (start_ticks, creation_processtime);
2600                 ticks_to_processtime (user_ticks, kernel_processtime);
2601                 ticks_to_processtime (kernel_ticks, user_processtime);
2602                 return TRUE;
2603         }
2604
2605         ticks_to_processtime (process_handle->create_time, creation_processtime);
2606
2607         /* A process handle is only signalled if the process has
2608          * exited, otherwise exit_processtime isn't set */
2609         if (mono_w32handle_issignalled (handle))
2610                 ticks_to_processtime (process_handle->exit_time, exit_processtime);
2611
2612 #ifdef HAVE_GETRUSAGE
2613         if (process_handle->pid == getpid ()) {
2614                 struct rusage time_data;
2615                 if (getrusage (RUSAGE_SELF, &time_data) == 0) {
2616                         ticks_to_processtime ((guint64)time_data.ru_utime.tv_sec * 10000000 + (guint64)time_data.ru_utime.tv_usec * 10, user_processtime);
2617                         ticks_to_processtime ((guint64)time_data.ru_stime.tv_sec * 10000000 + (guint64)time_data.ru_stime.tv_usec * 10, kernel_processtime);
2618                 }
2619         }
2620 #endif
2621
2622         return TRUE;
2623 }
2624
2625 static IMAGE_SECTION_HEADER *
2626 get_enclosing_section_header (guint32 rva, IMAGE_NT_HEADERS32 *nt_headers)
2627 {
2628         IMAGE_SECTION_HEADER *section = IMAGE_FIRST_SECTION32 (nt_headers);
2629         guint32 i;
2630
2631         for (i = 0; i < GUINT16_FROM_LE (nt_headers->FileHeader.NumberOfSections); i++, section++) {
2632                 guint32 size = GUINT32_FROM_LE (section->Misc.VirtualSize);
2633                 if (size == 0) {
2634                         size = GUINT32_FROM_LE (section->SizeOfRawData);
2635                 }
2636
2637                 if ((rva >= GUINT32_FROM_LE (section->VirtualAddress)) &&
2638                     (rva < (GUINT32_FROM_LE (section->VirtualAddress) + size))) {
2639                         return(section);
2640                 }
2641         }
2642
2643         return(NULL);
2644 }
2645
2646 /* This works for both 32bit and 64bit files, as the differences are
2647  * all after the section header block
2648  */
2649 static gpointer
2650 get_ptr_from_rva (guint32 rva, IMAGE_NT_HEADERS32 *ntheaders, gpointer file_map)
2651 {
2652         IMAGE_SECTION_HEADER *section_header;
2653         guint32 delta;
2654
2655         section_header = get_enclosing_section_header (rva, ntheaders);
2656         if (section_header == NULL) {
2657                 return(NULL);
2658         }
2659
2660         delta = (guint32)(GUINT32_FROM_LE (section_header->VirtualAddress) -
2661                           GUINT32_FROM_LE (section_header->PointerToRawData));
2662
2663         return((guint8 *)file_map + rva - delta);
2664 }
2665
2666 static gpointer
2667 scan_resource_dir (IMAGE_RESOURCE_DIRECTORY *root, IMAGE_NT_HEADERS32 *nt_headers, gpointer file_map,
2668         IMAGE_RESOURCE_DIRECTORY_ENTRY *entry, int level, guint32 res_id, guint32 lang_id, guint32 *size)
2669 {
2670         IMAGE_RESOURCE_DIRECTORY_ENTRY swapped_entry;
2671         gboolean is_string, is_dir;
2672         guint32 name_offset, dir_offset, data_offset;
2673
2674         swapped_entry.Name = GUINT32_FROM_LE (entry->Name);
2675         swapped_entry.OffsetToData = GUINT32_FROM_LE (entry->OffsetToData);
2676
2677         is_string = swapped_entry.NameIsString;
2678         is_dir = swapped_entry.DataIsDirectory;
2679         name_offset = swapped_entry.NameOffset;
2680         dir_offset = swapped_entry.OffsetToDirectory;
2681         data_offset = swapped_entry.OffsetToData;
2682
2683         if (level == 0) {
2684                 /* Normally holds a directory entry for each type of
2685                  * resource
2686                  */
2687                 if ((is_string == FALSE &&
2688                      name_offset != res_id) ||
2689                     (is_string == TRUE)) {
2690                         return(NULL);
2691                 }
2692         } else if (level == 1) {
2693                 /* Normally holds a directory entry for each resource
2694                  * item
2695                  */
2696         } else if (level == 2) {
2697                 /* Normally holds a directory entry for each language
2698                  */
2699                 if ((is_string == FALSE &&
2700                      name_offset != lang_id &&
2701                      lang_id != 0) ||
2702                     (is_string == TRUE)) {
2703                         return(NULL);
2704                 }
2705         } else {
2706                 g_assert_not_reached ();
2707         }
2708
2709         if (is_dir == TRUE) {
2710                 IMAGE_RESOURCE_DIRECTORY *res_dir = (IMAGE_RESOURCE_DIRECTORY *)((guint8 *)root + dir_offset);
2711                 IMAGE_RESOURCE_DIRECTORY_ENTRY *sub_entries = (IMAGE_RESOURCE_DIRECTORY_ENTRY *)(res_dir + 1);
2712                 guint32 entries, i;
2713
2714                 entries = GUINT16_FROM_LE (res_dir->NumberOfNamedEntries) + GUINT16_FROM_LE (res_dir->NumberOfIdEntries);
2715
2716                 for (i = 0; i < entries; i++) {
2717                         IMAGE_RESOURCE_DIRECTORY_ENTRY *sub_entry = &sub_entries[i];
2718                         gpointer ret;
2719
2720                         ret = scan_resource_dir (root, nt_headers, file_map,
2721                                                  sub_entry, level + 1, res_id,
2722                                                  lang_id, size);
2723                         if (ret != NULL) {
2724                                 return(ret);
2725                         }
2726                 }
2727
2728                 return(NULL);
2729         } else {
2730                 IMAGE_RESOURCE_DATA_ENTRY *data_entry = (IMAGE_RESOURCE_DATA_ENTRY *)((guint8 *)root + data_offset);
2731                 *size = GUINT32_FROM_LE (data_entry->Size);
2732
2733                 return(get_ptr_from_rva (GUINT32_FROM_LE (data_entry->OffsetToData), nt_headers, file_map));
2734         }
2735 }
2736
2737 static gpointer
2738 find_pe_file_resources32 (gpointer file_map, guint32 map_size, guint32 res_id, guint32 lang_id, guint32 *size)
2739 {
2740         IMAGE_DOS_HEADER *dos_header;
2741         IMAGE_NT_HEADERS32 *nt_headers;
2742         IMAGE_RESOURCE_DIRECTORY *resource_dir;
2743         IMAGE_RESOURCE_DIRECTORY_ENTRY *resource_dir_entry;
2744         guint32 resource_rva, entries, i;
2745         gpointer ret = NULL;
2746
2747         dos_header = (IMAGE_DOS_HEADER *)file_map;
2748         if (dos_header->e_magic != IMAGE_DOS_SIGNATURE) {
2749                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Bad dos signature 0x%x", __func__, dos_header->e_magic);
2750
2751                 mono_w32error_set_last (ERROR_INVALID_DATA);
2752                 return(NULL);
2753         }
2754
2755         if (map_size < sizeof(IMAGE_NT_HEADERS32) + GUINT32_FROM_LE (dos_header->e_lfanew)) {
2756                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: File is too small: %" G_GUINT32_FORMAT, __func__, map_size);
2757
2758                 mono_w32error_set_last (ERROR_BAD_LENGTH);
2759                 return(NULL);
2760         }
2761
2762         nt_headers = (IMAGE_NT_HEADERS32 *)((guint8 *)file_map + GUINT32_FROM_LE (dos_header->e_lfanew));
2763         if (nt_headers->Signature != IMAGE_NT_SIGNATURE) {
2764                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Bad NT signature 0x%x", __func__, nt_headers->Signature);
2765
2766                 mono_w32error_set_last (ERROR_INVALID_DATA);
2767                 return(NULL);
2768         }
2769
2770         if (nt_headers->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
2771                 /* Do 64-bit stuff */
2772                 resource_rva = GUINT32_FROM_LE (((IMAGE_NT_HEADERS64 *)nt_headers)->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress);
2773         } else {
2774                 resource_rva = GUINT32_FROM_LE (nt_headers->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress);
2775         }
2776
2777         if (resource_rva == 0) {
2778                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: No resources in file!", __func__);
2779
2780                 mono_w32error_set_last (ERROR_INVALID_DATA);
2781                 return(NULL);
2782         }
2783
2784         resource_dir = (IMAGE_RESOURCE_DIRECTORY *)get_ptr_from_rva (resource_rva, (IMAGE_NT_HEADERS32 *)nt_headers, file_map);
2785         if (resource_dir == NULL) {
2786                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Can't find resource directory", __func__);
2787
2788                 mono_w32error_set_last (ERROR_INVALID_DATA);
2789                 return(NULL);
2790         }
2791
2792         entries = GUINT16_FROM_LE (resource_dir->NumberOfNamedEntries) + GUINT16_FROM_LE (resource_dir->NumberOfIdEntries);
2793         resource_dir_entry = (IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resource_dir + 1);
2794
2795         for (i = 0; i < entries; i++) {
2796                 IMAGE_RESOURCE_DIRECTORY_ENTRY *direntry = &resource_dir_entry[i];
2797                 ret = scan_resource_dir (resource_dir,
2798                                          (IMAGE_NT_HEADERS32 *)nt_headers,
2799                                          file_map, direntry, 0, res_id,
2800                                          lang_id, size);
2801                 if (ret != NULL) {
2802                         return(ret);
2803                 }
2804         }
2805
2806         return(NULL);
2807 }
2808
2809 static gpointer
2810 find_pe_file_resources64 (gpointer file_map, guint32 map_size, guint32 res_id, guint32 lang_id, guint32 *size)
2811 {
2812         IMAGE_DOS_HEADER *dos_header;
2813         IMAGE_NT_HEADERS64 *nt_headers;
2814         IMAGE_RESOURCE_DIRECTORY *resource_dir;
2815         IMAGE_RESOURCE_DIRECTORY_ENTRY *resource_dir_entry;
2816         guint32 resource_rva, entries, i;
2817         gpointer ret = NULL;
2818
2819         dos_header = (IMAGE_DOS_HEADER *)file_map;
2820         if (dos_header->e_magic != IMAGE_DOS_SIGNATURE) {
2821                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Bad dos signature 0x%x", __func__, dos_header->e_magic);
2822
2823                 mono_w32error_set_last (ERROR_INVALID_DATA);
2824                 return(NULL);
2825         }
2826
2827         if (map_size < sizeof(IMAGE_NT_HEADERS64) + GUINT32_FROM_LE (dos_header->e_lfanew)) {
2828                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: File is too small: %" G_GUINT32_FORMAT, __func__, map_size);
2829
2830                 mono_w32error_set_last (ERROR_BAD_LENGTH);
2831                 return(NULL);
2832         }
2833
2834         nt_headers = (IMAGE_NT_HEADERS64 *)((guint8 *)file_map + GUINT32_FROM_LE (dos_header->e_lfanew));
2835         if (nt_headers->Signature != IMAGE_NT_SIGNATURE) {
2836                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Bad NT signature 0x%x", __func__,
2837                            nt_headers->Signature);
2838
2839                 mono_w32error_set_last (ERROR_INVALID_DATA);
2840                 return(NULL);
2841         }
2842
2843         if (nt_headers->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
2844                 /* Do 64-bit stuff */
2845                 resource_rva = GUINT32_FROM_LE (((IMAGE_NT_HEADERS64 *)nt_headers)->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress);
2846         } else {
2847                 resource_rva = GUINT32_FROM_LE (nt_headers->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress);
2848         }
2849
2850         if (resource_rva == 0) {
2851                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: No resources in file!", __func__);
2852
2853                 mono_w32error_set_last (ERROR_INVALID_DATA);
2854                 return(NULL);
2855         }
2856
2857         resource_dir = (IMAGE_RESOURCE_DIRECTORY *)get_ptr_from_rva (resource_rva, (IMAGE_NT_HEADERS32 *)nt_headers, file_map);
2858         if (resource_dir == NULL) {
2859                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Can't find resource directory", __func__);
2860
2861                 mono_w32error_set_last (ERROR_INVALID_DATA);
2862                 return(NULL);
2863         }
2864
2865         entries = GUINT16_FROM_LE (resource_dir->NumberOfNamedEntries) + GUINT16_FROM_LE (resource_dir->NumberOfIdEntries);
2866         resource_dir_entry = (IMAGE_RESOURCE_DIRECTORY_ENTRY *)(resource_dir + 1);
2867
2868         for (i = 0; i < entries; i++) {
2869                 IMAGE_RESOURCE_DIRECTORY_ENTRY *direntry = &resource_dir_entry[i];
2870                 ret = scan_resource_dir (resource_dir,
2871                                          (IMAGE_NT_HEADERS32 *)nt_headers,
2872                                          file_map, direntry, 0, res_id,
2873                                          lang_id, size);
2874                 if (ret != NULL) {
2875                         return(ret);
2876                 }
2877         }
2878
2879         return(NULL);
2880 }
2881
2882 static gpointer
2883 find_pe_file_resources (gpointer file_map, guint32 map_size, guint32 res_id, guint32 lang_id, guint32 *size)
2884 {
2885         /* Figure this out when we support 64bit PE files */
2886         if (1) {
2887                 return find_pe_file_resources32 (file_map, map_size, res_id,
2888                                                  lang_id, size);
2889         } else {
2890                 return find_pe_file_resources64 (file_map, map_size, res_id,
2891                                                  lang_id, size);
2892         }
2893 }
2894
2895 static gpointer
2896 map_pe_file (gunichar2 *filename, gint32 *map_size, void **handle)
2897 {
2898         gchar *filename_ext;
2899         int fd;
2900         struct stat statbuf;
2901         gpointer file_map;
2902
2903         /* According to the MSDN docs, a search path is applied to
2904          * filename.  FIXME: implement this, for now just pass it
2905          * straight to fopen
2906          */
2907
2908         filename_ext = mono_unicode_to_external (filename);
2909         if (filename_ext == NULL) {
2910                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: unicode conversion returned NULL", __func__);
2911
2912                 mono_w32error_set_last (ERROR_INVALID_NAME);
2913                 return(NULL);
2914         }
2915
2916         fd = open (filename_ext, O_RDONLY, 0);
2917         if (fd == -1 && (errno == ENOENT || errno == ENOTDIR) && IS_PORTABILITY_SET) {
2918                 gint saved_errno;
2919                 gchar *located_filename;
2920
2921                 saved_errno = errno;
2922
2923                 located_filename = mono_portability_find_file (filename_ext, TRUE);
2924                 if (!located_filename) {
2925                         errno = saved_errno;
2926
2927                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Error opening file %s (1): %s", __func__, filename_ext, strerror (errno));
2928
2929                         g_free (filename_ext);
2930
2931                         mono_w32error_set_last (mono_w32error_unix_to_win32 (errno));
2932                         return NULL;
2933                 }
2934
2935                 fd = open (located_filename, O_RDONLY, 0);
2936                 if (fd == -1) {
2937                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Error opening file %s (2): %s", __func__, filename_ext, strerror (errno));
2938
2939                         g_free (filename_ext);
2940                         g_free (located_filename);
2941
2942                         mono_w32error_set_last (mono_w32error_unix_to_win32 (errno));
2943                         return NULL;
2944                 }
2945
2946                 g_free (located_filename);
2947         }
2948
2949         if (fstat (fd, &statbuf) == -1) {
2950                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Error stat()ing file %s: %s", __func__, filename_ext, strerror (errno));
2951
2952                 mono_w32error_set_last (mono_w32error_unix_to_win32 (errno));
2953                 g_free (filename_ext);
2954                 close (fd);
2955                 return(NULL);
2956         }
2957         *map_size = statbuf.st_size;
2958
2959         /* Check basic file size */
2960         if (statbuf.st_size < sizeof(IMAGE_DOS_HEADER)) {
2961                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: File %s is too small: %lld", __func__, filename_ext, (long long) statbuf.st_size);
2962
2963                 mono_w32error_set_last (ERROR_BAD_LENGTH);
2964                 g_free (filename_ext);
2965                 close (fd);
2966                 return(NULL);
2967         }
2968
2969         file_map = mono_file_map (statbuf.st_size, MONO_MMAP_READ | MONO_MMAP_PRIVATE, fd, 0, handle);
2970         if (file_map == NULL) {
2971                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Error mmap()int file %s: %s", __func__, filename_ext, strerror (errno));
2972
2973                 mono_w32error_set_last (mono_w32error_unix_to_win32 (errno));
2974                 g_free (filename_ext);
2975                 close (fd);
2976                 return(NULL);
2977         }
2978
2979         /* Don't need the fd any more */
2980         close (fd);
2981         g_free (filename_ext);
2982
2983         return(file_map);
2984 }
2985
2986 static void
2987 unmap_pe_file (gpointer file_map, void *handle)
2988 {
2989         mono_file_unmap (file_map, handle);
2990 }
2991
2992 static guint32
2993 unicode_chars (const gunichar2 *str)
2994 {
2995         guint32 len = 0;
2996
2997         do {
2998                 if (str[len] == '\0') {
2999                         return(len);
3000                 }
3001                 len++;
3002         } while(1);
3003 }
3004
3005 static gboolean
3006 unicode_compare (const gunichar2 *str1, const gunichar2 *str2)
3007 {
3008         while (*str1 && *str2) {
3009                 if (*str1 != *str2) {
3010                         return(FALSE);
3011                 }
3012                 ++str1;
3013                 ++str2;
3014         }
3015
3016         return(*str1 == *str2);
3017 }
3018
3019 /* compare a little-endian null-terminated utf16 string and a normal string.
3020  * Can be used only for ascii or latin1 chars.
3021  */
3022 static gboolean
3023 unicode_string_equals (const gunichar2 *str1, const gchar *str2)
3024 {
3025         while (*str1 && *str2) {
3026                 if (GUINT16_TO_LE (*str1) != *str2) {
3027                         return(FALSE);
3028                 }
3029                 ++str1;
3030                 ++str2;
3031         }
3032
3033         return(*str1 == *str2);
3034 }
3035
3036 typedef struct {
3037         guint16 data_len;
3038         guint16 value_len;
3039         guint16 type;
3040         gunichar2 *key;
3041 } version_data;
3042
3043 /* Returns a pointer to the value data, because there's no way to know
3044  * how big that data is (value_len is set to zero for most blocks :-( )
3045  */
3046 static gconstpointer
3047 get_versioninfo_block (gconstpointer data, version_data *block)
3048 {
3049         block->data_len = GUINT16_FROM_LE (*((guint16 *)data));
3050         data = (char *)data + sizeof(guint16);
3051         block->value_len = GUINT16_FROM_LE (*((guint16 *)data));
3052         data = (char *)data + sizeof(guint16);
3053
3054         /* No idea what the type is supposed to indicate */
3055         block->type = GUINT16_FROM_LE (*((guint16 *)data));
3056         data = (char *)data + sizeof(guint16);
3057         block->key = ((gunichar2 *)data);
3058
3059         /* Skip over the key (including the terminator) */
3060         data = ((gunichar2 *)data) + (unicode_chars (block->key) + 1);
3061
3062         /* align on a 32-bit boundary */
3063         ALIGN32 (data);
3064
3065         return(data);
3066 }
3067
3068 static gconstpointer
3069 get_fixedfileinfo_block (gconstpointer data, version_data *block)
3070 {
3071         gconstpointer data_ptr;
3072         VS_FIXEDFILEINFO *ffi;
3073
3074         data_ptr = get_versioninfo_block (data, block);
3075
3076         if (block->value_len != sizeof(VS_FIXEDFILEINFO)) {
3077                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: FIXEDFILEINFO size mismatch", __func__);
3078                 return(NULL);
3079         }
3080
3081         if (!unicode_string_equals (block->key, "VS_VERSION_INFO")) {
3082                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: VS_VERSION_INFO mismatch", __func__);
3083
3084                 return(NULL);
3085         }
3086
3087         ffi = ((VS_FIXEDFILEINFO *)data_ptr);
3088         if ((ffi->dwSignature != VS_FFI_SIGNATURE) ||
3089             (ffi->dwStrucVersion != VS_FFI_STRUCVERSION)) {
3090                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: FIXEDFILEINFO bad signature", __func__);
3091
3092                 return(NULL);
3093         }
3094
3095         return(data_ptr);
3096 }
3097
3098 static gconstpointer
3099 get_varfileinfo_block (gconstpointer data_ptr, version_data *block)
3100 {
3101         /* data is pointing at a Var block
3102          */
3103         data_ptr = get_versioninfo_block (data_ptr, block);
3104
3105         return(data_ptr);
3106 }
3107
3108 static gconstpointer
3109 get_string_block (gconstpointer data_ptr, const gunichar2 *string_key, gpointer *string_value,
3110         guint32 *string_value_len, version_data *block)
3111 {
3112         guint16 data_len = block->data_len;
3113         guint16 string_len = 28; /* Length of the StringTable block */
3114         char *orig_data_ptr = (char *)data_ptr - 28;
3115
3116         /* data_ptr is pointing at an array of one or more String blocks
3117          * with total length (not including alignment padding) of
3118          * data_len
3119          */
3120         while (((char *)data_ptr - (char *)orig_data_ptr) < data_len) {
3121                 /* align on a 32-bit boundary */
3122                 ALIGN32 (data_ptr);
3123
3124                 data_ptr = get_versioninfo_block (data_ptr, block);
3125                 if (block->data_len == 0) {
3126                         /* We must have hit padding, so give up
3127                          * processing now
3128                          */
3129                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Hit 0-length block, giving up", __func__);
3130
3131                         return(NULL);
3132                 }
3133
3134                 string_len = string_len + block->data_len;
3135
3136                 if (string_key != NULL &&
3137                     string_value != NULL &&
3138                     string_value_len != NULL &&
3139                     unicode_compare (string_key, block->key) == TRUE) {
3140                         *string_value = (gpointer)data_ptr;
3141                         *string_value_len = block->value_len;
3142                 }
3143
3144                 /* Skip over the value */
3145                 data_ptr = ((gunichar2 *)data_ptr) + block->value_len;
3146         }
3147
3148         return(data_ptr);
3149 }
3150
3151 /* Returns a pointer to the byte following the Stringtable block, or
3152  * NULL if the data read hits padding.  We can't recover from this
3153  * because the data length does not include padding bytes, so it's not
3154  * possible to just return the start position + length
3155  *
3156  * If lang == NULL it means we're just stepping through this block
3157  */
3158 static gconstpointer
3159 get_stringtable_block (gconstpointer data_ptr, gchar *lang, const gunichar2 *string_key, gpointer *string_value,
3160         guint32 *string_value_len, version_data *block)
3161 {
3162         guint16 data_len = block->data_len;
3163         guint16 string_len = 36; /* length of the StringFileInfo block */
3164         gchar *found_lang;
3165         gchar *lowercase_lang;
3166
3167         /* data_ptr is pointing at an array of StringTable blocks,
3168          * with total length (not including alignment padding) of
3169          * data_len
3170          */
3171
3172         while(string_len < data_len) {
3173                 /* align on a 32-bit boundary */
3174                 ALIGN32 (data_ptr);
3175
3176                 data_ptr = get_versioninfo_block (data_ptr, block);
3177                 if (block->data_len == 0) {
3178                         /* We must have hit padding, so give up
3179                          * processing now
3180                          */
3181                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Hit 0-length block, giving up", __func__);
3182                         return(NULL);
3183                 }
3184
3185                 string_len = string_len + block->data_len;
3186
3187                 found_lang = g_utf16_to_utf8 (block->key, 8, NULL, NULL, NULL);
3188                 if (found_lang == NULL) {
3189                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Didn't find a valid language key, giving up", __func__);
3190                         return(NULL);
3191                 }
3192
3193                 lowercase_lang = g_utf8_strdown (found_lang, -1);
3194                 g_free (found_lang);
3195                 found_lang = lowercase_lang;
3196                 lowercase_lang = NULL;
3197
3198                 if (lang != NULL && !strcmp (found_lang, lang)) {
3199                         /* Got the one we're interested in */
3200                         data_ptr = get_string_block (data_ptr, string_key,
3201                                                      string_value,
3202                                                      string_value_len, block);
3203                 } else {
3204                         data_ptr = get_string_block (data_ptr, NULL, NULL,
3205                                                      NULL, block);
3206                 }
3207
3208                 g_free (found_lang);
3209
3210                 if (data_ptr == NULL) {
3211                         /* Child block hit padding */
3212                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Child block hit 0-length block, giving up", __func__);
3213                         return(NULL);
3214                 }
3215         }
3216
3217         return(data_ptr);
3218 }
3219
3220 #if G_BYTE_ORDER == G_BIG_ENDIAN
3221 static gconstpointer
3222 big_up_string_block (gconstpointer data_ptr, version_data *block)
3223 {
3224         guint16 data_len = block->data_len;
3225         guint16 string_len = 28; /* Length of the StringTable block */
3226         gchar *big_value;
3227         char *orig_data_ptr = (char *)data_ptr - 28;
3228
3229         /* data_ptr is pointing at an array of one or more String
3230          * blocks with total length (not including alignment padding)
3231          * of data_len
3232          */
3233         while (((char *)data_ptr - (char *)orig_data_ptr) < data_len) {
3234                 /* align on a 32-bit boundary */
3235                 ALIGN32 (data_ptr);
3236
3237                 data_ptr = get_versioninfo_block (data_ptr, block);
3238                 if (block->data_len == 0) {
3239                         /* We must have hit padding, so give up
3240                          * processing now
3241                          */
3242                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Hit 0-length block, giving up", __func__);
3243                         return(NULL);
3244                 }
3245
3246                 string_len = string_len + block->data_len;
3247
3248                 big_value = g_convert ((gchar *)block->key,
3249                                        unicode_chars (block->key) * 2,
3250                                        "UTF-16BE", "UTF-16LE", NULL, NULL,
3251                                        NULL);
3252                 if (big_value == NULL) {
3253                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Didn't find a valid string, giving up", __func__);
3254                         return(NULL);
3255                 }
3256
3257                 /* The swapped string should be exactly the same
3258                  * length as the original little-endian one, but only
3259                  * copy the number of original chars just to be on the
3260                  * safe side
3261                  */
3262                 memcpy (block->key, big_value, unicode_chars (block->key) * 2);
3263                 g_free (big_value);
3264
3265                 big_value = g_convert ((gchar *)data_ptr,
3266                                        unicode_chars (data_ptr) * 2,
3267                                        "UTF-16BE", "UTF-16LE", NULL, NULL,
3268                                        NULL);
3269                 if (big_value == NULL) {
3270                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Didn't find a valid data string, giving up", __func__);
3271                         return(NULL);
3272                 }
3273                 memcpy ((gpointer)data_ptr, big_value,
3274                         unicode_chars (data_ptr) * 2);
3275                 g_free (big_value);
3276
3277                 data_ptr = ((gunichar2 *)data_ptr) + block->value_len;
3278         }
3279
3280         return(data_ptr);
3281 }
3282
3283 /* Returns a pointer to the byte following the Stringtable block, or
3284  * NULL if the data read hits padding.  We can't recover from this
3285  * because the data length does not include padding bytes, so it's not
3286  * possible to just return the start position + length
3287  */
3288 static gconstpointer
3289 big_up_stringtable_block (gconstpointer data_ptr, version_data *block)
3290 {
3291         guint16 data_len = block->data_len;
3292         guint16 string_len = 36; /* length of the StringFileInfo block */
3293         gchar *big_value;
3294
3295         /* data_ptr is pointing at an array of StringTable blocks,
3296          * with total length (not including alignment padding) of
3297          * data_len
3298          */
3299
3300         while(string_len < data_len) {
3301                 /* align on a 32-bit boundary */
3302                 ALIGN32 (data_ptr);
3303
3304                 data_ptr = get_versioninfo_block (data_ptr, block);
3305                 if (block->data_len == 0) {
3306                         /* We must have hit padding, so give up
3307                          * processing now
3308                          */
3309                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Hit 0-length block, giving up", __func__);
3310                         return(NULL);
3311                 }
3312
3313                 string_len = string_len + block->data_len;
3314
3315                 big_value = g_convert ((gchar *)block->key, 16, "UTF-16BE",
3316                                        "UTF-16LE", NULL, NULL, NULL);
3317                 if (big_value == NULL) {
3318                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Didn't find a valid string, giving up", __func__);
3319                         return(NULL);
3320                 }
3321
3322                 memcpy (block->key, big_value, 16);
3323                 g_free (big_value);
3324
3325                 data_ptr = big_up_string_block (data_ptr, block);
3326
3327                 if (data_ptr == NULL) {
3328                         /* Child block hit padding */
3329                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Child block hit 0-length block, giving up", __func__);
3330                         return(NULL);
3331                 }
3332         }
3333
3334         return(data_ptr);
3335 }
3336
3337 /* Follows the data structures and turns all UTF-16 strings from the
3338  * LE found in the resource section into UTF-16BE
3339  */
3340 static void
3341 big_up (gconstpointer datablock, guint32 size)
3342 {
3343         gconstpointer data_ptr;
3344         gint32 data_len; /* signed to guard against underflow */
3345         version_data block;
3346
3347         data_ptr = get_fixedfileinfo_block (datablock, &block);
3348         if (data_ptr != NULL) {
3349                 VS_FIXEDFILEINFO *ffi = (VS_FIXEDFILEINFO *)data_ptr;
3350
3351                 /* Byteswap all the fields */
3352                 ffi->dwFileVersionMS = GUINT32_SWAP_LE_BE (ffi->dwFileVersionMS);
3353                 ffi->dwFileVersionLS = GUINT32_SWAP_LE_BE (ffi->dwFileVersionLS);
3354                 ffi->dwProductVersionMS = GUINT32_SWAP_LE_BE (ffi->dwProductVersionMS);
3355                 ffi->dwProductVersionLS = GUINT32_SWAP_LE_BE (ffi->dwProductVersionLS);
3356                 ffi->dwFileFlagsMask = GUINT32_SWAP_LE_BE (ffi->dwFileFlagsMask);
3357                 ffi->dwFileFlags = GUINT32_SWAP_LE_BE (ffi->dwFileFlags);
3358                 ffi->dwFileOS = GUINT32_SWAP_LE_BE (ffi->dwFileOS);
3359                 ffi->dwFileType = GUINT32_SWAP_LE_BE (ffi->dwFileType);
3360                 ffi->dwFileSubtype = GUINT32_SWAP_LE_BE (ffi->dwFileSubtype);
3361                 ffi->dwFileDateMS = GUINT32_SWAP_LE_BE (ffi->dwFileDateMS);
3362                 ffi->dwFileDateLS = GUINT32_SWAP_LE_BE (ffi->dwFileDateLS);
3363
3364                 /* The FFI and header occupies the first 92 bytes
3365                  */
3366                 data_ptr = (char *)data_ptr + sizeof(VS_FIXEDFILEINFO);
3367                 data_len = block.data_len - 92;
3368
3369                 /* There now follow zero or one StringFileInfo blocks
3370                  * and zero or one VarFileInfo blocks
3371                  */
3372                 while (data_len > 0) {
3373                         /* align on a 32-bit boundary */
3374                         ALIGN32 (data_ptr);
3375
3376                         data_ptr = get_versioninfo_block (data_ptr, &block);
3377                         if (block.data_len == 0) {
3378                                 /* We must have hit padding, so give
3379                                  * up processing now
3380                                  */
3381                                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Hit 0-length block, giving up", __func__);
3382                                 return;
3383                         }
3384
3385                         data_len = data_len - block.data_len;
3386
3387                         if (unicode_string_equals (block.key, "VarFileInfo")) {
3388                                 data_ptr = get_varfileinfo_block (data_ptr,
3389                                                                   &block);
3390                                 data_ptr = ((guchar *)data_ptr) + block.value_len;
3391                         } else if (unicode_string_equals (block.key,
3392                                                           "StringFileInfo")) {
3393                                 data_ptr = big_up_stringtable_block (data_ptr,
3394                                                                      &block);
3395                         } else {
3396                                 /* Bogus data */
3397                                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Not a valid VERSIONINFO child block", __func__);
3398                                 return;
3399                         }
3400
3401                         if (data_ptr == NULL) {
3402                                 /* Child block hit padding */
3403                                 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Child block hit 0-length block, giving up", __func__);
3404                                 return;
3405                         }
3406                 }
3407         }
3408 }
3409 #endif
3410
3411 guint32
3412 mono_w32process_get_fileversion_info_size (gunichar2 *filename, guint32 *handle)
3413 {
3414         gpointer file_map;
3415         gpointer versioninfo;
3416         void *map_handle;
3417         gint32 map_size;
3418         guint32 size;
3419
3420         /* This value is unused, but set to zero */
3421         *handle = 0;
3422
3423         file_map = map_pe_file (filename, &map_size, &map_handle);
3424         if (file_map == NULL) {
3425                 return(0);
3426         }
3427
3428         versioninfo = find_pe_file_resources (file_map, map_size, RT_VERSION, 0, &size);
3429         if (versioninfo == NULL) {
3430                 /* Didn't find the resource, so set the return value
3431                  * to 0
3432                  */
3433                 size = 0;
3434         }
3435
3436         unmap_pe_file (file_map, map_handle);
3437
3438         return(size);
3439 }
3440
3441 gboolean
3442 mono_w32process_get_fileversion_info (gunichar2 *filename, guint32 handle G_GNUC_UNUSED, guint32 len, gpointer data)
3443 {
3444         gpointer file_map;
3445         gpointer versioninfo;
3446         void *map_handle;
3447         gint32 map_size;
3448         guint32 size;
3449         gboolean ret = FALSE;
3450
3451         file_map = map_pe_file (filename, &map_size, &map_handle);
3452         if (file_map == NULL) {
3453                 return(FALSE);
3454         }
3455
3456         versioninfo = find_pe_file_resources (file_map, map_size, RT_VERSION,
3457                                               0, &size);
3458         if (versioninfo != NULL) {
3459                 /* This could probably process the data so that
3460                  * mono_w32process_ver_query_value() doesn't have to follow the data
3461                  * blocks every time.  But hey, these functions aren't
3462                  * likely to appear in many profiles.
3463                  */
3464                 memcpy (data, versioninfo, len < size?len:size);
3465                 ret = TRUE;
3466
3467 #if G_BYTE_ORDER == G_BIG_ENDIAN
3468                 big_up (data, size);
3469 #endif
3470         }
3471
3472         unmap_pe_file (file_map, map_handle);
3473
3474         return(ret);
3475 }
3476
3477 gboolean
3478 mono_w32process_ver_query_value (gconstpointer datablock, const gunichar2 *subblock, gpointer *buffer, guint32 *len)
3479 {
3480         gchar *subblock_utf8, *lang_utf8 = NULL;
3481         gboolean ret = FALSE;
3482         version_data block;
3483         gconstpointer data_ptr;
3484         gint32 data_len; /* signed to guard against underflow */
3485         gboolean want_var = FALSE;
3486         gboolean want_string = FALSE;
3487         gunichar2 lang[8];
3488         const gunichar2 *string_key = NULL;
3489         gpointer string_value = NULL;
3490         guint32 string_value_len = 0;
3491         gchar *lowercase_lang;
3492
3493         subblock_utf8 = g_utf16_to_utf8 (subblock, -1, NULL, NULL, NULL);
3494         if (subblock_utf8 == NULL) {
3495                 return(FALSE);
3496         }
3497
3498         if (!strcmp (subblock_utf8, "\\VarFileInfo\\Translation")) {
3499                 want_var = TRUE;
3500         } else if (!strncmp (subblock_utf8, "\\StringFileInfo\\", 16)) {
3501                 want_string = TRUE;
3502                 memcpy (lang, subblock + 16, 8 * sizeof(gunichar2));
3503                 lang_utf8 = g_utf16_to_utf8 (lang, 8, NULL, NULL, NULL);
3504                 lowercase_lang = g_utf8_strdown (lang_utf8, -1);
3505                 g_free (lang_utf8);
3506                 lang_utf8 = lowercase_lang;
3507                 lowercase_lang = NULL;
3508                 string_key = subblock + 25;
3509         }
3510
3511         if (!strcmp (subblock_utf8, "\\")) {
3512                 data_ptr = get_fixedfileinfo_block (datablock, &block);
3513                 if (data_ptr != NULL) {
3514                         *buffer = (gpointer)data_ptr;
3515                         *len = block.value_len;
3516
3517                         ret = TRUE;
3518                 }
3519         } else if (want_var || want_string) {
3520                 data_ptr = get_fixedfileinfo_block (datablock, &block);
3521                 if (data_ptr != NULL) {
3522                         /* The FFI and header occupies the first 92
3523                          * bytes
3524                          */
3525                         data_ptr = (char *)data_ptr + sizeof(VS_FIXEDFILEINFO);
3526                         data_len = block.data_len - 92;
3527
3528                         /* There now follow zero or one StringFileInfo
3529                          * blocks and zero or one VarFileInfo blocks
3530                          */
3531                         while (data_len > 0) {
3532                                 /* align on a 32-bit boundary */
3533                                 ALIGN32 (data_ptr);
3534
3535                                 data_ptr = get_versioninfo_block (data_ptr,
3536                                                                   &block);
3537                                 if (block.data_len == 0) {
3538                                         /* We must have hit padding,
3539                                          * so give up processing now
3540                                          */
3541                                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Hit 0-length block, giving up", __func__);
3542                                         goto done;
3543                                 }
3544
3545                                 data_len = data_len - block.data_len;
3546
3547                                 if (unicode_string_equals (block.key, "VarFileInfo")) {
3548                                         data_ptr = get_varfileinfo_block (data_ptr, &block);
3549                                         if (want_var) {
3550                                                 *buffer = (gpointer)data_ptr;
3551                                                 *len = block.value_len;
3552                                                 ret = TRUE;
3553                                                 goto done;
3554                                         } else {
3555                                                 /* Skip over the Var block */
3556                                                 data_ptr = ((guchar *)data_ptr) + block.value_len;
3557                                         }
3558                                 } else if (unicode_string_equals (block.key, "StringFileInfo")) {
3559                                         data_ptr = get_stringtable_block (data_ptr, lang_utf8, string_key, &string_value, &string_value_len, &block);
3560                                         if (want_string &&
3561                                             string_value != NULL &&
3562                                             string_value_len != 0) {
3563                                                 *buffer = string_value;
3564                                                 *len = unicode_chars ((const gunichar2 *)string_value) + 1; /* Include trailing null */
3565                                                 ret = TRUE;
3566                                                 goto done;
3567                                         }
3568                                 } else {
3569                                         /* Bogus data */
3570                                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Not a valid VERSIONINFO child block", __func__);
3571                                         goto done;
3572                                 }
3573
3574                                 if (data_ptr == NULL) {
3575                                         /* Child block hit padding */
3576                                         mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Child block hit 0-length block, giving up", __func__);
3577                                         goto done;
3578                                 }
3579                         }
3580                 }
3581         }
3582
3583   done:
3584         if (lang_utf8) {
3585                 g_free (lang_utf8);
3586         }
3587
3588         g_free (subblock_utf8);
3589         return(ret);
3590 }
3591
3592 static guint32
3593 copy_lang (gunichar2 *lang_out, guint32 lang_len, const gchar *text)
3594 {
3595         gunichar2 *unitext;
3596         int chars = strlen (text);
3597         int ret;
3598
3599         unitext = g_utf8_to_utf16 (text, -1, NULL, NULL, NULL);
3600         g_assert (unitext != NULL);
3601
3602         if (chars < (lang_len - 1)) {
3603                 memcpy (lang_out, (gpointer)unitext, chars * 2);
3604                 lang_out[chars] = '\0';
3605                 ret = chars;
3606         } else {
3607                 memcpy (lang_out, (gpointer)unitext, (lang_len - 1) * 2);
3608                 lang_out[lang_len] = '\0';
3609                 ret = lang_len;
3610         }
3611
3612         g_free (unitext);
3613
3614         return(ret);
3615 }
3616
3617 guint32
3618 mono_w32process_ver_language_name (guint32 lang, gunichar2 *lang_out, guint32 lang_len)
3619 {
3620         int primary, secondary;
3621         const char *name = NULL;
3622
3623         primary = lang & 0x3FF;
3624         secondary = (lang >> 10) & 0x3F;
3625
3626         switch(primary) {
3627         case 0x00:
3628                 switch (secondary) {
3629                 case 0x01: name = "Process Default Language"; break;
3630                 }
3631                 break;
3632         case 0x01:
3633                 switch (secondary) {
3634                 case 0x00:
3635                 case 0x01: name = "Arabic (Saudi Arabia)"; break;
3636                 case 0x02: name = "Arabic (Iraq)"; break;
3637                 case 0x03: name = "Arabic (Egypt)"; break;
3638                 case 0x04: name = "Arabic (Libya)"; break;
3639                 case 0x05: name = "Arabic (Algeria)"; break;
3640                 case 0x06: name = "Arabic (Morocco)"; break;
3641                 case 0x07: name = "Arabic (Tunisia)"; break;
3642                 case 0x08: name = "Arabic (Oman)"; break;
3643                 case 0x09: name = "Arabic (Yemen)"; break;
3644                 case 0x0a: name = "Arabic (Syria)"; break;
3645                 case 0x0b: name = "Arabic (Jordan)"; break;
3646                 case 0x0c: name = "Arabic (Lebanon)"; break;
3647                 case 0x0d: name = "Arabic (Kuwait)"; break;
3648                 case 0x0e: name = "Arabic (U.A.E.)"; break;
3649                 case 0x0f: name = "Arabic (Bahrain)"; break;
3650                 case 0x10: name = "Arabic (Qatar)"; break;
3651                 }
3652                 break;
3653         case 0x02:
3654                 switch (secondary) {
3655                 case 0x00: name = "Bulgarian (Bulgaria)"; break;
3656                 case 0x01: name = "Bulgarian"; break;
3657                 }
3658                 break;
3659         case 0x03:
3660                 switch (secondary) {
3661                 case 0x00: name = "Catalan (Spain)"; break;
3662                 case 0x01: name = "Catalan"; break;
3663                 }
3664                 break;
3665         case 0x04:
3666                 switch (secondary) {
3667                 case 0x00:
3668                 case 0x01: name = "Chinese (Taiwan)"; break;
3669                 case 0x02: name = "Chinese (PRC)"; break;
3670                 case 0x03: name = "Chinese (Hong Kong S.A.R.)"; break;
3671                 case 0x04: name = "Chinese (Singapore)"; break;
3672                 case 0x05: name = "Chinese (Macau S.A.R.)"; break;
3673                 }
3674                 break;
3675         case 0x05:
3676                 switch (secondary) {
3677                 case 0x00: name = "Czech (Czech Republic)"; break;
3678                 case 0x01: name = "Czech"; break;
3679                 }
3680                 break;
3681         case 0x06:
3682                 switch (secondary) {
3683                 case 0x00: name = "Danish (Denmark)"; break;
3684                 case 0x01: name = "Danish"; break;
3685                 }
3686                 break;
3687         case 0x07:
3688                 switch (secondary) {
3689                 case 0x00:
3690                 case 0x01: name = "German (Germany)"; break;
3691                 case 0x02: name = "German (Switzerland)"; break;
3692                 case 0x03: name = "German (Austria)"; break;
3693                 case 0x04: name = "German (Luxembourg)"; break;
3694                 case 0x05: name = "German (Liechtenstein)"; break;
3695                 }
3696                 break;
3697         case 0x08:
3698                 switch (secondary) {
3699                 case 0x00: name = "Greek (Greece)"; break;
3700                 case 0x01: name = "Greek"; break;
3701                 }
3702                 break;
3703         case 0x09:
3704                 switch (secondary) {
3705                 case 0x00:
3706                 case 0x01: name = "English (United States)"; break;
3707                 case 0x02: name = "English (United Kingdom)"; break;
3708                 case 0x03: name = "English (Australia)"; break;
3709                 case 0x04: name = "English (Canada)"; break;
3710                 case 0x05: name = "English (New Zealand)"; break;
3711                 case 0x06: name = "English (Ireland)"; break;
3712                 case 0x07: name = "English (South Africa)"; break;
3713                 case 0x08: name = "English (Jamaica)"; break;
3714                 case 0x09: name = "English (Caribbean)"; break;
3715                 case 0x0a: name = "English (Belize)"; break;
3716                 case 0x0b: name = "English (Trinidad and Tobago)"; break;
3717                 case 0x0c: name = "English (Zimbabwe)"; break;
3718                 case 0x0d: name = "English (Philippines)"; break;
3719                 case 0x10: name = "English (India)"; break;
3720                 case 0x11: name = "English (Malaysia)"; break;
3721                 case 0x12: name = "English (Singapore)"; break;
3722                 }
3723                 break;
3724         case 0x0a:
3725                 switch (secondary) {
3726                 case 0x00: name = "Spanish (Spain)"; break;
3727                 case 0x01: name = "Spanish (Traditional Sort)"; break;
3728                 case 0x02: name = "Spanish (Mexico)"; break;
3729                 case 0x03: name = "Spanish (International Sort)"; break;
3730                 case 0x04: name = "Spanish (Guatemala)"; break;
3731                 case 0x05: name = "Spanish (Costa Rica)"; break;
3732                 case 0x06: name = "Spanish (Panama)"; break;
3733                 case 0x07: name = "Spanish (Dominican Republic)"; break;
3734                 case 0x08: name = "Spanish (Venezuela)"; break;
3735                 case 0x09: name = "Spanish (Colombia)"; break;
3736                 case 0x0a: name = "Spanish (Peru)"; break;
3737                 case 0x0b: name = "Spanish (Argentina)"; break;
3738                 case 0x0c: name = "Spanish (Ecuador)"; break;
3739                 case 0x0d: name = "Spanish (Chile)"; break;
3740                 case 0x0e: name = "Spanish (Uruguay)"; break;
3741                 case 0x0f: name = "Spanish (Paraguay)"; break;
3742                 case 0x10: name = "Spanish (Bolivia)"; break;
3743                 case 0x11: name = "Spanish (El Salvador)"; break;
3744                 case 0x12: name = "Spanish (Honduras)"; break;
3745                 case 0x13: name = "Spanish (Nicaragua)"; break;
3746                 case 0x14: name = "Spanish (Puerto Rico)"; break;
3747                 case 0x15: name = "Spanish (United States)"; break;
3748                 }
3749                 break;
3750         case 0x0b:
3751                 switch (secondary) {
3752                 case 0x00: name = "Finnish (Finland)"; break;
3753                 case 0x01: name = "Finnish"; break;
3754                 }
3755                 break;
3756         case 0x0c:
3757                 switch (secondary) {
3758                 case 0x00:
3759                 case 0x01: name = "French (France)"; break;
3760                 case 0x02: name = "French (Belgium)"; break;
3761                 case 0x03: name = "French (Canada)"; break;
3762                 case 0x04: name = "French (Switzerland)"; break;
3763                 case 0x05: name = "French (Luxembourg)"; break;
3764                 case 0x06: name = "French (Monaco)"; break;
3765                 }
3766                 break;
3767         case 0x0d:
3768                 switch (secondary) {
3769                 case 0x00: name = "Hebrew (Israel)"; break;
3770                 case 0x01: name = "Hebrew"; break;
3771                 }
3772                 break;
3773         case 0x0e:
3774                 switch (secondary) {
3775                 case 0x00: name = "Hungarian (Hungary)"; break;
3776                 case 0x01: name = "Hungarian"; break;
3777                 }
3778                 break;
3779         case 0x0f:
3780                 switch (secondary) {
3781                 case 0x00: name = "Icelandic (Iceland)"; break;
3782                 case 0x01: name = "Icelandic"; break;
3783                 }
3784                 break;
3785         case 0x10:
3786                 switch (secondary) {
3787                 case 0x00:
3788                 case 0x01: name = "Italian (Italy)"; break;
3789                 case 0x02: name = "Italian (Switzerland)"; break;
3790                 }
3791                 break;
3792         case 0x11:
3793                 switch (secondary) {
3794                 case 0x00: name = "Japanese (Japan)"; break;
3795                 case 0x01: name = "Japanese"; break;
3796                 }
3797                 break;
3798         case 0x12:
3799                 switch (secondary) {
3800                 case 0x00: name = "Korean (Korea)"; break;
3801                 case 0x01: name = "Korean"; break;
3802                 }
3803                 break;
3804         case 0x13:
3805                 switch (secondary) {
3806                 case 0x00:
3807                 case 0x01: name = "Dutch (Netherlands)"; break;
3808                 case 0x02: name = "Dutch (Belgium)"; break;
3809                 }
3810                 break;
3811         case 0x14:
3812                 switch (secondary) {
3813                 case 0x00:
3814                 case 0x01: name = "Norwegian (Bokmal)"; break;
3815                 case 0x02: name = "Norwegian (Nynorsk)"; break;
3816                 }
3817                 break;
3818         case 0x15:
3819                 switch (secondary) {
3820                 case 0x00: name = "Polish (Poland)"; break;
3821                 case 0x01: name = "Polish"; break;
3822                 }
3823                 break;
3824         case 0x16:
3825                 switch (secondary) {
3826                 case 0x00:
3827                 case 0x01: name = "Portuguese (Brazil)"; break;
3828                 case 0x02: name = "Portuguese (Portugal)"; break;
3829                 }
3830                 break;
3831         case 0x17:
3832                 switch (secondary) {
3833                 case 0x01: name = "Romansh (Switzerland)"; break;
3834                 }
3835                 break;
3836         case 0x18:
3837                 switch (secondary) {
3838                 case 0x00: name = "Romanian (Romania)"; break;
3839                 case 0x01: name = "Romanian"; break;
3840                 }
3841                 break;
3842         case 0x19:
3843                 switch (secondary) {
3844                 case 0x00: name = "Russian (Russia)"; break;
3845                 case 0x01: name = "Russian"; break;
3846                 }
3847                 break;
3848         case 0x1a:
3849                 switch (secondary) {
3850                 case 0x00: name = "Croatian (Croatia)"; break;
3851                 case 0x01: name = "Croatian"; break;
3852                 case 0x02: name = "Serbian (Latin)"; break;
3853                 case 0x03: name = "Serbian (Cyrillic)"; break;
3854                 case 0x04: name = "Croatian (Bosnia and Herzegovina)"; break;
3855                 case 0x05: name = "Bosnian (Latin, Bosnia and Herzegovina)"; break;
3856                 case 0x06: name = "Serbian (Latin, Bosnia and Herzegovina)"; break;
3857                 case 0x07: name = "Serbian (Cyrillic, Bosnia and Herzegovina)"; break;
3858                 case 0x08: name = "Bosnian (Cyrillic, Bosnia and Herzegovina)"; break;
3859                 }
3860                 break;
3861         case 0x1b:
3862                 switch (secondary) {
3863                 case 0x00: name = "Slovak (Slovakia)"; break;
3864                 case 0x01: name = "Slovak"; break;
3865                 }
3866                 break;
3867         case 0x1c:
3868                 switch (secondary) {
3869                 case 0x00: name = "Albanian (Albania)"; break;
3870                 case 0x01: name = "Albanian"; break;
3871                 }
3872                 break;
3873         case 0x1d:
3874                 switch (secondary) {
3875                 case 0x00: name = "Swedish (Sweden)"; break;
3876                 case 0x01: name = "Swedish"; break;
3877                 case 0x02: name = "Swedish (Finland)"; break;
3878                 }
3879                 break;
3880         case 0x1e:
3881                 switch (secondary) {
3882                 case 0x00: name = "Thai (Thailand)"; break;
3883                 case 0x01: name = "Thai"; break;
3884                 }
3885                 break;
3886         case 0x1f:
3887                 switch (secondary) {
3888                 case 0x00: name = "Turkish (Turkey)"; break;
3889                 case 0x01: name = "Turkish"; break;
3890                 }
3891                 break;
3892         case 0x20:
3893                 switch (secondary) {
3894                 case 0x00: name = "Urdu (Islamic Republic of Pakistan)"; break;
3895                 case 0x01: name = "Urdu"; break;
3896                 }
3897                 break;
3898         case 0x21:
3899                 switch (secondary) {
3900                 case 0x00: name = "Indonesian (Indonesia)"; break;
3901                 case 0x01: name = "Indonesian"; break;
3902                 }
3903                 break;
3904         case 0x22:
3905                 switch (secondary) {
3906                 case 0x00: name = "Ukrainian (Ukraine)"; break;
3907                 case 0x01: name = "Ukrainian"; break;
3908                 }
3909                 break;
3910         case 0x23:
3911                 switch (secondary) {
3912                 case 0x00: name = "Belarusian (Belarus)"; break;
3913                 case 0x01: name = "Belarusian"; break;
3914                 }
3915                 break;
3916         case 0x24:
3917                 switch (secondary) {
3918                 case 0x00: name = "Slovenian (Slovenia)"; break;
3919                 case 0x01: name = "Slovenian"; break;
3920                 }
3921                 break;
3922         case 0x25:
3923                 switch (secondary) {
3924                 case 0x00: name = "Estonian (Estonia)"; break;
3925                 case 0x01: name = "Estonian"; break;
3926                 }
3927                 break;
3928         case 0x26:
3929                 switch (secondary) {
3930                 case 0x00: name = "Latvian (Latvia)"; break;
3931                 case 0x01: name = "Latvian"; break;
3932                 }
3933                 break;
3934         case 0x27:
3935                 switch (secondary) {
3936                 case 0x00: name = "Lithuanian (Lithuania)"; break;
3937                 case 0x01: name = "Lithuanian"; break;
3938                 }
3939                 break;
3940         case 0x28:
3941                 switch (secondary) {
3942                 case 0x01: name = "Tajik (Tajikistan)"; break;
3943                 }
3944                 break;
3945         case 0x29:
3946                 switch (secondary) {
3947                 case 0x00: name = "Farsi (Iran)"; break;
3948                 case 0x01: name = "Farsi"; break;
3949                 }
3950                 break;
3951         case 0x2a:
3952                 switch (secondary) {
3953                 case 0x00: name = "Vietnamese (Viet Nam)"; break;
3954                 case 0x01: name = "Vietnamese"; break;
3955                 }
3956                 break;
3957         case 0x2b:
3958                 switch (secondary) {
3959                 case 0x00: name = "Armenian (Armenia)"; break;
3960                 case 0x01: name = "Armenian"; break;
3961                 }
3962                 break;
3963         case 0x2c:
3964                 switch (secondary) {
3965                 case 0x00: name = "Azeri (Latin) (Azerbaijan)"; break;
3966                 case 0x01: name = "Azeri (Latin)"; break;
3967                 case 0x02: name = "Azeri (Cyrillic)"; break;
3968                 }
3969                 break;
3970         case 0x2d:
3971                 switch (secondary) {
3972                 case 0x00: name = "Basque (Spain)"; break;
3973                 case 0x01: name = "Basque"; break;
3974                 }
3975                 break;
3976         case 0x2e:
3977                 switch (secondary) {
3978                 case 0x01: name = "Upper Sorbian (Germany)"; break;
3979                 case 0x02: name = "Lower Sorbian (Germany)"; break;
3980                 }
3981                 break;
3982         case 0x2f:
3983                 switch (secondary) {
3984                 case 0x00: name = "FYRO Macedonian (Former Yugoslav Republic of Macedonia)"; break;
3985                 case 0x01: name = "FYRO Macedonian"; break;
3986                 }
3987                 break;
3988         case 0x32:
3989                 switch (secondary) {
3990                 case 0x00: name = "Tswana (South Africa)"; break;
3991                 case 0x01: name = "Tswana"; break;
3992                 }
3993                 break;
3994         case 0x34:
3995                 switch (secondary) {
3996                 case 0x00: name = "Xhosa (South Africa)"; break;
3997                 case 0x01: name = "Xhosa"; break;
3998                 }
3999                 break;
4000         case 0x35:
4001                 switch (secondary) {
4002                 case 0x00: name = "Zulu (South Africa)"; break;
4003                 case 0x01: name = "Zulu"; break;
4004                 }
4005                 break;
4006         case 0x36:
4007                 switch (secondary) {
4008                 case 0x00: name = "Afrikaans (South Africa)"; break;
4009                 case 0x01: name = "Afrikaans"; break;
4010                 }
4011                 break;
4012         case 0x37:
4013                 switch (secondary) {
4014                 case 0x00: name = "Georgian (Georgia)"; break;
4015                 case 0x01: name = "Georgian"; break;
4016                 }
4017                 break;
4018         case 0x38:
4019                 switch (secondary) {
4020                 case 0x00: name = "Faroese (Faroe Islands)"; break;
4021                 case 0x01: name = "Faroese"; break;
4022                 }
4023                 break;
4024         case 0x39:
4025                 switch (secondary) {
4026                 case 0x00: name = "Hindi (India)"; break;
4027                 case 0x01: name = "Hindi"; break;
4028                 }
4029                 break;
4030         case 0x3a:
4031                 switch (secondary) {
4032                 case 0x00: name = "Maltese (Malta)"; break;
4033                 case 0x01: name = "Maltese"; break;
4034                 }
4035                 break;
4036         case 0x3b:
4037                 switch (secondary) {
4038                 case 0x00: name = "Sami (Northern) (Norway)"; break;
4039                 case 0x01: name = "Sami, Northern (Norway)"; break;
4040                 case 0x02: name = "Sami, Northern (Sweden)"; break;
4041                 case 0x03: name = "Sami, Northern (Finland)"; break;
4042                 case 0x04: name = "Sami, Lule (Norway)"; break;
4043                 case 0x05: name = "Sami, Lule (Sweden)"; break;
4044                 case 0x06: name = "Sami, Southern (Norway)"; break;
4045                 case 0x07: name = "Sami, Southern (Sweden)"; break;
4046                 case 0x08: name = "Sami, Skolt (Finland)"; break;
4047                 case 0x09: name = "Sami, Inari (Finland)"; break;
4048                 }
4049                 break;
4050         case 0x3c:
4051                 switch (secondary) {
4052                 case 0x02: name = "Irish (Ireland)"; break;
4053                 }
4054                 break;
4055         case 0x3e:
4056                 switch (secondary) {
4057                 case 0x00:
4058                 case 0x01: name = "Malay (Malaysia)"; break;
4059                 case 0x02: name = "Malay (Brunei Darussalam)"; break;
4060                 }
4061                 break;
4062         case 0x3f:
4063                 switch (secondary) {
4064                 case 0x00: name = "Kazakh (Kazakhstan)"; break;
4065                 case 0x01: name = "Kazakh"; break;
4066                 }
4067                 break;
4068         case 0x40:
4069                 switch (secondary) {
4070                 case 0x00: name = "Kyrgyz (Kyrgyzstan)"; break;
4071                 case 0x01: name = "Kyrgyz (Cyrillic)"; break;
4072                 }
4073                 break;
4074         case 0x41:
4075                 switch (secondary) {
4076                 case 0x00: name = "Swahili (Kenya)"; break;
4077                 case 0x01: name = "Swahili"; break;
4078                 }
4079                 break;
4080         case 0x42:
4081                 switch (secondary) {
4082                 case 0x01: name = "Turkmen (Turkmenistan)"; break;
4083                 }
4084                 break;
4085         case 0x43:
4086                 switch (secondary) {
4087                 case 0x00: name = "Uzbek (Latin) (Uzbekistan)"; break;
4088                 case 0x01: name = "Uzbek (Latin)"; break;
4089                 case 0x02: name = "Uzbek (Cyrillic)"; break;
4090                 }
4091                 break;
4092         case 0x44:
4093                 switch (secondary) {
4094                 case 0x00: name = "Tatar (Russia)"; break;
4095                 case 0x01: name = "Tatar"; break;
4096                 }
4097                 break;
4098         case 0x45:
4099                 switch (secondary) {
4100                 case 0x00:
4101                 case 0x01: name = "Bengali (India)"; break;
4102                 }
4103                 break;
4104         case 0x46:
4105                 switch (secondary) {
4106                 case 0x00: name = "Punjabi (India)"; break;
4107                 case 0x01: name = "Punjabi"; break;
4108                 }
4109                 break;
4110         case 0x47:
4111                 switch (secondary) {
4112                 case 0x00: name = "Gujarati (India)"; break;
4113                 case 0x01: name = "Gujarati"; break;
4114                 }
4115                 break;
4116         case 0x49:
4117                 switch (secondary) {
4118                 case 0x00: name = "Tamil (India)"; break;
4119                 case 0x01: name = "Tamil"; break;
4120                 }
4121                 break;
4122         case 0x4a:
4123                 switch (secondary) {
4124                 case 0x00: name = "Telugu (India)"; break;
4125                 case 0x01: name = "Telugu"; break;
4126                 }
4127                 break;
4128         case 0x4b:
4129                 switch (secondary) {
4130                 case 0x00: name = "Kannada (India)"; break;
4131                 case 0x01: name = "Kannada"; break;
4132                 }
4133                 break;
4134         case 0x4c:
4135                 switch (secondary) {
4136                 case 0x00:
4137                 case 0x01: name = "Malayalam (India)"; break;
4138                 }
4139                 break;
4140         case 0x4d:
4141                 switch (secondary) {
4142                 case 0x01: name = "Assamese (India)"; break;
4143                 }
4144                 break;
4145         case 0x4e:
4146                 switch (secondary) {
4147                 case 0x00: name = "Marathi (India)"; break;
4148                 case 0x01: name = "Marathi"; break;
4149                 }
4150                 break;
4151         case 0x4f:
4152                 switch (secondary) {
4153                 case 0x00: name = "Sanskrit (India)"; break;
4154                 case 0x01: name = "Sanskrit"; break;
4155                 }
4156                 break;
4157         case 0x50:
4158                 switch (secondary) {
4159                 case 0x00: name = "Mongolian (Mongolia)"; break;
4160                 case 0x01: name = "Mongolian (Cyrillic)"; break;
4161                 case 0x02: name = "Mongolian (PRC)"; break;
4162                 }
4163                 break;
4164         case 0x51:
4165                 switch (secondary) {
4166                 case 0x01: name = "Tibetan (PRC)"; break;
4167                 case 0x02: name = "Tibetan (Bhutan)"; break;
4168                 }
4169                 break;
4170         case 0x52:
4171                 switch (secondary) {
4172                 case 0x00: name = "Welsh (United Kingdom)"; break;
4173                 case 0x01: name = "Welsh"; break;
4174                 }
4175                 break;
4176         case 0x53:
4177                 switch (secondary) {
4178                 case 0x01: name = "Khmer (Cambodia)"; break;
4179                 }
4180                 break;
4181         case 0x54:
4182                 switch (secondary) {
4183                 case 0x01: name = "Lao (Lao PDR)"; break;
4184                 }
4185                 break;
4186         case 0x56:
4187                 switch (secondary) {
4188                 case 0x00: name = "Galician (Spain)"; break;
4189                 case 0x01: name = "Galician"; break;
4190                 }
4191                 break;
4192         case 0x57:
4193                 switch (secondary) {
4194                 case 0x00: name = "Konkani (India)"; break;
4195                 case 0x01: name = "Konkani"; break;
4196                 }
4197                 break;
4198         case 0x5a:
4199                 switch (secondary) {
4200                 case 0x00: name = "Syriac (Syria)"; break;
4201                 case 0x01: name = "Syriac"; break;
4202                 }
4203                 break;
4204         case 0x5b:
4205                 switch (secondary) {
4206                 case 0x01: name = "Sinhala (Sri Lanka)"; break;
4207                 }
4208                 break;
4209         case 0x5d:
4210                 switch (secondary) {
4211                 case 0x01: name = "Inuktitut (Syllabics, Canada)"; break;
4212                 case 0x02: name = "Inuktitut (Latin, Canada)"; break;
4213                 }
4214                 break;
4215         case 0x5e:
4216                 switch (secondary) {
4217                 case 0x01: name = "Amharic (Ethiopia)"; break;
4218                 }
4219                 break;
4220         case 0x5f:
4221                 switch (secondary) {
4222                 case 0x02: name = "Tamazight (Algeria, Latin)"; break;
4223                 }
4224                 break;
4225         case 0x61:
4226                 switch (secondary) {
4227                 case 0x01: name = "Nepali (Nepal)"; break;
4228                 }
4229                 break;
4230         case 0x62:
4231                 switch (secondary) {
4232                 case 0x01: name = "Frisian (Netherlands)"; break;
4233                 }
4234                 break;
4235         case 0x63:
4236                 switch (secondary) {
4237                 case 0x01: name = "Pashto (Afghanistan)"; break;
4238                 }
4239                 break;
4240         case 0x64:
4241                 switch (secondary) {
4242                 case 0x01: name = "Filipino (Philippines)"; break;
4243                 }
4244                 break;
4245         case 0x65:
4246                 switch (secondary) {
4247                 case 0x00: name = "Divehi (Maldives)"; break;
4248                 case 0x01: name = "Divehi"; break;
4249                 }
4250                 break;
4251         case 0x68:
4252                 switch (secondary) {
4253                 case 0x01: name = "Hausa (Nigeria, Latin)"; break;
4254                 }
4255                 break;
4256         case 0x6a:
4257                 switch (secondary) {
4258                 case 0x01: name = "Yoruba (Nigeria)"; break;
4259                 }
4260                 break;
4261         case 0x6b:
4262                 switch (secondary) {
4263                 case 0x00:
4264                 case 0x01: name = "Quechua (Bolivia)"; break;
4265                 case 0x02: name = "Quechua (Ecuador)"; break;
4266                 case 0x03: name = "Quechua (Peru)"; break;
4267                 }
4268                 break;
4269         case 0x6c:
4270                 switch (secondary) {
4271                 case 0x00: name = "Northern Sotho (South Africa)"; break;
4272                 case 0x01: name = "Northern Sotho"; break;
4273                 }
4274                 break;
4275         case 0x6d:
4276                 switch (secondary) {
4277                 case 0x01: name = "Bashkir (Russia)"; break;
4278                 }
4279                 break;
4280         case 0x6e:
4281                 switch (secondary) {
4282                 case 0x01: name = "Luxembourgish (Luxembourg)"; break;
4283                 }
4284                 break;
4285         case 0x6f:
4286                 switch (secondary) {
4287                 case 0x01: name = "Greenlandic (Greenland)"; break;
4288                 }
4289                 break;
4290         case 0x78:
4291                 switch (secondary) {
4292                 case 0x01: name = "Yi (PRC)"; break;
4293                 }
4294                 break;
4295         case 0x7a:
4296                 switch (secondary) {
4297                 case 0x01: name = "Mapudungun (Chile)"; break;
4298                 }
4299                 break;
4300         case 0x7c:
4301                 switch (secondary) {
4302                 case 0x01: name = "Mohawk (Mohawk)"; break;
4303                 }
4304                 break;
4305         case 0x7e:
4306                 switch (secondary) {
4307                 case 0x01: name = "Breton (France)"; break;
4308                 }
4309                 break;
4310         case 0x7f:
4311                 switch (secondary) {
4312                 case 0x00: name = "Invariant Language (Invariant Country)"; break;
4313                 }
4314                 break;
4315         case 0x80:
4316                 switch (secondary) {
4317                 case 0x01: name = "Uighur (PRC)"; break;
4318                 }
4319                 break;
4320         case 0x81:
4321                 switch (secondary) {
4322                 case 0x00: name = "Maori (New Zealand)"; break;
4323                 case 0x01: name = "Maori"; break;
4324                 }
4325                 break;
4326         case 0x83:
4327                 switch (secondary) {
4328                 case 0x01: name = "Corsican (France)"; break;
4329                 }
4330                 break;
4331         case 0x84:
4332                 switch (secondary) {
4333                 case 0x01: name = "Alsatian (France)"; break;
4334                 }
4335                 break;
4336         case 0x85:
4337                 switch (secondary) {
4338                 case 0x01: name = "Yakut (Russia)"; break;
4339                 }
4340                 break;
4341         case 0x86:
4342                 switch (secondary) {
4343                 case 0x01: name = "K'iche (Guatemala)"; break;
4344                 }
4345                 break;
4346         case 0x87:
4347                 switch (secondary) {
4348                 case 0x01: name = "Kinyarwanda (Rwanda)"; break;
4349                 }
4350                 break;
4351         case 0x88:
4352                 switch (secondary) {
4353                 case 0x01: name = "Wolof (Senegal)"; break;
4354                 }
4355                 break;
4356         case 0x8c:
4357                 switch (secondary) {
4358                 case 0x01: name = "Dari (Afghanistan)"; break;
4359                 }
4360                 break;
4361
4362         default:
4363                 name = "Language Neutral";
4364
4365         }
4366
4367         if (!name)
4368                 name = "Language Neutral";
4369
4370         return copy_lang (lang_out, lang_len, name);
4371 }