mono/io-layer/processes.c

   1 /*
   2  * processes.c:  Process handles
   3  *
   4  * Author:
   5  *      Dick Porter (dick@ximian.com)
   6  *
   7  * (C) 2002-2006 Novell, Inc.
   8  */
   9
  10 #include <config.h>
  11 #include <glib.h>
  12 #include <string.h>
  13 #include <pthread.h>
  14 #include <sched.h>
  15 #include <sys/time.h>
  16 #include <errno.h>
  17 #include <sys/types.h>
  18 #include <unistd.h>
  19 #include <signal.h>
  20 #include <sys/wait.h>
  21 #include <fcntl.h>
  22
  23 #include <mono/io-layer/wapi.h>
  24 #include <mono/io-layer/wapi-private.h>
  25 #include <mono/io-layer/handles-private.h>
  26 #include <mono/io-layer/misc-private.h>
  27 #include <mono/io-layer/mono-mutex.h>
  28 #include <mono/io-layer/process-private.h>
  29 #include <mono/io-layer/threads.h>
  30 #include <mono/utils/strenc.h>
  31 #include <mono/io-layer/timefuncs-private.h>
  32
  33 /* The process' environment strings */
  34 extern char **environ;
  35
  36 #undef DEBUG
  37
  38 static guint32 process_wait (gpointer handle, guint32 timeout);
  39
  40 struct _WapiHandleOps _wapi_process_ops = {
  41         NULL,                           /* close_shared */
  42         NULL,                           /* signal */
  43         NULL,                           /* own */
  44         NULL,                           /* is_owned */
  45         process_wait,                   /* special_wait */
  46         NULL                            /* prewait */
  47 };
  48
  49 static mono_once_t process_current_once=MONO_ONCE_INIT;
  50 static gpointer current_process=NULL;
  51
  52 static mono_once_t process_ops_once=MONO_ONCE_INIT;
  53
  54 static void process_ops_init (void)
  55 {
  56         _wapi_handle_register_capabilities (WAPI_HANDLE_PROCESS,
  57                                             WAPI_HANDLE_CAP_WAIT |
  58                                             WAPI_HANDLE_CAP_SPECIAL_WAIT);
  59 }
  60
  61 static gboolean process_set_termination_details (gpointer handle, int status)
  62 {
  63         struct _WapiHandle_process *process_handle;
  64         gboolean ok;
  65         int thr_ret;
  66
  67         ok = _wapi_lookup_handle (handle, WAPI_HANDLE_PROCESS,
  68                                   (gpointer *)&process_handle);
  69         if (ok == FALSE) {
  70                 g_warning ("%s: error looking up process handle %p",
  71                            __func__, handle);
  72                 return(FALSE);
  73         }
  74
  75         thr_ret = _wapi_handle_lock_shared_handles ();
  76         g_assert (thr_ret == 0);
  77
  78         if (WIFSIGNALED(status)) {
  79                 process_handle->exitstatus = 128 + WTERMSIG(status);
  80         } else {
  81                 process_handle->exitstatus = WEXITSTATUS(status);
  82         }
  83         _wapi_time_t_to_filetime (time(NULL), &process_handle->exit_time);
  84
  85         /* Don't set process_handle->waited here, it needs to only
  86          * happen in the parent when wait() has been called.
  87          */
  88
  89 #ifdef DEBUG
  90         g_message ("%s: Setting handle %p signalled", __func__, handle);
  91 #endif
  92
  93         _wapi_shared_handle_set_signal_state (handle, TRUE);
  94
  95         _wapi_handle_unlock_shared_handles ();
  96
  97         /* Drop the reference we hold so we have somewhere to store
  98          * the exit details, now the process has in fact exited
  99          */
 100         _wapi_handle_unref (handle);
 101
 102         return (ok);
 103 }
 104
 105 /* See if any child processes have terminated and wait() for them,
 106  * updating process handle info.  This function is called from the
 107  * collection thread every few seconds.
 108  */
 109 static gboolean waitfor_pid (gpointer test, gpointer user_data)
 110 {
 111         struct _WapiHandle_process *process;
 112         gboolean ok;
 113         int status;
 114         pid_t ret;
 115
 116         ok = _wapi_lookup_handle (test, WAPI_HANDLE_PROCESS,
 117                                   (gpointer *)&process);
 118         if (ok == FALSE) {
 119                 /* The handle must have been too old and was reaped */
 120                 return (FALSE);
 121         }
 122
 123         if (process->waited) {
 124                 /* We've already done this one */
 125                 return(FALSE);
 126         }
 127
 128         do {
 129                 ret = waitpid (process->id, &status, WNOHANG);
 130         } while (errno == EINTR);
 131
 132         if (ret <= 0) {
 133                 /* Process not ready for wait */
 134 #ifdef DEBUG
 135                 g_message ("%s: Process %d not ready for waiting for: %s",
 136                            __func__, process->id, g_strerror (errno));
 137 #endif
 138
 139                 return (FALSE);
 140         }
 141
 142 #ifdef DEBUG
 143         g_message ("%s: Process %d finished", __func__, ret);
 144 #endif
 145
 146         process->waited = TRUE;
 147
 148         *(int *)user_data = status;
 149
 150         return (TRUE);
 151 }
 152
 153 void _wapi_process_reap (void)
 154 {
 155         gpointer proc;
 156         int status;
 157
 158 #ifdef DEBUG
 159         g_message ("%s: Reaping child processes", __func__);
 160 #endif
 161
 162         do {
 163                 proc = _wapi_search_handle (WAPI_HANDLE_PROCESS, waitfor_pid,
 164                                             &status, NULL, FALSE);
 165                 if (proc != NULL) {
 166 #ifdef DEBUG
 167                         g_message ("%s: process handle %p exit code %d",
 168                                    __func__, proc, status);
 169 #endif
 170
 171                         process_set_termination_details (proc, status);
 172
 173                         /* _wapi_search_handle adds a reference, so
 174                          * drop it here
 175                          */
 176                         _wapi_handle_unref (proc);
 177                 }
 178         } while (proc != NULL);
 179 }
 180
 181 /* Limitations: This can only wait for processes that are our own
 182  * children.  Fixing this means resurrecting a daemon helper to manage
 183  * processes.
 184  */
 185 static guint32 process_wait (gpointer handle, guint32 timeout)
 186 {
 187         struct _WapiHandle_process *process_handle;
 188         gboolean ok;
 189         pid_t pid, ret;
 190         int status;
 191
 192 #ifdef DEBUG
 193         g_message ("%s: Waiting for process %p", __func__, handle);
 194 #endif
 195
 196         ok = _wapi_lookup_handle (handle, WAPI_HANDLE_PROCESS,
 197                                   (gpointer *)&process_handle);
 198         if (ok == FALSE) {
 199                 g_warning ("%s: error looking up process handle %p", __func__,
 200                            handle);
 201                 return(WAIT_FAILED);
 202         }
 203
 204         if (process_handle->waited) {
 205                 /* We've already done this one */
 206 #ifdef DEBUG
 207                 g_message ("%s: Process %p already signalled", __func__,
 208                            handle);
 209 #endif
 210
 211                 return (WAIT_OBJECT_0);
 212         }
 213
 214         pid = process_handle->id;
 215
 216 #ifdef DEBUG
 217         g_message ("%s: PID is %d, timeout %d", __func__, pid, timeout);
 218 #endif
 219
 220         if (timeout == INFINITE) {
 221                 if (pid == _wapi_getpid ()) {
 222                         do {
 223                                 Sleep (10000);
 224                         } while(1);
 225                 } else {
 226                         while ((ret = waitpid (pid, &status, 0)) != pid) {
 227                                 if (ret == (pid_t)-1 && errno != EINTR) {
 228                                         return(WAIT_FAILED);
 229                                 }
 230                         }
 231                 }
 232         } else if (timeout == 0) {
 233                 /* Just poll */
 234                 ret = waitpid (pid, &status, WNOHANG);
 235                 if (ret != pid) {
 236                         return (WAIT_TIMEOUT);
 237                 }
 238         } else {
 239                 /* Poll in a loop */
 240                 if (pid == _wapi_getpid ()) {
 241                         Sleep (timeout);
 242                         return(WAIT_TIMEOUT);
 243                 } else {
 244                         do {
 245                                 ret = waitpid (pid, &status, WNOHANG);
 246 #ifdef DEBUG
 247                                 g_message ("%s: waitpid returns: %d, timeout is %d", __func__, ret, timeout);
 248 #endif
 249
 250                                 if (ret == pid) {
 251                                         break;
 252                                 } else if (ret == (pid_t)-1 &&
 253                                            errno != EINTR) {
 254 #ifdef DEBUG
 255                                         g_message ("%s: waitpid failure: %s",
 256                                                    __func__,
 257                                                    g_strerror (errno));
 258 #endif
 259
 260                                         if (errno == ECHILD &&
 261                                             process_handle->waited) {
 262                                                 /* The background
 263                                                  * process reaper must
 264                                                  * have got this one
 265                                                  */
 266 #ifdef DEBUG
 267                                                 g_message ("%s: Process %p already reaped", __func__, handle);
 268 #endif
 269
 270                                                 return(WAIT_OBJECT_0);
 271                                         } else {
 272                                                 return(WAIT_FAILED);
 273                                         }
 274                                 }
 275
 276                                 _wapi_handle_spin (100);
 277                                 timeout -= 100;
 278                         } while (timeout > 0);
 279                 }
 280
 281                 if (timeout <= 0) {
 282                         return(WAIT_TIMEOUT);
 283                 }
 284         }
 285
 286         /* Process must have exited */
 287 #ifdef DEBUG
 288         g_message ("%s: Wait done, status %d", __func__, status);
 289 #endif
 290
 291         ok = process_set_termination_details (handle, status);
 292         if (ok == FALSE) {
 293                 SetLastError (ERROR_OUTOFMEMORY);
 294                 return (WAIT_FAILED);
 295         }
 296         process_handle->waited = TRUE;
 297
 298         return(WAIT_OBJECT_0);
 299 }
 300
 301 void _wapi_process_signal_self ()
 302 {
 303         if (current_process != NULL) {
 304                 process_set_termination_details (current_process, 0);
 305         }
 306 }
 307
 308 static void process_set_defaults (struct _WapiHandle_process *process_handle)
 309 {
 310         /* These seem to be the defaults on w2k */
 311         process_handle->min_working_set = 204800;
 312         process_handle->max_working_set = 1413120;
 313
 314         process_handle->waited = FALSE;
 315
 316         _wapi_time_t_to_filetime (time (NULL), &process_handle->create_time);
 317 }
 318
 319 static int
 320 len16 (const gunichar2 *str)
 321 {
 322         int len = 0;
 323
 324         while (*str++ != 0)
 325                 len++;
 326
 327         return len;
 328 }
 329
 330 static gunichar2 *
 331 utf16_concat (const gunichar2 *first, ...)
 332 {
 333         va_list args;
 334         int total = 0, i;
 335         const gunichar2 *s;
 336         gunichar2 *ret;
 337
 338         va_start (args, first);
 339         total += len16 (first);
 340         for (s = va_arg (args, gunichar2 *); s != NULL; s = va_arg(args, gunichar2 *)){
 341                 total += len16 (s);
 342         }
 343         va_end (args);
 344
 345         ret = g_new (gunichar2, total + 1);
 346         if (ret == NULL)
 347                 return NULL;
 348
 349         ret [total] = 0;
 350         i = 0;
 351         for (s = first; *s != 0; s++)
 352                 ret [i++] = *s;
 353         va_start (args, first);
 354         for (s = va_arg (args, gunichar2 *); s != NULL; s = va_arg (args, gunichar2 *)){
 355                 const gunichar2 *p;
 356
 357                 for (p = s; *p != 0; p++)
 358                         ret [i++] = *p;
 359         }
 360         va_end (args);
 361
 362         return ret;
 363 }
 364
 365 static const gunichar2 utf16_space_bytes [2] = { 0x20, 0 };
 366 static const gunichar2 *utf16_space = utf16_space_bytes;
 367
 368 /* Implemented as just a wrapper around CreateProcess () */
 369 gboolean ShellExecuteEx (WapiShellExecuteInfo *sei)
 370 {
 371         gboolean ret;
 372         WapiProcessInformation process_info;
 373         gunichar2 *args;
 374
 375         if (sei == NULL) {
 376                 /* w2k just segfaults here, but we can do better than
 377                  * that
 378                  */
 379                 SetLastError (ERROR_INVALID_PARAMETER);
 380                 return (FALSE);
 381         }
 382
 383         if (sei->lpFile == NULL) {
 384                 /* w2k returns TRUE for this, for some reason. */
 385                 return (TRUE);
 386         }
 387
 388         /* Put both executable and parameters into the second argument
 389          * to CreateProcess (), so it searches $PATH.  The conversion
 390          * into and back out of utf8 is because there is no
 391          * g_strdup_printf () equivalent for gunichar2 :-(
 392          */
 393         args = utf16_concat (sei->lpFile, sei->lpParameters == NULL ? NULL : utf16_space, sei->lpParameters, NULL);
 394         if (args == NULL){
 395                 SetLastError (ERROR_INVALID_DATA);
 396                 return (FALSE);
 397         }
 398         ret = CreateProcess (NULL, args, NULL, NULL, TRUE,
 399                              CREATE_UNICODE_ENVIRONMENT, NULL,
 400                              sei->lpDirectory, NULL, &process_info);
 401         g_free (args);
 402
 403         if (!ret) {
 404                 static char *handler;
 405                 static gunichar2 *handler_utf16;
 406
 407                 if (handler_utf16 == (gunichar2 *)-1)
 408                         return FALSE;
 409
 410 #ifdef PLATFORM_MACOSX
 411                 handler = "/usr/bin/open";
 412 #else
 413                 /*
 414                  * On Linux, try: xdg-open, the FreeDesktop standard way of doing it,
 415                  * if that fails, try to use gnome-open, then kfmclient
 416                  */
 417                 handler = g_find_program_in_path ("xdg-open");
 418                 if (handler == NULL){
 419                         handler = g_find_program_in_path ("gnome-open");
 420                         if (handler == NULL){
 421                                 handler = g_find_program_in_path ("kfmclient");
 422                                 if (handler == NULL){
 423                                         handler_utf16 = (gunichar2 *) -1;
 424                                         return (FALSE);
 425                                 } else {
 426                                         /* kfmclient needs exec argument */
 427                                         char *old = handler;
 428                                         handler = g_strconcat (old, " exec",
 429                                                                NULL);
 430                                         g_free (old);
 431                                 }
 432                         }
 433                 }
 434 #endif
 435                 handler_utf16 = g_utf8_to_utf16 (handler, -1, NULL, NULL, NULL);
 436                 g_free (handler);
 437                 args = utf16_concat (handler_utf16, utf16_space, sei->lpFile,
 438                                      sei->lpParameters == NULL ? NULL : utf16_space,
 439                                      sei->lpParameters, NULL);
 440                 if (args == NULL){
 441                         SetLastError (ERROR_INVALID_DATA);
 442                         return FALSE;
 443                 }
 444                 ret = CreateProcess (NULL, args, NULL, NULL, TRUE,
 445                                      CREATE_UNICODE_ENVIRONMENT, NULL,
 446                                      sei->lpDirectory, NULL, &process_info);
 447                 g_free (args);
 448                 if (!ret){
 449                         SetLastError (ERROR_INVALID_DATA);
 450                         return FALSE;
 451                 }
 452         }
 453
 454         if (sei->fMask & SEE_MASK_NOCLOSEPROCESS) {
 455                 sei->hProcess = process_info.hProcess;
 456         } else {
 457                 CloseHandle (process_info.hProcess);
 458         }
 459
 460         return (ret);
 461 }
 462
 463 static gboolean
 464 is_managed_binary (const gchar *filename)
 465 {
 466         int original_errno = errno;
 467 #if defined(HAVE_LARGE_FILE_SUPPORT) && defined(O_LARGEFILE)
 468         int file = open (filename, O_RDONLY | O_LARGEFILE);
 469 #else
 470         int file = open (filename, O_RDONLY);
 471 #endif
 472         off_t new_offset;
 473         unsigned char buffer[8];
 474         off_t file_size, optional_header_offset;
 475         off_t pe_header_offset;
 476         gboolean managed = FALSE;
 477         int num_read;
 478         guint32 first_word, second_word;
 479
 480         /* If we are unable to open the file, then we definitely
 481          * can't say that it is managed. The child mono process
 482          * probably wouldn't be able to open it anyway.
 483          */
 484         if (file < 0) {
 485                 errno = original_errno;
 486                 return FALSE;
 487         }
 488
 489         /* Retrieve the length of the file for future sanity checks. */
 490         file_size = lseek (file, 0, SEEK_END);
 491         lseek (file, 0, SEEK_SET);
 492
 493         /* We know we need to read a header field at offset 60. */
 494         if (file_size < 64)
 495                 goto leave;
 496
 497         num_read = read (file, buffer, 2);
 498
 499         if ((num_read != 2) || (buffer[0] != 'M') || (buffer[1] != 'Z'))
 500                 goto leave;
 501
 502         new_offset = lseek (file, 60, SEEK_SET);
 503
 504         if (new_offset != 60)
 505                 goto leave;
 506
 507         num_read = read (file, buffer, 4);
 508
 509         if (num_read != 4)
 510                 goto leave;
 511         pe_header_offset =  buffer[0]
 512                 | (buffer[1] <<  8)
 513                 | (buffer[2] << 16)
 514                 | (buffer[3] << 24);
 515
 516         if (pe_header_offset + 24 > file_size)
 517                 goto leave;
 518
 519         new_offset = lseek (file, pe_header_offset, SEEK_SET);
 520
 521         if (new_offset != pe_header_offset)
 522                 goto leave;
 523
 524         num_read = read (file, buffer, 4);
 525
 526         if ((num_read != 4) || (buffer[0] != 'P') || (buffer[1] != 'E') || (buffer[2] != 0) || (buffer[3] != 0))
 527                 goto leave;
 528
 529         /*
 530          * Verify that the header we want in the optional header data
 531          * is present in this binary.
 532          */
 533         new_offset = lseek (file, pe_header_offset + 20, SEEK_SET);
 534
 535         if (new_offset != pe_header_offset + 20)
 536                 goto leave;
 537
 538         num_read = read (file, buffer, 2);
 539
 540         if ((num_read != 2) || ((buffer[0] | (buffer[1] << 8)) < 216))
 541                 goto leave;
 542
 543         /* Read the CLR header address and size fields. These will be
 544          * zero if the binary is not managed.
 545          */
 546         optional_header_offset = pe_header_offset + 24;
 547         new_offset = lseek (file, optional_header_offset + 208, SEEK_SET);
 548
 549         if (new_offset != optional_header_offset + 208)
 550                 goto leave;
 551
 552         num_read = read (file, buffer, 8);
 553
 554         /* We are not concerned with endianness, only with
 555          * whether it is zero or not.
 556          */
 557         first_word = *(guint32 *)&buffer[0];
 558         second_word = *(guint32 *)&buffer[4];
 559
 560         if ((num_read != 8) || (first_word == 0) || (second_word == 0))
 561                 goto leave;
 562
 563         managed = TRUE;
 564
 565 leave:
 566         close (file);
 567         errno = original_errno;
 568         return managed;
 569 }
 570
 571 gboolean CreateProcess (const gunichar2 *appname, const gunichar2 *cmdline,
 572                         WapiSecurityAttributes *process_attrs G_GNUC_UNUSED,
 573                         WapiSecurityAttributes *thread_attrs G_GNUC_UNUSED,
 574                         gboolean inherit_handles, guint32 create_flags,
 575                         gpointer new_environ, const gunichar2 *cwd,
 576                         WapiStartupInfo *startup,
 577                         WapiProcessInformation *process_info)
 578 {
 579         gchar *cmd=NULL, *prog = NULL, *full_prog = NULL, *args = NULL, *args_after_prog = NULL, *dir = NULL, **env_strings = NULL, **argv = NULL;
 580         guint32 i, env_count = 0;
 581         gboolean ret = FALSE;
 582         gpointer handle;
 583         struct _WapiHandle_process process_handle = {0}, *process_handle_data;
 584         GError *gerr = NULL;
 585         int in_fd, out_fd, err_fd;
 586         pid_t pid;
 587         int thr_ret;
 588
 589         mono_once (&process_ops_once, process_ops_init);
 590
 591         /* appname and cmdline specify the executable and its args:
 592          *
 593          * If appname is not NULL, it is the name of the executable.
 594          * Otherwise the executable is the first token in cmdline.
 595          *
 596          * Executable searching:
 597          *
 598          * If appname is not NULL, it can specify the full path and
 599          * file name, or else a partial name and the current directory
 600          * will be used.  There is no additional searching.
 601          *
 602          * If appname is NULL, the first whitespace-delimited token in
 603          * cmdline is used.  If the name does not contain a full
 604          * directory path, the search sequence is:
 605          *
 606          * 1) The directory containing the current process
 607          * 2) The current working directory
 608          * 3) The windows system directory  (Ignored)
 609          * 4) The windows directory (Ignored)
 610          * 5) $PATH
 611          *
 612          * Just to make things more interesting, tokens can contain
 613          * white space if they are surrounded by quotation marks.  I'm
 614          * beginning to understand just why windows apps are generally
 615          * so crap, with an API like this :-(
 616          */
 617         if (appname != NULL) {
 618                 cmd = mono_unicode_to_external (appname);
 619                 if (cmd == NULL) {
 620 #ifdef DEBUG
 621                         g_message ("%s: unicode conversion returned NULL",
 622                                    __func__);
 623 #endif
 624
 625                         SetLastError (ERROR_PATH_NOT_FOUND);
 626                         goto cleanup;
 627                 }
 628
 629                 /* Turn all the slashes round the right way */
 630                 for (i = 0; i < strlen (cmd); i++) {
 631                         if (cmd[i] == '\\') {
 632                                 cmd[i] = '/';
 633                         }
 634                 }
 635         }
 636
 637         if (cmdline != NULL) {
 638                 args = mono_unicode_to_external (cmdline);
 639                 if (args == NULL) {
 640 #ifdef DEBUG
 641                         g_message ("%s: unicode conversion returned NULL", __func__);
 642 #endif
 643
 644                         SetLastError (ERROR_PATH_NOT_FOUND);
 645                         goto cleanup;
 646                 }
 647         }
 648
 649         if (cwd != NULL) {
 650                 dir = mono_unicode_to_external (cwd);
 651                 if (dir == NULL) {
 652 #ifdef DEBUG
 653                         g_message ("%s: unicode conversion returned NULL", __func__);
 654 #endif
 655
 656                         SetLastError (ERROR_PATH_NOT_FOUND);
 657                         goto cleanup;
 658                 }
 659
 660                 /* Turn all the slashes round the right way */
 661                 for (i = 0; i < strlen (dir); i++) {
 662                         if (dir[i] == '\\') {
 663                                 dir[i] = '/';
 664                         }
 665                 }
 666         }
 667
 668
 669         /* We can't put off locating the executable any longer :-( */
 670         if (cmd != NULL) {
 671                 gchar *unquoted;
 672                 if (g_ascii_isalpha (cmd[0]) && (cmd[1] == ':')) {
 673                         /* Strip off the drive letter.  I can't
 674                          * believe that CP/M holdover is still
 675                          * visible...
 676                          */
 677                         g_memmove (cmd, cmd+2, strlen (cmd)-2);
 678                         cmd[strlen (cmd)-2] = '\0';
 679                 }
 680
 681                 unquoted = g_shell_unquote (cmd, NULL);
 682                 if (unquoted[0] == '/') {
 683                         /* Assume full path given */
 684                         prog = g_strdup (unquoted);
 685
 686                         /* Executable existing ? */
 687                         if (access (prog, X_OK) != 0) {
 688 #ifdef DEBUG
 689                                 g_message ("%s: Couldn't find executable %s",
 690                                            __func__, prog);
 691 #endif
 692                                 g_free (unquoted);
 693                                 SetLastError (ERROR_FILE_NOT_FOUND);
 694                                 goto cleanup;
 695                         }
 696                 } else {
 697                         /* Search for file named by cmd in the current
 698                          * directory
 699                          */
 700                         char *curdir = g_get_current_dir ();
 701
 702                         prog = g_strdup_printf ("%s/%s", curdir, unquoted);
 703                         g_free (curdir);
 704
 705                         /* And make sure it's executable */
 706                         if (access (prog, X_OK) != 0) {
 707 #ifdef DEBUG
 708                                 g_message ("%s: Couldn't find executable %s",
 709                                            __func__, prog);
 710 #endif
 711                                 g_free (unquoted);
 712                                 SetLastError (ERROR_FILE_NOT_FOUND);
 713                                 goto cleanup;
 714                         }
 715                 }
 716                 g_free (unquoted);
 717
 718                 args_after_prog = args;
 719         } else {
 720                 gchar *token = NULL;
 721                 char quote;
 722
 723                 /* Dig out the first token from args, taking quotation
 724                  * marks into account
 725                  */
 726
 727                 /* First, strip off all leading whitespace */
 728                 args = g_strchug (args);
 729
 730                 /* args_after_prog points to the contents of args
 731                  * after token has been set (otherwise argv[0] is
 732                  * duplicated)
 733                  */
 734                 args_after_prog = args;
 735
 736                 /* Assume the opening quote will always be the first
 737                  * character
 738                  */
 739                 if (args[0] == '\"' || args [0] == '\'') {
 740                         quote = args [0];
 741                         for (i = 1; args[i] != '\0' && args[i] != quote; i++);
 742                         if (g_ascii_isspace (args[i+1])) {
 743                                 /* We found the first token */
 744                                 token = g_strndup (args+1, i-1);
 745                                 args_after_prog = args + i;
 746                         } else {
 747                                 /* Quotation mark appeared in the
 748                                  * middle of the token.  Just give the
 749                                  * whole first token, quotes and all,
 750                                  * to exec.
 751                                  */
 752                         }
 753                 }
 754
 755                 if (token == NULL) {
 756                         /* No quote mark, or malformed */
 757                         for (i = 0; args[i] != '\0'; i++) {
 758                                 if (g_ascii_isspace (args[i])) {
 759                                         token = g_strndup (args, i);
 760                                         args_after_prog = args + i + 1;
 761                                         break;
 762                                 }
 763                         }
 764                 }
 765
 766                 if (token == NULL && args[0] != '\0') {
 767                         /* Must be just one token in the string */
 768                         token = g_strdup (args);
 769                         args_after_prog = NULL;
 770                 }
 771
 772                 if (token == NULL) {
 773                         /* Give up */
 774 #ifdef DEBUG
 775                         g_message ("%s: Couldn't find what to exec", __func__);
 776 #endif
 777
 778                         SetLastError (ERROR_PATH_NOT_FOUND);
 779                         goto cleanup;
 780                 }
 781
 782                 /* Turn all the slashes round the right way. Only for
 783                  * the prg. name
 784                  */
 785                 for (i = 0; i < strlen (token); i++) {
 786                         if (token[i] == '\\') {
 787                                 token[i] = '/';
 788                         }
 789                 }
 790
 791                 if (g_ascii_isalpha (token[0]) && (token[1] == ':')) {
 792                         /* Strip off the drive letter.  I can't
 793                          * believe that CP/M holdover is still
 794                          * visible...
 795                          */
 796                         g_memmove (token, token+2, strlen (token)-2);
 797                         token[strlen (token)-2] = '\0';
 798                 }
 799
 800                 if (token[0] == '/') {
 801                         /* Assume full path given */
 802                         prog = g_strdup (token);
 803
 804                         /* Executable existing ? */
 805                         if (access (prog, X_OK) != 0) {
 806 #ifdef DEBUG
 807                                 g_message ("%s: Couldn't find executable %s",
 808                                            __func__, token);
 809 #endif
 810                                 g_free (token);
 811                                 SetLastError (ERROR_FILE_NOT_FOUND);
 812                                 goto cleanup;
 813                         }
 814
 815                 } else {
 816                         char *curdir = g_get_current_dir ();
 817
 818                         /* FIXME: Need to record the directory
 819                          * containing the current process, and check
 820                          * that for the new executable as the first
 821                          * place to look
 822                          */
 823
 824                         prog = g_strdup_printf ("%s/%s", curdir, token);
 825                         g_free (curdir);
 826
 827                         /* I assume X_OK is the criterion to use,
 828                          * rather than F_OK
 829                          */
 830                         if (access (prog, X_OK) != 0) {
 831                                 g_free (prog);
 832                                 prog = g_find_program_in_path (token);
 833                                 if (prog == NULL) {
 834 #ifdef DEBUG
 835                                         g_message ("%s: Couldn't find executable %s", __func__, token);
 836 #endif
 837
 838                                         g_free (token);
 839                                         SetLastError (ERROR_FILE_NOT_FOUND);
 840                                         goto cleanup;
 841                                 }
 842                         }
 843                 }
 844
 845                 g_free (token);
 846         }
 847
 848 #ifdef DEBUG
 849         g_message ("%s: Exec prog [%s] args [%s]", __func__, prog,
 850                    args_after_prog);
 851 #endif
 852
 853         /* Check for CLR binaries; if found, we will try to invoke
 854          * them using the same mono binary that started us.
 855          */
 856         if (is_managed_binary (prog) && (appname == NULL)) {
 857                 gsize bytes_ignored;
 858
 859                 appname = mono_unicode_from_external ("mono", &bytes_ignored);
 860
 861                 if (appname != NULL) {
 862                         cmdline = utf16_concat (appname, utf16_space, cmdline, NULL);
 863
 864                         g_free ((gunichar2 *)appname);
 865
 866                         if (cmdline != NULL) {
 867                                 gboolean return_value = CreateProcess (
 868                                         NULL, cmdline, process_attrs,
 869                                         thread_attrs, inherit_handles, create_flags, new_environ,
 870                                         cwd, startup, process_info);
 871
 872                                 g_free ((gunichar2 *)cmdline);
 873
 874                                 return return_value;
 875                         }
 876                 }
 877         }
 878
 879         if (args_after_prog != NULL && *args_after_prog) {
 880                 gchar *qprog;
 881
 882                 qprog = g_shell_quote (prog);
 883                 full_prog = g_strconcat (qprog, " ", args_after_prog, NULL);
 884                 g_free (qprog);
 885         } else {
 886                 full_prog = g_shell_quote (prog);
 887         }
 888
 889         ret = g_shell_parse_argv (full_prog, NULL, &argv, &gerr);
 890         if (ret == FALSE) {
 891                 /* FIXME: Could do something with the GError here
 892                  */
 893         }
 894
 895         if (startup != NULL && startup->dwFlags & STARTF_USESTDHANDLES) {
 896                 in_fd = GPOINTER_TO_UINT (startup->hStdInput);
 897                 out_fd = GPOINTER_TO_UINT (startup->hStdOutput);
 898                 err_fd = GPOINTER_TO_UINT (startup->hStdError);
 899         } else {
 900                 in_fd = GPOINTER_TO_UINT (GetStdHandle (STD_INPUT_HANDLE));
 901                 out_fd = GPOINTER_TO_UINT (GetStdHandle (STD_OUTPUT_HANDLE));
 902                 err_fd = GPOINTER_TO_UINT (GetStdHandle (STD_ERROR_HANDLE));
 903         }
 904
 905         g_strlcpy (process_handle.proc_name, prog,
 906                    _WAPI_PROC_NAME_MAX_LEN - 1);
 907
 908         process_set_defaults (&process_handle);
 909
 910         handle = _wapi_handle_new (WAPI_HANDLE_PROCESS, &process_handle);
 911         if (handle == _WAPI_HANDLE_INVALID) {
 912                 g_warning ("%s: error creating process handle", __func__);
 913
 914                 SetLastError (ERROR_PATH_NOT_FOUND);
 915                 goto cleanup;
 916         }
 917
 918         /* Hold another reference so the process has somewhere to
 919          * store its exit data even if we drop this handle
 920          */
 921         _wapi_handle_ref (handle);
 922
 923         /* new_environ is a block of NULL-terminated strings, which
 924          * is itself NULL-terminated. Of course, passing an array of
 925          * string pointers would have made things too easy :-(
 926          *
 927          * If new_environ is not NULL it specifies the entire set of
 928          * environment variables in the new process.  Otherwise the
 929          * new process inherits the same environment.
 930          */
 931         if (new_environ != NULL) {
 932                 gunichar2 *new_environp;
 933
 934                 /* Count the number of strings */
 935                 for (new_environp = (gunichar2 *)new_environ; *new_environp;
 936                      new_environp++) {
 937                         env_count++;
 938                         while (*new_environp) {
 939                                 new_environp++;
 940                         }
 941                 }
 942
 943                 /* +2: one for the process handle value, and the last
 944                  * one is NULL
 945                  */
 946                 env_strings = g_new0 (gchar *, env_count + 2);
 947
 948                 /* Copy each environ string into 'strings' turning it
 949                  * into utf8 (or the requested encoding) at the same
 950                  * time
 951                  */
 952                 env_count = 0;
 953                 for (new_environp = (gunichar2 *)new_environ; *new_environp;
 954                      new_environp++) {
 955                         env_strings[env_count] = mono_unicode_to_external (new_environp);
 956                         env_count++;
 957                         while (*new_environp) {
 958                                 new_environp++;
 959                         }
 960                 }
 961         } else {
 962                 for (i = 0; environ[i] != NULL; i++) {
 963                         env_count++;
 964                 }
 965
 966                 /* +2: one for the process handle value, and the last
 967                  * one is NULL
 968                  */
 969                 env_strings = g_new0 (gchar *, env_count + 2);
 970
 971                 /* Copy each environ string into 'strings' turning it
 972                  * into utf8 (or the requested encoding) at the same
 973                  * time
 974                  */
 975                 env_count = 0;
 976                 for (i = 0; environ[i] != NULL; i++) {
 977                         env_strings[env_count] = g_strdup (environ[i]);
 978                         env_count++;
 979                 }
 980         }
 981         /* pass process handle info to the child, so it doesn't have
 982          * to do an expensive search over the whole list
 983          */
 984         if (env_strings != NULL) {
 985                 struct _WapiHandleUnshared *handle_data;
 986                 struct _WapiHandle_shared_ref *ref;
 987
 988                 handle_data = &_WAPI_PRIVATE_HANDLES(GPOINTER_TO_UINT(handle));
 989                 ref = &handle_data->u.shared;
 990
 991                 env_strings[env_count] = g_strdup_printf ("_WAPI_PROCESS_HANDLE_OFFSET=%d", ref->offset);
 992         }
 993
 994         thr_ret = _wapi_handle_lock_shared_handles ();
 995         g_assert (thr_ret == 0);
 996
 997         pid = fork ();
 998         if (pid == -1) {
 999                 /* Error */
1000                 SetLastError (ERROR_OUTOFMEMORY);
1001                 _wapi_handle_unref (handle);
1002                 goto cleanup;
1003         } else if (pid == 0) {
1004                 /* Child */
1005
1006                 if (_wapi_shm_disabled == FALSE) {
1007                         /* Wait for the parent to finish setting up
1008                          * the handle.  The semaphore lock is safe
1009                          * because the sem_undo structures of a
1010                          * semaphore aren't inherited across a fork
1011                          * (), but we can't do this if we're not using
1012                          * the shared memory
1013                          */
1014                         thr_ret = _wapi_handle_lock_shared_handles ();
1015                         g_assert (thr_ret == 0);
1016
1017                         _wapi_handle_unlock_shared_handles ();
1018                 }
1019
1020                 /* should we detach from the process group? */
1021
1022                 /* Connect stdin, stdout and stderr */
1023                 dup2 (in_fd, 0);
1024                 dup2 (out_fd, 1);
1025                 dup2 (err_fd, 2);
1026
1027                 if (inherit_handles != TRUE) {
1028                         /* FIXME: do something here */
1029                 }
1030
1031                 /* Close all file descriptors */
1032                 for (i = getdtablesize () - 1; i > 2; i--) {
1033                         close (i);
1034                 }
1035
1036 #ifdef DEBUG
1037                 g_message ("%s: exec()ing [%s] in dir [%s]", __func__, cmd,
1038                            dir==NULL?".":dir);
1039                 for (i = 0; argv[i] != NULL; i++) {
1040                         g_message ("arg %d: [%s]", i, argv[i]);
1041                 }
1042
1043                 for (i = 0; env_strings[i] != NULL; i++) {
1044                         g_message ("env %d: [%s]", i, env_strings[i]);
1045                 }
1046 #endif
1047
1048                 /* set cwd */
1049                 if (dir != NULL && chdir (dir) == -1) {
1050                         /* set error */
1051                         _exit (-1);
1052                 }
1053
1054                 /* exec */
1055                 execve (argv[0], argv, env_strings);
1056
1057                 /* set error */
1058                 _exit (-1);
1059         }
1060         /* parent */
1061
1062         ret = _wapi_lookup_handle (handle, WAPI_HANDLE_PROCESS,
1063                                    (gpointer *)&process_handle_data);
1064         if (ret == FALSE) {
1065                 g_warning ("%s: error looking up process handle %p", __func__,
1066                            handle);
1067                 _wapi_handle_unref (handle);
1068                 goto cleanup;
1069         }
1070
1071         process_handle_data->id = pid;
1072
1073         if (process_info != NULL) {
1074                 process_info->hProcess = handle;
1075                 process_info->dwProcessId = pid;
1076
1077                 /* FIXME: we might need to handle the thread info some
1078                  * day
1079                  */
1080                 process_info->hThread = INVALID_HANDLE_VALUE;
1081                 process_info->dwThreadId = 0;
1082         }
1083
1084 cleanup:
1085         _wapi_handle_unlock_shared_handles ();
1086
1087         if (cmd != NULL) {
1088                 g_free (cmd);
1089         }
1090         if (full_prog != NULL) {
1091                 g_free (full_prog);
1092         }
1093         if (prog != NULL) {
1094                 g_free (prog);
1095         }
1096         if (args != NULL) {
1097                 g_free (args);
1098         }
1099         if (dir != NULL) {
1100                 g_free (dir);
1101         }
1102         if(env_strings != NULL) {
1103                 g_strfreev (env_strings);
1104         }
1105         if (argv != NULL) {
1106                 g_strfreev (argv);
1107         }
1108
1109 #ifdef DEBUG
1110         g_message ("%s: returning handle %p for pid %d", __func__, handle,
1111                    pid);
1112 #endif
1113
1114         return(ret);
1115 }
1116
1117 static void process_set_name (struct _WapiHandle_process *process_handle)
1118 {
1119         gchar *progname, *utf8_progname, *slash;
1120
1121         progname=g_get_prgname ();
1122         utf8_progname=mono_utf8_from_external (progname);
1123
1124 #ifdef DEBUG
1125         g_message ("%s: using [%s] as prog name", __func__, progname);
1126 #endif
1127
1128         if(utf8_progname!=NULL) {
1129                 slash=strrchr (utf8_progname, '/');
1130                 if(slash!=NULL) {
1131                         g_strlcpy (process_handle->proc_name, slash+1,
1132                                    _WAPI_PROC_NAME_MAX_LEN - 1);
1133                 } else {
1134                         g_strlcpy (process_handle->proc_name, utf8_progname,
1135                                    _WAPI_PROC_NAME_MAX_LEN - 1);
1136                 }
1137
1138                 g_free (utf8_progname);
1139         }
1140 }
1141
1142 extern void _wapi_time_t_to_filetime (time_t timeval, WapiFileTime *filetime);
1143
1144 #if !GLIB_CHECK_VERSION (2,4,0)
1145 #define g_setenv(a,b,c) setenv(a,b,c)
1146 #define g_unsetenv(a) unsetenv(a)
1147 #endif
1148
1149 static void process_set_current (void)
1150 {
1151         pid_t pid = _wapi_getpid ();
1152         const char *handle_env;
1153         struct _WapiHandle_process process_handle = {0};
1154
1155         mono_once (&process_ops_once, process_ops_init);
1156
1157         handle_env = g_getenv ("_WAPI_PROCESS_HANDLE_OFFSET");
1158         g_unsetenv ("_WAPI_PROCESS_HANDLE_OFFSET");
1159
1160         if (handle_env != NULL) {
1161                 struct _WapiHandle_process *process_handlep;
1162                 gchar *procname = NULL;
1163                 gboolean ok;
1164
1165                 current_process = _wapi_handle_new_from_offset (WAPI_HANDLE_PROCESS, atoi (handle_env), TRUE);
1166
1167 #ifdef DEBUG
1168                 g_message ("%s: Found my process handle: %p (offset %d 0x%x)",
1169                            __func__, current_process, atoi (handle_env),
1170                            atoi (handle_env));
1171 #endif
1172
1173                 ok = _wapi_lookup_handle (current_process, WAPI_HANDLE_PROCESS,
1174                                           (gpointer *)&process_handlep);
1175                 if (ok) {
1176                         /* This test will probably break on linuxthreads, but
1177                          * that should be ancient history on all distros we
1178                          * care about by now
1179                          */
1180                         if (process_handlep->id == pid) {
1181                                 procname = process_handlep->proc_name;
1182                                 if (!strcmp (procname, "mono")) {
1183                                         /* Set a better process name */
1184 #ifdef DEBUG
1185                                         g_message ("%s: Setting better process name", __func__);
1186 #endif
1187
1188                                         process_set_name (process_handlep);
1189                                 } else {
1190 #ifdef DEBUG
1191                                         g_message ("%s: Leaving process name: %s", __func__, procname);
1192 #endif
1193                                 }
1194
1195                                 return;
1196                         }
1197
1198                         /* Wrong pid, so drop this handle and fall through to
1199                          * create a new one
1200                          */
1201                         _wapi_handle_unref (current_process);
1202                 }
1203         }
1204
1205         /* We get here if the handle wasn't specified in the
1206          * environment, or if the process ID was wrong, or if the
1207          * handle lookup failed (eg if the parent process forked and
1208          * quit immediately, and deleted the shared data before the
1209          * child got a chance to attach it.)
1210          */
1211
1212 #ifdef DEBUG
1213         g_message ("%s: Need to create my own process handle", __func__);
1214 #endif
1215
1216         process_handle.id = pid;
1217
1218         process_set_defaults (&process_handle);
1219         process_set_name (&process_handle);
1220
1221         current_process = _wapi_handle_new (WAPI_HANDLE_PROCESS,
1222                                             &process_handle);
1223         if (current_process == _WAPI_HANDLE_INVALID) {
1224                 g_warning ("%s: error creating process handle", __func__);
1225                 return;
1226         }
1227 }
1228
1229 gpointer _wapi_process_duplicate ()
1230 {
1231         mono_once (&process_current_once, process_set_current);
1232
1233         _wapi_handle_ref (current_process);
1234
1235         return(current_process);
1236 }
1237
1238 /* Returns a pseudo handle that doesn't need to be closed afterwards */
1239 gpointer GetCurrentProcess (void)
1240 {
1241         mono_once (&process_current_once, process_set_current);
1242
1243         return(_WAPI_PROCESS_CURRENT);
1244 }
1245
1246 guint32 GetProcessId (gpointer handle)
1247 {
1248         struct _WapiHandle_process *process_handle;
1249         gboolean ok;
1250
1251         ok = _wapi_lookup_handle (handle, WAPI_HANDLE_PROCESS,
1252                                   (gpointer *)&process_handle);
1253         if (ok == FALSE) {
1254                 SetLastError (ERROR_INVALID_HANDLE);
1255                 return (0);
1256         }
1257
1258         return (process_handle->id);
1259 }
1260
1261 guint32 GetCurrentProcessId (void)
1262 {
1263         mono_once (&process_current_once, process_set_current);
1264
1265         return (GetProcessId (current_process));
1266 }
1267
1268 /* Returns the process id as a convenience to the functions that call this */
1269 static pid_t signal_process_if_gone (gpointer handle)
1270 {
1271         struct _WapiHandle_process *process_handle;
1272         gboolean ok;
1273
1274         /* Make sure the process is signalled if it has exited - if
1275          * the parent process didn't wait for it then it won't be
1276          */
1277         ok = _wapi_lookup_handle (handle, WAPI_HANDLE_PROCESS,
1278                                   (gpointer *)&process_handle);
1279         if (ok == FALSE) {
1280                 /* It's possible that the handle has vanished during
1281                  * the _wapi_search_handle before it gets here, so
1282                  * don't spam the console with warnings.
1283                  */
1284 /*              g_warning ("%s: error looking up process handle %p",
1285   __func__, handle);*/
1286
1287                 return (0);
1288         }
1289
1290 #ifdef DEBUG
1291         g_message ("%s: looking at process %d", __func__, process_handle->id);
1292 #endif
1293
1294         if (kill (process_handle->id, 0) == -1 &&
1295             (errno == ESRCH ||
1296              errno == EPERM)) {
1297                 /* The process is dead, (EPERM tells us a new process
1298                  * has that ID, but as it's owned by someone else it
1299                  * can't be the one listed in our shared memory file)
1300                  */
1301                 _wapi_shared_handle_set_signal_state (handle, TRUE);
1302         }
1303
1304         return (process_handle->id);
1305 }
1306
1307 static gboolean process_enum (gpointer handle, gpointer user_data)
1308 {
1309         GArray *processes=user_data;
1310         pid_t pid = signal_process_if_gone (handle);
1311         int i;
1312
1313         if (pid == 0) {
1314                 return (FALSE);
1315         }
1316
1317         /* Ignore processes that have already exited (ie they are signalled) */
1318         if (_wapi_handle_issignalled (handle) == FALSE) {
1319 #ifdef DEBUG
1320                 g_message ("%s: process %d added to array", __func__, pid);
1321 #endif
1322
1323                 /* This ensures that duplicates aren't returned (see
1324                  * the comment above _wapi_search_handle () for why
1325                  * it's needed
1326                  */
1327                 for (i = 0; i < processes->len; i++) {
1328                         if (g_array_index (processes, pid_t, i) == pid) {
1329                                 /* We've already got this one, return
1330                                  * FALSE to keep searching
1331                                  */
1332                                 return (FALSE);
1333                         }
1334                 }
1335
1336                 g_array_append_val (processes, pid);
1337         }
1338
1339         /* Return false to keep searching */
1340         return(FALSE);
1341 }
1342
1343 gboolean EnumProcesses (guint32 *pids, guint32 len, guint32 *needed)
1344 {
1345         GArray *processes = g_array_new (FALSE, FALSE, sizeof(pid_t));
1346         guint32 fit, i, j;
1347
1348         mono_once (&process_current_once, process_set_current);
1349
1350         _wapi_search_handle (WAPI_HANDLE_PROCESS, process_enum, processes,
1351                              NULL, TRUE);
1352
1353         fit=len/sizeof(guint32);
1354         for (i = 0, j = 0; j < fit && i < processes->len; i++) {
1355                 pids[j++] = g_array_index (processes, pid_t, i);
1356         }
1357
1358         g_array_free (processes, TRUE);
1359
1360         *needed = j * sizeof(guint32);
1361
1362         return(TRUE);
1363 }
1364
1365 static gboolean process_open_compare (gpointer handle, gpointer user_data)
1366 {
1367         pid_t wanted_pid;
1368         pid_t checking_pid = signal_process_if_gone (handle);
1369
1370         if (checking_pid == 0) {
1371                 return(FALSE);
1372         }
1373
1374         wanted_pid = GPOINTER_TO_UINT (user_data);
1375
1376         /* It's possible to have more than one process handle with the
1377          * same pid, but only the one running process can be
1378          * unsignalled
1379          */
1380         if (checking_pid == wanted_pid &&
1381             _wapi_handle_issignalled (handle) == FALSE) {
1382                 /* If the handle is blown away in the window between
1383                  * returning TRUE here and _wapi_search_handle pinging
1384                  * the timestamp, the search will continue
1385                  */
1386                 return(TRUE);
1387         } else {
1388                 return(FALSE);
1389         }
1390 }
1391
1392 gpointer OpenProcess (guint32 access G_GNUC_UNUSED, gboolean inherit G_GNUC_UNUSED, guint32 pid)
1393 {
1394         /* Find the process handle that corresponds to pid */
1395         gpointer handle;
1396
1397         mono_once (&process_current_once, process_set_current);
1398
1399 #ifdef DEBUG
1400         g_message ("%s: looking for process %d", __func__, pid);
1401 #endif
1402
1403         handle = _wapi_search_handle (WAPI_HANDLE_PROCESS,
1404                                       process_open_compare,
1405                                       GUINT_TO_POINTER (pid), NULL, TRUE);
1406         if (handle == 0) {
1407 #ifdef DEBUG
1408                 g_message ("%s: Can't find pid %d", __func__, pid);
1409 #endif
1410
1411                 SetLastError (ERROR_PROC_NOT_FOUND);
1412
1413                 return(NULL);
1414         }
1415
1416         _wapi_handle_ref (handle);
1417
1418         return(handle);
1419 }
1420
1421 gboolean GetExitCodeProcess (gpointer process, guint32 *code)
1422 {
1423         struct _WapiHandle_process *process_handle;
1424         gboolean ok;
1425
1426         mono_once (&process_current_once, process_set_current);
1427
1428         if(code==NULL) {
1429                 return(FALSE);
1430         }
1431
1432         ok=_wapi_lookup_handle (process, WAPI_HANDLE_PROCESS,
1433                                 (gpointer *)&process_handle);
1434         if(ok==FALSE) {
1435 #ifdef DEBUG
1436                 g_message ("%s: Can't find process %p", __func__, process);
1437 #endif
1438
1439                 return(FALSE);
1440         }
1441
1442         /* A process handle is only signalled if the process has exited
1443          * and has been waited for */
1444         if (_wapi_handle_issignalled (process) == TRUE ||
1445             process_wait (process, 0) == WAIT_OBJECT_0) {
1446                 *code = process_handle->exitstatus;
1447         } else {
1448                 *code = STILL_ACTIVE;
1449         }
1450
1451         return(TRUE);
1452 }
1453
1454 gboolean GetProcessTimes (gpointer process, WapiFileTime *create_time,
1455                           WapiFileTime *exit_time, WapiFileTime *kernel_time,
1456                           WapiFileTime *user_time)
1457 {
1458         struct _WapiHandle_process *process_handle;
1459         gboolean ok;
1460
1461         mono_once (&process_current_once, process_set_current);
1462
1463         if(create_time==NULL || exit_time==NULL || kernel_time==NULL ||
1464            user_time==NULL) {
1465                 /* Not sure if w32 allows NULLs here or not */
1466                 return(FALSE);
1467         }
1468
1469         ok=_wapi_lookup_handle (process, WAPI_HANDLE_PROCESS,
1470                                 (gpointer *)&process_handle);
1471         if(ok==FALSE) {
1472 #ifdef DEBUG
1473                 g_message ("%s: Can't find process %p", __func__, process);
1474 #endif
1475
1476                 return(FALSE);
1477         }
1478
1479         *create_time=process_handle->create_time;
1480
1481         /* A process handle is only signalled if the process has
1482          * exited.  Otherwise exit_time isn't set
1483          */
1484         if(_wapi_handle_issignalled (process)==TRUE) {
1485                 *exit_time=process_handle->exit_time;
1486         }
1487
1488         return(TRUE);
1489 }
1490
1491 gboolean EnumProcessModules (gpointer process, gpointer *modules,
1492                              guint32 size, guint32 *needed)
1493 {
1494         /* Store modules in an array of pointers (main module as
1495          * modules[0]), using the load address for each module as a
1496          * token.  (Use 'NULL' as an alternative for the main module
1497          * so that the simple implementation can just return one item
1498          * for now.)  Get the info from /proc/<pid>/maps on linux,
1499          * other systems will have to implement /dev/kmem reading or
1500          * whatever other horrid technique is needed.
1501          */
1502         if(size<sizeof(gpointer)) {
1503                 return(FALSE);
1504         }
1505
1506 #ifdef linux
1507         modules[0]=NULL;
1508         *needed=sizeof(gpointer);
1509 #else
1510         modules[0]=NULL;
1511         *needed=sizeof(gpointer);
1512 #endif
1513
1514         return(TRUE);
1515 }
1516
1517 guint32 GetModuleBaseName (gpointer process, gpointer module,
1518                            gunichar2 *basename, guint32 size)
1519 {
1520         struct _WapiHandle_process *process_handle;
1521         gboolean ok;
1522
1523         mono_once (&process_current_once, process_set_current);
1524
1525 #ifdef DEBUG
1526         g_message ("%s: Getting module base name, process handle %p module %p",
1527                    __func__, process, module);
1528 #endif
1529
1530         if(basename==NULL || size==0) {
1531                 return(FALSE);
1532         }
1533
1534         ok=_wapi_lookup_handle (process, WAPI_HANDLE_PROCESS,
1535                                 (gpointer *)&process_handle);
1536         if(ok==FALSE) {
1537 #ifdef DEBUG
1538                 g_message ("%s: Can't find process %p", __func__, process);
1539 #endif
1540
1541                 return(FALSE);
1542         }
1543
1544         if(module==NULL) {
1545                 /* Shorthand for the main module, which has the
1546                  * process name recorded in the handle data
1547                  */
1548                 pid_t pid;
1549                 gunichar2 *procname;
1550                 gchar *procname_utf8 = NULL;
1551                 glong len, bytes;
1552
1553 #ifdef DEBUG
1554                 g_message ("%s: Returning main module name", __func__);
1555 #endif
1556
1557                 pid=process_handle->id;
1558                 procname_utf8 = process_handle->proc_name;
1559
1560 #ifdef DEBUG
1561                 g_message ("%s: Process name is [%s]", __func__,
1562                            procname_utf8);
1563 #endif
1564
1565                 procname = g_utf8_to_utf16 (procname_utf8, -1, NULL, &len,
1566                                             NULL);
1567                 if (procname == NULL) {
1568                         /* bugger */
1569                         return(0);
1570                 }
1571
1572                 /* Add the terminator, and convert chars to bytes */
1573                 bytes = (len + 1) * 2;
1574
1575                 if (size < bytes) {
1576 #ifdef DEBUG
1577                         g_message ("%s: Size %d smaller than needed (%ld); truncating", __func__, size, bytes);
1578 #endif
1579
1580                         memcpy (basename, procname, size);
1581                 } else {
1582 #ifdef DEBUG
1583                         g_message ("%s: Size %d larger than needed (%ld)",
1584                                    __func__, size, bytes);
1585 #endif
1586
1587                         memcpy (basename, procname, bytes);
1588                 }
1589
1590                 g_free (procname);
1591
1592                 return(len);
1593         } else {
1594                 /* Look up the address in /proc/<pid>/maps */
1595         }
1596
1597         return(0);
1598 }
1599
1600 gboolean GetProcessWorkingSetSize (gpointer process, size_t *min, size_t *max)
1601 {
1602         struct _WapiHandle_process *process_handle;
1603         gboolean ok;
1604
1605         mono_once (&process_current_once, process_set_current);
1606
1607         if(min==NULL || max==NULL) {
1608                 /* Not sure if w32 allows NULLs here or not */
1609                 return(FALSE);
1610         }
1611
1612         ok=_wapi_lookup_handle (process, WAPI_HANDLE_PROCESS,
1613                                 (gpointer *)&process_handle);
1614         if(ok==FALSE) {
1615 #ifdef DEBUG
1616                 g_message ("%s: Can't find process %p", __func__, process);
1617 #endif
1618
1619                 return(FALSE);
1620         }
1621
1622         *min=process_handle->min_working_set;
1623         *max=process_handle->max_working_set;
1624
1625         return(TRUE);
1626 }
1627
1628 gboolean SetProcessWorkingSetSize (gpointer process, size_t min, size_t max)
1629 {
1630         struct _WapiHandle_process *process_handle;
1631         gboolean ok;
1632
1633         mono_once (&process_current_once, process_set_current);
1634
1635         ok=_wapi_lookup_handle (process, WAPI_HANDLE_PROCESS,
1636                                 (gpointer *)&process_handle);
1637         if(ok==FALSE) {
1638 #ifdef DEBUG
1639                 g_message ("%s: Can't find process %p", __func__, process);
1640 #endif
1641
1642                 return(FALSE);
1643         }
1644
1645         process_handle->min_working_set=min;
1646         process_handle->max_working_set=max;
1647
1648         return(TRUE);
1649 }
1650
1651
1652 gboolean
1653 TerminateProcess (gpointer process, gint32 exitCode)
1654 {
1655         struct _WapiHandle_process *process_handle;
1656         gboolean ok;
1657         int signo;
1658         int ret;
1659
1660         ok = _wapi_lookup_handle (process, WAPI_HANDLE_PROCESS,
1661                                   (gpointer *) &process_handle);
1662
1663         if (ok == FALSE) {
1664 #ifdef DEBUG
1665                 g_message ("%s: Can't find process %p", __func__, process);
1666 #endif
1667                 SetLastError (ERROR_INVALID_HANDLE);
1668                 return FALSE;
1669         }
1670
1671         signo = (exitCode == -1) ? SIGKILL : SIGTERM;
1672         ret = kill (process_handle->id, signo);
1673         if (ret == -1) {
1674                 switch (errno) {
1675                 case EINVAL:
1676                         SetLastError (ERROR_INVALID_PARAMETER);
1677                         break;
1678                 case EPERM:
1679                         SetLastError (ERROR_ACCESS_DENIED);
1680                         break;
1681                 case ESRCH:
1682                         SetLastError (ERROR_PROC_NOT_FOUND);
1683                         break;
1684                 default:
1685                         SetLastError (ERROR_GEN_FAILURE);
1686                 }
1687         }
1688
1689         return (ret == 0);
1690 }
1691