dlls/ntdll/unix/process.c

   1 /*
   2  * NT process handling
   3  *
   4  * Copyright 1996-1998 Marcus Meissner
   5  * Copyright 2018, 2020 Alexandre Julliard
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #if 0
  23 #pragma makedep unix
  24 #endif
  25
  26 #include "config.h"
  27 #include "wine/port.h"
  28
  29 #include <errno.h>
  30 #include <fcntl.h>
  31 #include <signal.h>
  32 #include <stdarg.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <time.h>
  37 #ifdef HAVE_SYS_SOCKET_H
  38 #include <sys/socket.h>
  39 #endif
  40 #ifdef HAVE_SYS_TIME_H
  41 # include <sys/time.h>
  42 #endif
  43 #ifdef HAVE_SYS_TIMES_H
  44 # include <sys/times.h>
  45 #endif
  46 #include <sys/types.h>
  47 #ifdef HAVE_SYS_WAIT_H
  48 # include <sys/wait.h>
  49 #endif
  50 #ifdef HAVE_UNISTD_H
  51 # include <unistd.h>
  52 #endif
  53 #ifdef __APPLE__
  54 # include <CoreFoundation/CoreFoundation.h>
  55 # include <pthread.h>
  56 #endif
  57 #ifdef HAVE_MACH_MACH_H
  58 # include <mach/mach.h>
  59 #endif
  60
  61 #include "ntstatus.h"
  62 #define WIN32_NO_STATUS
  63 #include "windef.h"
  64 #include "winternl.h"
  65 #include "unix_private.h"
  66 #include "wine/exception.h"
  67 #include "wine/server.h"
  68 #include "wine/debug.h"
  69
  70
  71 static char **build_argv( const UNICODE_STRING *cmdline, int reserved )
  72 {
  73     char **argv, *arg, *src, *dst;
  74     int argc, in_quotes = 0, bcount = 0, len = cmdline->Length / sizeof(WCHAR);
  75
  76     if (!(src = malloc( len * 3 + 1 ))) return NULL;
  77     len = ntdll_wcstoumbs( cmdline->Buffer, len, src, len * 3, FALSE );
  78     src[len++] = 0;
  79
  80     argc = reserved + 2 + len / 2;
  81     argv = malloc( argc * sizeof(*argv) + len );
  82     arg = dst = (char *)(argv + argc);
  83     argc = reserved;
  84     while (*src)
  85     {
  86         if ((*src == ' ' || *src == '\t') && !in_quotes)
  87         {
  88             /* skip the remaining spaces */
  89             while (*src == ' ' || *src == '\t') src++;
  90             if (!*src) break;
  91             /* close the argument and copy it */
  92             *dst++ = 0;
  93             argv[argc++] = arg;
  94             /* start with a new argument */
  95             arg = dst;
  96             bcount = 0;
  97         }
  98         else if (*src == '\\')
  99         {
 100             *dst++ = *src++;
 101             bcount++;
 102         }
 103         else if (*src == '"')
 104         {
 105             if ((bcount & 1) == 0)
 106             {
 107                 /* Preceded by an even number of '\', this is half that
 108                  * number of '\', plus a '"' which we discard.
 109                  */
 110                 dst -= bcount / 2;
 111                 src++;
 112                 if (in_quotes && *src == '"') *dst++ = *src++;
 113                 else in_quotes = !in_quotes;
 114             }
 115             else
 116             {
 117                 /* Preceded by an odd number of '\', this is half that
 118                  * number of '\' followed by a '"'
 119                  */
 120                 dst -= bcount / 2 + 1;
 121                 *dst++ = *src++;
 122             }
 123             bcount = 0;
 124         }
 125         else  /* a regular character */
 126         {
 127             *dst++ = *src++;
 128             bcount = 0;
 129         }
 130     }
 131     *dst = 0;
 132     argv[argc++] = arg;
 133     argv[argc] = NULL;
 134     return argv;
 135 }
 136
 137
 138 #ifdef __APPLE__
 139 /***********************************************************************
 140  *           terminate_main_thread
 141  *
 142  * On some versions of Mac OS X, the execve system call fails with
 143  * ENOTSUP if the process has multiple threads.  Wine is always multi-
 144  * threaded on Mac OS X because it specifically reserves the main thread
 145  * for use by the system frameworks (see apple_main_thread() in
 146  * libs/wine/loader.c).  So, when we need to exec without first forking,
 147  * we need to terminate the main thread first.  We do this by installing
 148  * a custom run loop source onto the main run loop and signaling it.
 149  * The source's "perform" callback is pthread_exit and it will be
 150  * executed on the main thread, terminating it.
 151  *
 152  * Returns TRUE if there's still hope the main thread has terminated or
 153  * will soon.  Return FALSE if we've given up.
 154  */
 155 static BOOL terminate_main_thread(void)
 156 {
 157     static int delayms;
 158
 159     if (!delayms)
 160     {
 161         CFRunLoopSourceContext source_context = { 0 };
 162         CFRunLoopSourceRef source;
 163
 164         source_context.perform = pthread_exit;
 165         if (!(source = CFRunLoopSourceCreate( NULL, 0, &source_context )))
 166             return FALSE;
 167
 168         CFRunLoopAddSource( CFRunLoopGetMain(), source, kCFRunLoopCommonModes );
 169         CFRunLoopSourceSignal( source );
 170         CFRunLoopWakeUp( CFRunLoopGetMain() );
 171         CFRelease( source );
 172
 173         delayms = 20;
 174     }
 175
 176     if (delayms > 1000)
 177         return FALSE;
 178
 179     usleep(delayms * 1000);
 180     delayms *= 2;
 181
 182     return TRUE;
 183 }
 184 #endif
 185
 186
 187 /***********************************************************************
 188  *           set_stdio_fd
 189  */
 190 static void set_stdio_fd( int stdin_fd, int stdout_fd )
 191 {
 192     int fd = -1;
 193
 194     if (stdin_fd == -1 || stdout_fd == -1)
 195     {
 196         fd = open( "/dev/null", O_RDWR );
 197         if (stdin_fd == -1) stdin_fd = fd;
 198         if (stdout_fd == -1) stdout_fd = fd;
 199     }
 200
 201     dup2( stdin_fd, 0 );
 202     dup2( stdout_fd, 1 );
 203     if (fd != -1) close( fd );
 204 }
 205
 206
 207 /***********************************************************************
 208  *           spawn_process
 209  */
 210 NTSTATUS CDECL spawn_process( const RTL_USER_PROCESS_PARAMETERS *params, int socketfd,
 211                               const char *unixdir, char *winedebug, const pe_image_info_t *pe_info )
 212 {
 213     const int is_child_64bit = (pe_info->cpu == CPU_x86_64 || pe_info->cpu == CPU_ARM64);
 214     NTSTATUS status = STATUS_SUCCESS;
 215     int stdin_fd = -1, stdout_fd = -1;
 216     pid_t pid;
 217     char **argv;
 218
 219     server_handle_to_fd( params->hStdInput, FILE_READ_DATA, &stdin_fd, NULL );
 220     server_handle_to_fd( params->hStdOutput, FILE_WRITE_DATA, &stdout_fd, NULL );
 221
 222     if (!(pid = fork()))  /* child */
 223     {
 224         if (!(pid = fork()))  /* grandchild */
 225         {
 226             if (params->ConsoleFlags ||
 227                 params->ConsoleHandle == (HANDLE)1 /* KERNEL32_CONSOLE_ALLOC */ ||
 228                 (params->hStdInput == INVALID_HANDLE_VALUE && params->hStdOutput == INVALID_HANDLE_VALUE))
 229             {
 230                 setsid();
 231                 set_stdio_fd( -1, -1 );  /* close stdin and stdout */
 232             }
 233             else set_stdio_fd( stdin_fd, stdout_fd );
 234
 235             if (stdin_fd != -1) close( stdin_fd );
 236             if (stdout_fd != -1) close( stdout_fd );
 237
 238             if (winedebug) putenv( winedebug );
 239             if (unixdir) chdir( unixdir );
 240
 241             argv = build_argv( &params->CommandLine, 2 );
 242
 243             exec_wineloader( argv, socketfd, is_child_64bit,
 244                              pe_info->base, pe_info->base + pe_info->map_size );
 245             _exit(1);
 246         }
 247
 248         _exit(pid == -1);
 249     }
 250
 251     if (pid != -1)
 252     {
 253         /* reap child */
 254         pid_t wret;
 255         do {
 256             wret = waitpid(pid, NULL, 0);
 257         } while (wret < 0 && errno == EINTR);
 258     }
 259     else status = STATUS_NO_MEMORY;
 260
 261     if (stdin_fd != -1) close( stdin_fd );
 262     if (stdout_fd != -1) close( stdout_fd );
 263     return status;
 264 }
 265
 266
 267 /***********************************************************************
 268  *           exec_process
 269  */
 270 NTSTATUS CDECL exec_process( const UNICODE_STRING *cmdline, const pe_image_info_t *pe_info )
 271 {
 272     const int is_child_64bit = (pe_info->cpu == CPU_x86_64 || pe_info->cpu == CPU_ARM64);
 273     NTSTATUS status;
 274     int socketfd[2];
 275     char **argv;
 276
 277     if (socketpair( PF_UNIX, SOCK_STREAM, 0, socketfd ) == -1) return STATUS_TOO_MANY_OPENED_FILES;
 278 #ifdef SO_PASSCRED
 279     else
 280     {
 281         int enable = 1;
 282         setsockopt( socketfd[0], SOL_SOCKET, SO_PASSCRED, &enable, sizeof(enable) );
 283     }
 284 #endif
 285     server_send_fd( socketfd[1] );
 286     close( socketfd[1] );
 287
 288     SERVER_START_REQ( exec_process )
 289     {
 290         req->socket_fd = socketfd[1];
 291         req->cpu       = pe_info->cpu;
 292         status = wine_server_call( req );
 293     }
 294     SERVER_END_REQ;
 295
 296     if (!status)
 297     {
 298         if (!(argv = build_argv( cmdline, 2 ))) return STATUS_NO_MEMORY;
 299         do
 300         {
 301             status = exec_wineloader( argv, socketfd[0], is_child_64bit,
 302                                       pe_info->base, pe_info->base + pe_info->map_size );
 303         }
 304 #ifdef __APPLE__
 305         while (errno == ENOTSUP && terminate_main_thread());
 306 #else
 307         while (0);
 308 #endif
 309         free( argv );
 310     }
 311     close( socketfd[0] );
 312     return status;
 313 }
 314
 315
 316 /***********************************************************************
 317  *           fork_and_exec
 318  *
 319  * Fork and exec a new Unix binary, checking for errors.
 320  */
 321 NTSTATUS CDECL fork_and_exec( const char *unix_name, const char *unix_dir,
 322                               const RTL_USER_PROCESS_PARAMETERS *params )
 323 {
 324     pid_t pid;
 325     int fd[2], stdin_fd = -1, stdout_fd = -1;
 326     char **argv, **envp;
 327     NTSTATUS status;
 328
 329 #ifdef HAVE_PIPE2
 330     if (pipe2( fd, O_CLOEXEC ) == -1)
 331 #endif
 332     {
 333         if (pipe(fd) == -1) return STATUS_TOO_MANY_OPENED_FILES;
 334         fcntl( fd[0], F_SETFD, FD_CLOEXEC );
 335         fcntl( fd[1], F_SETFD, FD_CLOEXEC );
 336     }
 337
 338     server_handle_to_fd( params->hStdInput, FILE_READ_DATA, &stdin_fd, NULL );
 339     server_handle_to_fd( params->hStdOutput, FILE_WRITE_DATA, &stdout_fd, NULL );
 340
 341     if (!(pid = fork()))  /* child */
 342     {
 343         if (!(pid = fork()))  /* grandchild */
 344         {
 345             close( fd[0] );
 346
 347             if (params->ConsoleFlags ||
 348                 params->ConsoleHandle == (HANDLE)1 /* KERNEL32_CONSOLE_ALLOC */ ||
 349                 (params->hStdInput == INVALID_HANDLE_VALUE && params->hStdOutput == INVALID_HANDLE_VALUE))
 350             {
 351                 setsid();
 352                 set_stdio_fd( -1, -1 );  /* close stdin and stdout */
 353             }
 354             else set_stdio_fd( stdin_fd, stdout_fd );
 355
 356             if (stdin_fd != -1) close( stdin_fd );
 357             if (stdout_fd != -1) close( stdout_fd );
 358
 359             /* Reset signals that we previously set to SIG_IGN */
 360             signal( SIGPIPE, SIG_DFL );
 361
 362             argv = build_argv( &params->CommandLine, 0 );
 363             envp = build_envp( params->Environment );
 364             if (unix_dir) chdir( unix_dir );
 365
 366             execve( unix_name, argv, envp );
 367         }
 368
 369         if (pid <= 0)  /* grandchild if exec failed or child if fork failed */
 370         {
 371             switch (errno)
 372             {
 373             case EPERM:
 374             case EACCES: status = STATUS_ACCESS_DENIED; break;
 375             case ENOENT: status = STATUS_OBJECT_NAME_NOT_FOUND; break;
 376             case EMFILE:
 377             case ENFILE: status = STATUS_TOO_MANY_OPENED_FILES; break;
 378             case ENOEXEC:
 379             case EINVAL: status = STATUS_INVALID_IMAGE_FORMAT; break;
 380             default:     status = STATUS_NO_MEMORY; break;
 381             }
 382             write( fd[1], &status, sizeof(status) );
 383             _exit(1);
 384         }
 385         _exit(0); /* child if fork succeeded */
 386     }
 387     close( fd[1] );
 388
 389     if (pid != -1)
 390     {
 391         /* reap child */
 392         pid_t wret;
 393         do {
 394             wret = waitpid(pid, NULL, 0);
 395         } while (wret < 0 && errno == EINTR);
 396         read( fd[0], &status, sizeof(status) );  /* if we read something, exec or second fork failed */
 397     }
 398     else status = STATUS_NO_MEMORY;
 399
 400     close( fd[0] );
 401     if (stdin_fd != -1) close( stdin_fd );
 402     if (stdout_fd != -1) close( stdout_fd );
 403     return status;
 404 }