?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[runtime] Improve tracing of process name lookup functions.
[mono-project.git] / mono / metadata / w32process-unix.c
blob8f1cc374c26b88e065dbe5318fde1089d7e0bdcf
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, %u)", __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, %u): 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, %u): 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, %u): 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, %u): 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, %u): 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, %u): 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, %u): waiting on semaphore for %li ms...",
667 __func__, handle, timeout, (long)(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, %u): 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, %u): 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, %u): 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, %u): 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, %u): 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, %u): 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 %d", __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 %d 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 %d 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 %d",
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) {
1219 g_free (pname);
1220 return 0;
1221 }
1222
1223 /* If module != NULL compare the address.
1224 * If module == NULL we are looking for the main module.
1225 * The best we can do for now check it the module name end with the process name.
1226 */
1227 for (mods_iter = mods; mods_iter; mods_iter = g_slist_next (mods_iter)) {
1228 found_module = (MonoW32ProcessModule *)mods_iter->data;
1229 if (procname_ext == NULL &&
1230 ((module == NULL && match_procname_to_modulename (pname, found_module->filename)) ||
1231 (module != NULL && found_module->address_start == module))) {
1232 procname_ext = g_path_get_basename (found_module->filename);
1233 }
1234
1235 mono_w32process_module_free (found_module);
1236 }
1237
1238 if (procname_ext == NULL) {
1239 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Can't find procname_ext from procmods %p", __func__, process);
1240 /* If it's *still* null, we might have hit the
1241 * case where reading /proc/$pid/maps gives an
1242 * empty file for this user.
1243 */
1244 procname_ext = mono_w32process_get_name (pid);
1245 if (!procname_ext)
1246 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);
1247 }
1248
1249 g_slist_free (mods);
1250 g_free (pname);
1251
1252 if (procname_ext) {
1253 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Process name is [%s]", __func__,
1254 procname_ext);
1255
1256 procname = mono_unicode_from_external (procname_ext, &bytes);
1257 if (procname == NULL) {
1258 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Can't get procname %p", __func__, process);
1259 /* bugger */
1260 g_free (procname_ext);
1261 return 0;
1262 }
1263
1264 len = (bytes / 2);
1265
1266 /* Add the terminator */
1267 bytes += 2;
1268
1269 if (size < bytes) {
1270 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Size %d smaller than needed (%zd); truncating", __func__, size, bytes);
1271
1272 memcpy (basename, procname, size);
1273 } else {
1274 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Size %d larger than needed (%zd)",
1275 __func__, size, bytes);
1276
1277 memcpy (basename, procname, bytes);
1278 }
1279
1280 g_free (procname);
1281 g_free (procname_ext);
1282
1283 return len;
1284 }
1285
1286 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Can't find procname_ext %p", __func__, process);
1287 return 0;
1288 }
1289
1290 gboolean
1291 mono_w32process_module_get_information (gpointer process, gpointer module, MODULEINFO *modinfo, guint32 size)
1292 {
1293 MonoW32HandleProcess *process_handle;
1294 pid_t pid;
1295 GSList *mods = NULL, *mods_iter;
1296 MonoW32ProcessModule *found_module;
1297 gboolean ret = FALSE;
1298 char *pname = NULL;
1299 gboolean res;
1300
1301 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Getting module info, process handle %p module %p",
1302 __func__, process, module);
1303
1304 if (modinfo == NULL || size < sizeof (MODULEINFO))
1305 return FALSE;
1306
1307 res = mono_w32handle_lookup (process, MONO_W32HANDLE_PROCESS, (gpointer*) &process_handle);
1308 if (!res) {
1309 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Can't find process %p", __func__, process);
1310 return FALSE;
1311 }
1312
1313 pid = process_handle->pid;
1314 pname = g_strdup (process_handle->pname);
1315
1316 mods = mono_w32process_get_modules (pid);
1317 if (!mods) {
1318 g_free (pname);
1319 return FALSE;
1320 }
1321
1322 /* If module != NULL compare the address.
1323 * If module == NULL we are looking for the main module.
1324 * The best we can do for now check it the module name end with the process name.
1325 */
1326 for (mods_iter = mods; mods_iter; mods_iter = g_slist_next (mods_iter)) {
1327 found_module = (MonoW32ProcessModule *)mods_iter->data;
1328 if (ret == FALSE &&
1329 ((module == NULL && match_procname_to_modulename (pname, found_module->filename)) ||
1330 (module != NULL && found_module->address_start == module))) {
1331 modinfo->lpBaseOfDll = found_module->address_start;
1332 modinfo->SizeOfImage = (gsize)(found_module->address_end) - (gsize)(found_module->address_start);
1333 modinfo->EntryPoint = found_module->address_offset;
1334 ret = TRUE;
1335 }
1336
1337 mono_w32process_module_free (found_module);
1338 }
1339
1340 g_slist_free (mods);
1341 g_free (pname);
1342
1343 return ret;
1344 }
1345
1346 static void
1347 switch_dir_separators (char *path)
1348 {
1349 size_t i, pathLength = strlen(path);
1350
1351 /* Turn all the slashes round the right way, except for \' */
1352 /* There are probably other characters that need to be excluded as well. */
1353 for (i = 0; i < pathLength; i++) {
1354 if (path[i] == '\\' && i < pathLength - 1 && path[i+1] != '\'' )
1355 path[i] = '/';
1356 }
1357 }
1358
1359 #if HAVE_SIGACTION
1360
1361 MONO_SIGNAL_HANDLER_FUNC (static, mono_sigchld_signal_handler, (int _dummy, siginfo_t *info, void *context))
1362 {
1363 int status;
1364 int pid;
1365 Process *process;
1366
1367 do {
1368 do {
1369 pid = waitpid (-1, &status, WNOHANG);
1370 } while (pid == -1 && errno == EINTR);
1371
1372 if (pid <= 0)
1373 break;
1374
1375 /*
1376 * This can run concurrently with the code in the rest of this module.
1377 */
1378 for (process = processes; process; process = process->next) {
1379 if (process->pid != pid)
1380 continue;
1381 if (process->signalled)
1382 continue;
1383
1384 process->signalled = TRUE;
1385 process->status = status;
1386 mono_os_sem_post (&process->exit_sem);
1387 mono_memory_barrier ();
1388 /* Mark this as freeable, the pointer becomes invalid afterwards */
1389 process->freeable = TRUE;
1390 break;
1391 }
1392 } while (1);
1393 }
1394
1395 static void
1396 process_add_sigchld_handler (void)
1397 {
1398 struct sigaction sa;
1399
1400 sa.sa_sigaction = mono_sigchld_signal_handler;
1401 sigemptyset (&sa.sa_mask);
1402 sa.sa_flags = SA_NOCLDSTOP | SA_SIGINFO;
1403 g_assert (sigaction (SIGCHLD, &sa, NULL) != -1);
1404 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "Added SIGCHLD handler");
1405 }
1406
1407 #endif
1408
1409 static gboolean
1410 is_readable_or_executable (const char *prog)
1411 {
1412 struct stat buf;
1413 int a = access (prog, R_OK);
1414 int b = access (prog, X_OK);
1415 if (a != 0 && b != 0)
1416 return FALSE;
1417 if (stat (prog, &buf))
1418 return FALSE;
1419 if (S_ISREG (buf.st_mode))
1420 return TRUE;
1421 return FALSE;
1422 }
1423
1424 static gboolean
1425 is_executable (const char *prog)
1426 {
1427 struct stat buf;
1428 if (access (prog, X_OK) != 0)
1429 return FALSE;
1430 if (stat (prog, &buf))
1431 return FALSE;
1432 if (S_ISREG (buf.st_mode))
1433 return TRUE;
1434 return FALSE;
1435 }
1436
1437 static gboolean
1438 is_managed_binary (const char *filename)
1439 {
1440 int original_errno = errno;
1441 #if defined(HAVE_LARGE_FILE_SUPPORT) && defined(O_LARGEFILE)
1442 int file = open (filename, O_RDONLY | O_LARGEFILE);
1443 #else
1444 int file = open (filename, O_RDONLY);
1445 #endif
1446 off_t new_offset;
1447 unsigned char buffer[8];
1448 off_t file_size, optional_header_offset;
1449 off_t pe_header_offset, clr_header_offset;
1450 gboolean managed = FALSE;
1451 int num_read;
1452 guint32 first_word, second_word, magic_number;
1453
1454 /* If we are unable to open the file, then we definitely
1455 * can't say that it is managed. The child mono process
1456 * probably wouldn't be able to open it anyway.
1457 */
1458 if (file < 0) {
1459 errno = original_errno;
1460 return FALSE;
1461 }
1462
1463 /* Retrieve the length of the file for future sanity checks. */
1464 file_size = lseek (file, 0, SEEK_END);
1465 lseek (file, 0, SEEK_SET);
1466
1467 /* We know we need to read a header field at offset 60. */
1468 if (file_size < 64)
1469 goto leave;
1470
1471 num_read = read (file, buffer, 2);
1472
1473 if ((num_read != 2) || (buffer[0] != 'M') || (buffer[1] != 'Z'))
1474 goto leave;
1475
1476 new_offset = lseek (file, 60, SEEK_SET);
1477
1478 if (new_offset != 60)
1479 goto leave;
1480
1481 num_read = read (file, buffer, 4);
1482
1483 if (num_read != 4)
1484 goto leave;
1485 pe_header_offset = buffer[0]
1486 | (buffer[1] << 8)
1487 | (buffer[2] << 16)
1488 | (buffer[3] << 24);
1489
1490 if (pe_header_offset + 24 > file_size)
1491 goto leave;
1492
1493 new_offset = lseek (file, pe_header_offset, SEEK_SET);
1494
1495 if (new_offset != pe_header_offset)
1496 goto leave;
1497
1498 num_read = read (file, buffer, 4);
1499
1500 if ((num_read != 4) || (buffer[0] != 'P') || (buffer[1] != 'E') || (buffer[2] != 0) || (buffer[3] != 0))
1501 goto leave;
1502
1503 /*
1504 * Verify that the header we want in the optional header data
1505 * is present in this binary.
1506 */
1507 new_offset = lseek (file, pe_header_offset + 20, SEEK_SET);
1508
1509 if (new_offset != pe_header_offset + 20)
1510 goto leave;
1511
1512 num_read = read (file, buffer, 2);
1513
1514 if ((num_read != 2) || ((buffer[0] | (buffer[1] << 8)) < 216))
1515 goto leave;
1516
1517 optional_header_offset = pe_header_offset + 24;
1518
1519 /* Read the PE magic number */
1520 new_offset = lseek (file, optional_header_offset, SEEK_SET);
1521
1522 if (new_offset != optional_header_offset)
1523 goto leave;
1524
1525 num_read = read (file, buffer, 2);
1526
1527 if (num_read != 2)
1528 goto leave;
1529
1530 magic_number = (buffer[0] | (buffer[1] << 8));
1531
1532 if (magic_number == 0x10B) // PE32
1533 clr_header_offset = 208;
1534 else if (magic_number == 0x20B) // PE32+
1535 clr_header_offset = 224;
1536 else
1537 goto leave;
1538
1539 /* Read the CLR header address and size fields. These will be
1540 * zero if the binary is not managed.
1541 */
1542 new_offset = lseek (file, optional_header_offset + clr_header_offset, SEEK_SET);
1543
1544 if (new_offset != optional_header_offset + clr_header_offset)
1545 goto leave;
1546
1547 num_read = read (file, buffer, 8);
1548
1549 /* We are not concerned with endianness, only with
1550 * whether it is zero or not.
1551 */
1552 first_word = *(guint32 *)&buffer[0];
1553 second_word = *(guint32 *)&buffer[4];
1554
1555 if ((num_read != 8) || (first_word == 0) || (second_word == 0))
1556 goto leave;
1557
1558 managed = TRUE;
1559
1560 leave:
1561 close (file);
1562 errno = original_errno;
1563 return managed;
1564 }
1565
1566 static gboolean
1567 process_create (const gunichar2 *appname, const gunichar2 *cmdline,
1568 const gunichar2 *cwd, StartupHandles *startup_handles, MonoW32ProcessInfo *process_info)
1569 {
1570 #if defined (HAVE_FORK) && defined (HAVE_EXECVE)
1571 char *cmd = NULL, *prog = NULL, *full_prog = NULL, *args = NULL, *args_after_prog = NULL;
1572 char *dir = NULL, **env_strings = NULL, **argv = NULL;
1573 guint32 i;
1574 gboolean ret = FALSE;
1575 gpointer handle = NULL;
1576 GError *gerr = NULL;
1577 int in_fd, out_fd, err_fd;
1578 pid_t pid = 0;
1579 int startup_pipe [2] = {-1, -1};
1580 int dummy;
1581 Process *process;
1582
1583 #if HAVE_SIGACTION
1584 mono_lazy_initialize (&process_sig_chld_once, process_add_sigchld_handler);
1585 #endif
1586
1587 /* appname and cmdline specify the executable and its args:
1588 *
1589 * If appname is not NULL, it is the name of the executable.
1590 * Otherwise the executable is the first token in cmdline.
1591 *
1592 * Executable searching:
1593 *
1594 * If appname is not NULL, it can specify the full path and
1595 * file name, or else a partial name and the current directory
1596 * will be used. There is no additional searching.
1597 *
1598 * If appname is NULL, the first whitespace-delimited token in
1599 * cmdline is used. If the name does not contain a full
1600 * directory path, the search sequence is:
1601 *
1602 * 1) The directory containing the current process
1603 * 2) The current working directory
1604 * 3) The windows system directory (Ignored)
1605 * 4) The windows directory (Ignored)
1606 * 5) $PATH
1607 *
1608 * Just to make things more interesting, tokens can contain
1609 * white space if they are surrounded by quotation marks. I'm
1610 * beginning to understand just why windows apps are generally
1611 * so crap, with an API like this :-(
1612 */
1613 if (appname != NULL) {
1614 cmd = mono_unicode_to_external (appname);
1615 if (cmd == NULL) {
1616 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: unicode conversion returned NULL",
1617 __func__);
1618
1619 mono_w32error_set_last (ERROR_PATH_NOT_FOUND);
1620 goto free_strings;
1621 }
1622
1623 switch_dir_separators(cmd);
1624 }
1625
1626 if (cmdline != NULL) {
1627 args = mono_unicode_to_external (cmdline);
1628 if (args == NULL) {
1629 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: unicode conversion returned NULL", __func__);
1630
1631 mono_w32error_set_last (ERROR_PATH_NOT_FOUND);
1632 goto free_strings;
1633 }
1634 }
1635
1636 if (cwd != NULL) {
1637 dir = mono_unicode_to_external (cwd);
1638 if (dir == NULL) {
1639 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: unicode conversion returned NULL", __func__);
1640
1641 mono_w32error_set_last (ERROR_PATH_NOT_FOUND);
1642 goto free_strings;
1643 }
1644
1645 /* Turn all the slashes round the right way */
1646 switch_dir_separators(dir);
1647 }
1648
1649
1650 /* We can't put off locating the executable any longer :-( */
1651 if (cmd != NULL) {
1652 char *unquoted;
1653 if (g_ascii_isalpha (cmd[0]) && (cmd[1] == ':')) {
1654 /* Strip off the drive letter. I can't
1655 * believe that CP/M holdover is still
1656 * visible...
1657 */
1658 g_memmove (cmd, cmd+2, strlen (cmd)-2);
1659 cmd[strlen (cmd)-2] = '\0';
1660 }
1661
1662 unquoted = g_shell_unquote (cmd, NULL);
1663 if (unquoted[0] == '/') {
1664 /* Assume full path given */
1665 prog = g_strdup (unquoted);
1666
1667 /* Executable existing ? */
1668 if (!is_readable_or_executable (prog)) {
1669 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Couldn't find executable %s",
1670 __func__, prog);
1671 g_free (unquoted);
1672 mono_w32error_set_last (ERROR_FILE_NOT_FOUND);
1673 goto free_strings;
1674 }
1675 } else {
1676 /* Search for file named by cmd in the current
1677 * directory
1678 */
1679 char *curdir = g_get_current_dir ();
1680
1681 prog = g_strdup_printf ("%s/%s", curdir, unquoted);
1682 g_free (curdir);
1683
1684 /* And make sure it's readable */
1685 if (!is_readable_or_executable (prog)) {
1686 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Couldn't find executable %s",
1687 __func__, prog);
1688 g_free (unquoted);
1689 mono_w32error_set_last (ERROR_FILE_NOT_FOUND);
1690 goto free_strings;
1691 }
1692 }
1693 g_free (unquoted);
1694
1695 args_after_prog = args;
1696 } else {
1697 char *token = NULL;
1698 char quote;
1699
1700 /* Dig out the first token from args, taking quotation
1701 * marks into account
1702 */
1703
1704 /* First, strip off all leading whitespace */
1705 args = g_strchug (args);
1706
1707 /* args_after_prog points to the contents of args
1708 * after token has been set (otherwise argv[0] is
1709 * duplicated)
1710 */
1711 args_after_prog = args;
1712
1713 /* Assume the opening quote will always be the first
1714 * character
1715 */
1716 if (args[0] == '\"' || args [0] == '\'') {
1717 quote = args [0];
1718 for (i = 1; args[i] != '\0' && args[i] != quote; i++);
1719 if (args [i + 1] == '\0' || g_ascii_isspace (args[i+1])) {
1720 /* We found the first token */
1721 token = g_strndup (args+1, i-1);
1722 args_after_prog = g_strchug (args + i + 1);
1723 } else {
1724 /* Quotation mark appeared in the
1725 * middle of the token. Just give the
1726 * whole first token, quotes and all,
1727 * to exec.
1728 */
1729 }
1730 }
1731
1732 if (token == NULL) {
1733 /* No quote mark, or malformed */
1734 for (i = 0; args[i] != '\0'; i++) {
1735 if (g_ascii_isspace (args[i])) {
1736 token = g_strndup (args, i);
1737 args_after_prog = args + i + 1;
1738 break;
1739 }
1740 }
1741 }
1742
1743 if (token == NULL && args[0] != '\0') {
1744 /* Must be just one token in the string */
1745 token = g_strdup (args);
1746 args_after_prog = NULL;
1747 }
1748
1749 if (token == NULL) {
1750 /* Give up */
1751 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Couldn't find what to exec", __func__);
1752
1753 mono_w32error_set_last (ERROR_PATH_NOT_FOUND);
1754 goto free_strings;
1755 }
1756
1757 /* Turn all the slashes round the right way. Only for
1758 * the prg. name
1759 */
1760 switch_dir_separators(token);
1761
1762 if (g_ascii_isalpha (token[0]) && (token[1] == ':')) {
1763 /* Strip off the drive letter. I can't
1764 * believe that CP/M holdover is still
1765 * visible...
1766 */
1767 g_memmove (token, token+2, strlen (token)-2);
1768 token[strlen (token)-2] = '\0';
1769 }
1770
1771 if (token[0] == '/') {
1772 /* Assume full path given */
1773 prog = g_strdup (token);
1774
1775 /* Executable existing ? */
1776 if (!is_readable_or_executable (prog)) {
1777 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Couldn't find executable %s",
1778 __func__, token);
1779 g_free (token);
1780 mono_w32error_set_last (ERROR_FILE_NOT_FOUND);
1781 goto free_strings;
1782 }
1783 } else {
1784 char *curdir = g_get_current_dir ();
1785
1786 /* FIXME: Need to record the directory
1787 * containing the current process, and check
1788 * that for the new executable as the first
1789 * place to look
1790 */
1791
1792 prog = g_strdup_printf ("%s/%s", curdir, token);
1793 g_free (curdir);
1794
1795 /* I assume X_OK is the criterion to use,
1796 * rather than F_OK
1797 *
1798 * X_OK is too strict *if* the target is a CLR binary
1799 */
1800 if (!is_readable_or_executable (prog)) {
1801 g_free (prog);
1802 prog = g_find_program_in_path (token);
1803 if (prog == NULL) {
1804 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Couldn't find executable %s", __func__, token);
1805
1806 g_free (token);
1807 mono_w32error_set_last (ERROR_FILE_NOT_FOUND);
1808 goto free_strings;
1809 }
1810 }
1811 }
1812
1813 g_free (token);
1814 }
1815
1816 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Exec prog [%s] args [%s]",
1817 __func__, prog, args_after_prog);
1818
1819 /* Check for CLR binaries; if found, we will try to invoke
1820 * them using the same mono binary that started us.
1821 */
1822 if (is_managed_binary (prog)) {
1823 gunichar2 *newapp, *newcmd;
1824 gsize bytes_ignored;
1825
1826 newapp = mono_unicode_from_external (cli_launcher ? cli_launcher : "mono", &bytes_ignored);
1827 if (newapp) {
1828 if (appname)
1829 newcmd = utf16_concat (utf16_quote, newapp, utf16_quote, utf16_space, appname, utf16_space, cmdline, NULL);
1830 else
1831 newcmd = utf16_concat (utf16_quote, newapp, utf16_quote, utf16_space, cmdline, NULL);
1832
1833 g_free (newapp);
1834
1835 if (newcmd) {
1836 ret = process_create (NULL, newcmd, cwd, startup_handles, process_info);
1837
1838 g_free (newcmd);
1839
1840 goto free_strings;
1841 }
1842 }
1843 } else {
1844 if (!is_executable (prog)) {
1845 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: Executable permisson not set on %s", __func__, prog);
1846 mono_w32error_set_last (ERROR_ACCESS_DENIED);
1847 goto free_strings;
1848 }
1849 }
1850
1851 if (args_after_prog != NULL && *args_after_prog) {
1852 char *qprog;
1853
1854 qprog = g_shell_quote (prog);
1855 full_prog = g_strconcat (qprog, " ", args_after_prog, NULL);
1856 g_free (qprog);
1857 } else {
1858 full_prog = g_shell_quote (prog);
1859 }
1860
1861 ret = g_shell_parse_argv (full_prog, NULL, &argv, &gerr);
1862 if (ret == FALSE) {
1863 g_message ("process_create: %s\n", gerr->message);
1864 g_error_free (gerr);
1865 gerr = NULL;
1866 goto free_strings;
1867 }
1868
1869 if (startup_handles) {
1870 in_fd = GPOINTER_TO_UINT (startup_handles->input);
1871 out_fd = GPOINTER_TO_UINT (startup_handles->output);
1872 err_fd = GPOINTER_TO_UINT (startup_handles->error);
1873 } else {
1874 in_fd = GPOINTER_TO_UINT (mono_w32file_get_console_input ());
1875 out_fd = GPOINTER_TO_UINT (mono_w32file_get_console_output ());
1876 err_fd = GPOINTER_TO_UINT (mono_w32file_get_console_error ());
1877 }
1878
1879 /*
1880 * process->env_variables is a an array of MonoString*
1881 *
1882 * If new_environ is not NULL it specifies the entire set of
1883 * environment variables in the new process. Otherwise the
1884 * new process inherits the same environment.
1885 */
1886 if (process_info->env_variables) {
1887 gint i, str_length, var_length;
1888 MonoString *var;
1889 gunichar2 *str;
1890
1891 /* +2: one for the process handle value, and the last one is NULL */
1892 env_strings = g_new0 (gchar*, mono_array_length (process_info->env_variables) + 2);
1893
1894 str = NULL;
1895 str_length = 0;
1896
1897 /* Copy each environ string into 'strings' turning it into utf8 (or the requested encoding) at the same time */
1898 for (i = 0; i < mono_array_length (process_info->env_variables); ++i) {
1899 var = mono_array_get (process_info->env_variables, MonoString*, i);
1900 var_length = mono_string_length (var);
1901
1902 /* str is a null-terminated copy of var */
1903
1904 if (var_length + 1 > str_length) {
1905 str_length = var_length + 1;
1906 str = g_renew (gunichar2, str, str_length);
1907 }
1908
1909 memcpy (str, mono_string_chars (var), var_length * sizeof (gunichar2));
1910 str [var_length] = '\0';
1911
1912 env_strings [i] = mono_unicode_to_external (str);
1913 }
1914
1915 g_free (str);
1916 } else {
1917 guint32 env_count;
1918
1919 env_count = 0;
1920 for (i = 0; environ[i] != NULL; i++)
1921 env_count++;
1922
1923 /* +2: one for the process handle value, and the last one is NULL */
1924 env_strings = g_new0 (gchar*, env_count + 2);
1925
1926 /* Copy each environ string into 'strings' turning it into utf8 (or the requested encoding) at the same time */
1927 for (i = 0; i < env_count; i++)
1928 env_strings [i] = g_strdup (environ[i]);
1929 }
1930
1931 /* Create a pipe to make sure the child doesn't exit before
1932 * we can add the process to the linked list of processes */
1933 if (pipe (startup_pipe) == -1) {
1934 /* Could not create the pipe to synchroniz process startup. We'll just not synchronize.
1935 * This is just for a very hard to hit race condition in the first place */
1936 startup_pipe [0] = startup_pipe [1] = -1;
1937 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__);
1938 }
1939
1940 switch (pid = fork ()) {
1941 case -1: /* Error */ {
1942 mono_w32error_set_last (ERROR_OUTOFMEMORY);
1943 ret = FALSE;
1944 break;
1945 }
1946 case 0: /* Child */ {
1947 if (startup_pipe [0] != -1) {
1948 /* Wait until the parent has updated it's internal data */
1949 ssize_t _i G_GNUC_UNUSED = read (startup_pipe [0], &dummy, 1);
1950 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: child: parent has completed its setup", __func__);
1951 close (startup_pipe [0]);
1952 close (startup_pipe [1]);
1953 }
1954
1955 /* should we detach from the process group? */
1956
1957 /* Connect stdin, stdout and stderr */
1958 dup2 (in_fd, 0);
1959 dup2 (out_fd, 1);
1960 dup2 (err_fd, 2);
1961
1962 /* Close all file descriptors */
1963 for (i = mono_w32handle_fd_reserve - 1; i > 2; i--)
1964 close (i);
1965
1966 #ifdef DEBUG_ENABLED
1967 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: exec()ing [%s] in dir [%s]", __func__, cmd,
1968 dir == NULL?".":dir);
1969 for (i = 0; argv[i] != NULL; i++)
1970 g_message ("arg %d: [%s]", i, argv[i]);
1971
1972 for (i = 0; env_strings[i] != NULL; i++)
1973 g_message ("env %d: [%s]", i, env_strings[i]);
1974 #endif
1975
1976 /* set cwd */
1977 if (dir != NULL && chdir (dir) == -1) {
1978 /* set error */
1979 _exit (-1);
1980 }
1981
1982 /* exec */
1983 execve (argv[0], argv, env_strings);
1984
1985 /* set error */
1986 _exit (-1);
1987
1988 break;
1989 }
1990 default: /* Parent */ {
1991 MonoW32HandleProcess process_handle;
1992
1993 memset (&process_handle, 0, sizeof (process_handle));
1994 process_handle.pid = pid;
1995 process_handle.child = TRUE;
1996 process_handle.pname = g_strdup (prog);
1997 process_set_defaults (&process_handle);
1998
1999 /* Add our process into the linked list of processes */
2000 process = (Process *) g_malloc0 (sizeof (Process));
2001 process->pid = pid;
2002 process->handle_count = 1;
2003 mono_os_sem_init (&process->exit_sem, 0);
2004
2005 process_handle.process = process;
2006
2007 handle = mono_w32handle_new (MONO_W32HANDLE_PROCESS, &process_handle);
2008 if (handle == INVALID_HANDLE_VALUE) {
2009 g_warning ("%s: error creating process handle", __func__);
2010
2011 mono_os_sem_destroy (&process->exit_sem);
2012 g_free (process);
2013
2014 mono_w32error_set_last (ERROR_OUTOFMEMORY);
2015 ret = FALSE;
2016 break;
2017 }
2018
2019 /* Keep the process handle artificially alive until the process
2020 * exits so that the information in the handle isn't lost. */
2021 mono_w32handle_ref (handle);
2022 process->handle = handle;
2023
2024 mono_os_mutex_lock (&processes_mutex);
2025 process->next = processes;
2026 mono_memory_barrier ();
2027 processes = process;
2028 mono_os_mutex_unlock (&processes_mutex);
2029
2030 if (process_info != NULL) {
2031 process_info->process_handle = handle;
2032 process_info->pid = pid;
2033
2034 /* FIXME: we might need to handle the thread info some day */
2035 process_info->thread_handle = INVALID_HANDLE_VALUE;
2036 process_info->tid = 0;
2037 }
2038
2039 break;
2040 }
2041 }
2042
2043 if (startup_pipe [1] != -1) {
2044 /* Write 1 byte, doesn't matter what */
2045 ssize_t _i G_GNUC_UNUSED = write (startup_pipe [1], startup_pipe, 1);
2046 close (startup_pipe [0]);
2047 close (startup_pipe [1]);
2048 }
2049
2050 free_strings:
2051 if (cmd)
2052 g_free (cmd);
2053 if (full_prog)
2054 g_free (full_prog);
2055 if (prog)
2056 g_free (prog);
2057 if (args)
2058 g_free (args);
2059 if (dir)
2060 g_free (dir);
2061 if (env_strings)
2062 g_strfreev (env_strings);
2063 if (argv)
2064 g_strfreev (argv);
2065
2066 mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER, "%s: returning handle %p for pid %d", __func__, handle, pid);
2067
2068 /* Check if something needs to be cleaned up. */
2069 processes_cleanup ();
2070
2071 return ret;
2072 #else
2073 mono_w32error_set_last (ERROR_NOT_SUPPORTED);
2074 return FALSE;
2075 #endif // defined (HAVE_FORK) && defined (HAVE_EXECVE)
2076 }
2077
2078 MonoBoolean
2079 ves_icall_System_Diagnostics_Process_ShellExecuteEx_internal (MonoW32ProcessStartInfo *proc_start_info, MonoW32ProcessInfo *process_info)
2080 {
2081 const gunichar2 *lpFile;
2082 const gunichar2 *lpParameters;
2083 const gunichar2 *lpDirectory;
2084 gunichar2 *args;
2085 gboolean ret;
2086
2087 if (!proc_start_info->filename) {
2088 /* w2k returns TRUE for this, for some reason. */
2089 ret = TRUE;
2090 goto done;
2091 }
2092
2093 lpFile = proc_start_info->filename ? mono_string_chars (proc_start_info->filename) : NULL;
2094 lpParameters = proc_start_info->arguments ? mono_string_chars (proc_start_info->arguments) : NULL;
2095 lpDirectory = proc_start_info->working_directory && mono_string_length (proc_start_info->working_directory) != 0 ?
2096 mono_string_chars (proc_start_info->working_directory) : NULL;
2097
2098 /* Put both executable and parameters into the second argument
2099 * to process_create (), so it searches $PATH. The conversion
2100 * into and back out of utf8 is because there is no
2101 * g_strdup_printf () equivalent for gunichar2 :-(
2102 */
2103 args = utf16_concat (utf16_quote, lpFile, utf16_quote, lpParameters == NULL ? NULL : utf16_space, lpParameters, NULL);
2104 if (args == NULL) {
2105 mono_w32error_set_last (ERROR_INVALID_DATA);
2106 ret = FALSE;
2107 goto done;
2108 }
2109 ret = process_create (NULL, args, lpDirectory, NULL, process_info);
2110 g_free (args);
2111
2112 if (!ret && mono_w32error_get_last () == ERROR_OUTOFMEMORY)
2113 goto done;
2114
2115 if (!ret) {
2116 static char *handler;
2117 static gunichar2 *handler_utf16;
2118
2119 if (handler_utf16 == (gunichar2 *)-1) {
2120 ret = FALSE;
2121 goto done;
2122 }
2123
2124 #ifdef PLATFORM_MACOSX
2125 handler = g_strdup ("/usr/bin/open");
2126 #else
2127 /*
2128 * On Linux, try: xdg-open, the FreeDesktop standard way of doing it,
2129 * if that fails, try to use gnome-open, then kfmclient
2130 */
2131 handler = g_find_program_in_path ("xdg-open");
2132 if (handler == NULL){
2133 handler = g_find_program_in_path ("gnome-open");
2134 if (handler == NULL){
2135 handler = g_find_program_in_path ("kfmclient");
2136 if (handler == NULL){
2137 handler_utf16 = (gunichar2 *) -1;
2138 ret = FALSE;
2139 goto done;
2140 } else {
2141 /* kfmclient needs exec argument */
2142 char *old = handler;
2143 handler = g_strconcat (old, " exec",
2144 NULL);
2145 g_free (old);
2146 }
2147 }
2148 }
2149 #endif
2150 handler_utf16 = g_utf8_to_utf16 (handler, -1, NULL, NULL, NULL);
2151 g_free (handler);
2152
2153 /* Put quotes around the filename, in case it's a url
2154 * that contains #'s (process_create() calls
2155 * g_shell_parse_argv(), which deliberately throws
2156 * away anything after an unquoted #). Fixes bug
2157 * 371567.
2158 */
2159 args = utf16_concat (handler_utf16, utf16_space, utf16_quote, lpFile, utf16_quote,
2160 lpParameters == NULL ? NULL : utf16_space, lpParameters, NULL);
2161 if (args == NULL) {
2162 mono_w32error_set_last (ERROR_INVALID_DATA);
2163 ret = FALSE;
2164 goto done;
2165 }
2166 ret = process_create (NULL, args, lpDirectory, NULL, process_info);
2167 g_free (args);
2168 if (!ret) {
2169 if (mono_w32error_get_last () != ERROR_OUTOFMEMORY)
2170 mono_w32error_set_last (ERROR_INVALID_DATA);
2171 ret = FALSE;
2172 goto done;
2173 }
2174 /* Shell exec should not return a process handle when it spawned a GUI thing, like a browser. */
2175 mono_w32handle_close (process_info->process_handle);
2176 process_info->process_handle = NULL;
2177 }
2178
2179 done:
2180 if (ret == FALSE) {
2181 process_info->pid = -mono_w32error_get_last ();
2182 } else {
2183 process_info->thread_handle = NULL;
2184 #if !defined(MONO_CROSS_COMPILE)
2185 process_info->pid = mono_w32process_get_pid (process_info->process_handle);
2186 #else
2187 process_info->pid = 0;
2188 #endif
2189 process_info->tid = 0;
2190 }
2191
2192 return ret;
2193 }
2194
2195 /* Only used when UseShellExecute is false */
2196 static gboolean
2197 process_get_complete_path (const gunichar2 *appname, gchar **completed)
2198 {
2199 gchar *utf8app;
2200 gchar *found;
2201
2202 utf8app = g_utf16_to_utf8 (appname, -1, NULL, NULL, NULL);
2203
2204 if (g_path_is_absolute (utf8app)) {
2205 *completed = g_shell_quote (utf8app);
2206 g_free (utf8app);
2207 return TRUE;
2208 }
2209
2210 if (g_file_test (utf8app, G_FILE_TEST_IS_EXECUTABLE) && !g_file_test (utf8app, G_FILE_TEST_IS_DIR)) {
2211 *completed = g_shell_quote (utf8app);
2212 g_free (utf8app);
2213 return TRUE;
2214 }
2215
2216 found = g_find_program_in_path (utf8app);
2217 if (found == NULL) {
2218 *completed = NULL;
2219 g_free (utf8app);
2220 return FALSE;
2221 }
2222
2223 *completed = g_shell_quote (found);
2224 g_free (found);
2225 g_free (utf8app);
2226 return TRUE;
2227 }
2228
2229 static gboolean
2230 process_get_shell_arguments (MonoW32ProcessStartInfo *proc_start_info, gunichar2 **shell_path)
2231 {
2232 gchar *complete_path = NULL;
2233
2234 *shell_path = NULL;
2235
2236 if (process_get_complete_path (mono_string_chars (proc_start_info->filename), &complete_path)) {
2237 *shell_path = g_utf8_to_utf16 (complete_path, -1, NULL, NULL, NULL);
2238 g_free (complete_path);
2239 }
2240
2241 return *shell_path != NULL;
2242 }
2243
2244 MonoBoolean
2245 ves_icall_System_Diagnostics_Process_CreateProcess_internal (MonoW32ProcessStartInfo *proc_start_info,
2246 HANDLE stdin_handle, HANDLE stdout_handle, HANDLE stderr_handle, MonoW32ProcessInfo *process_info)
2247 {
2248 gboolean ret;
2249 gunichar2 *dir;
2250 StartupHandles startup_handles;
2251 gunichar2 *shell_path = NULL;
2252 gunichar2 *args = NULL;
2253
2254 memset (&startup_handles, 0, sizeof (startup_handles));
2255 startup_handles.input = stdin_handle;
2256 startup_handles.output = stdout_handle;
2257 startup_handles.error = stderr_handle;
2258
2259 if (!process_get_shell_arguments (proc_start_info, &shell_path)) {
2260 process_info->pid = -ERROR_FILE_NOT_FOUND;
2261 return FALSE;
2262 }
2263
2264 args = proc_start_info->arguments && mono_string_length (proc_start_info->arguments) > 0 ?
2265 mono_string_chars (proc_start_info->arguments): NULL;
2266
2267 /* The default dir name is "". Turn that into NULL to mean "current directory" */
2268 dir = proc_start_info->working_directory && mono_string_length (proc_start_info->working_directory) > 0 ?
2269 mono_string_chars (proc_start_info->working_directory) : NULL;
2270
2271 ret = process_create (shell_path, args, dir, &startup_handles, process_info);
2272
2273 if (shell_path != NULL)
2274 g_free (shell_path);
2275
2276 if (!ret)
2277 process_info->pid = -mono_w32error_get_last ();
2278
2279 return ret;
2280 }
2281
2282 /* Returns an array of pids */
2283 MonoArray *
2284 ves_icall_System_Diagnostics_Process_GetProcesses_internal (void)
2285 {
2286 MonoError error;
2287 MonoArray *procs;
2288 gpointer *pidarray;
2289 int i, count;
2290
2291 pidarray = mono_process_list (&count);
2292 if (!pidarray) {
2293 mono_set_pending_exception (mono_get_exception_not_supported ("This system does not support EnumProcesses"));
2294 return NULL;
2295 }
2296 procs = mono_array_new_checked (mono_domain_get (), mono_get_int32_class (), count, &error);
2297 if (mono_error_set_pending_exception (&error)) {
2298 g_free (pidarray);
2299 return NULL;
2300 }
2301 if (sizeof (guint32) == sizeof (gpointer)) {
2302 memcpy (mono_array_addr (procs, guint32, 0), pidarray, count * sizeof (gint32));
2303 } else {
2304 for (i = 0; i < count; ++i)
2305 *(mono_array_addr (procs, guint32, i)) = GPOINTER_TO_UINT (pidarray [i]);
2306 }
2307 g_free (pidarray);
2308
2309 return procs;
2310 }
2311
2312 void
2313 mono_w32process_set_cli_launcher (gchar *path)
2314 {
2315 g_free (cli_launcher);
2316 cli_launcher = g_strdup (path);
2317 }
2318
2319 gpointer
2320 ves_icall_Microsoft_Win32_NativeMethods_GetCurrentProcess (void)
2321 {
2322 mono_w32handle_ref (current_process);
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: %d", __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: %d", __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, 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 }
Mirror of the official Mono project git repository