dlls/msvcrt/process.c

   1 /*
   2  * msvcrt.dll spawn/exec functions
   3  *
   4  * Copyright 1996,1998 Marcus Meissner
   5  * Copyright 1996 Jukka Iivonen
   6  * Copyright 1997,2000 Uwe Bonnes
   7  * Copyright 2000 Jon Griffiths
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  *
  23  * FIXME:
  24  * -File handles need some special handling. Sometimes children get
  25  *  open file handles, sometimes not. The docs are confusing
  26  * -No check for maximum path/argument/environment size is done
  27  */
  28 #include "config.h"
  29
  30 #include <stdarg.h>
  31
  32 #include "msvcrt.h"
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  36
  37 /* INTERNAL: Spawn a child process */
  38 static MSVCRT_intptr_t msvcrt_spawn(int flags, const char* exe, char* cmdline, char* env)
  39 {
  40   STARTUPINFOA si;
  41   PROCESS_INFORMATION pi;
  42
  43   if ((unsigned)flags > MSVCRT__P_DETACH)
  44   {
  45     *MSVCRT__errno() = MSVCRT_EINVAL;
  46     return -1;
  47   }
  48
  49   memset(&si, 0, sizeof(si));
  50   si.cb = sizeof(si);
  51   msvcrt_create_io_inherit_block(&si);
  52   if (!CreateProcessA(exe, cmdline, NULL, NULL, TRUE,
  53                      flags == MSVCRT__P_DETACH ? DETACHED_PROCESS : 0,
  54                      env, NULL, &si, &pi))
  55   {
  56     msvcrt_set_errno(GetLastError());
  57     MSVCRT_free(si.lpReserved2);
  58     return -1;
  59   }
  60
  61   MSVCRT_free(si.lpReserved2);
  62   switch(flags)
  63   {
  64   case MSVCRT__P_WAIT:
  65     WaitForSingleObject(pi.hProcess, INFINITE);
  66     GetExitCodeProcess(pi.hProcess,&pi.dwProcessId);
  67     CloseHandle(pi.hProcess);
  68     CloseHandle(pi.hThread);
  69     return pi.dwProcessId;
  70   case MSVCRT__P_DETACH:
  71     CloseHandle(pi.hProcess);
  72     pi.hProcess = 0;
  73     /* fall through */
  74   case MSVCRT__P_NOWAIT:
  75   case MSVCRT__P_NOWAITO:
  76     CloseHandle(pi.hThread);
  77     return (MSVCRT_intptr_t)pi.hProcess;
  78   case  MSVCRT__P_OVERLAY:
  79     MSVCRT__exit(0);
  80   }
  81   return -1; /* can't reach here */
  82 }
  83
  84 /* INTERNAL: Convert argv list to a single 'delim'-separated string, with an
  85  * extra '\0' to terminate it
  86  */
  87 static char* msvcrt_argvtos(const char* const* arg, char delim)
  88 {
  89   const char* const* a;
  90   long size;
  91   char* p;
  92   char* ret;
  93
  94   if (!arg && !delim)
  95   {
  96       /* Return NULL for an empty environment list */
  97       return NULL;
  98   }
  99
 100   /* get length */
 101   a = arg;
 102   size = 0;
 103   while (*a)
 104   {
 105     size += strlen(*a) + 1;
 106     a++;
 107   }
 108
 109   ret = (char*)MSVCRT_malloc(size + 1);
 110   if (!ret)
 111     return NULL;
 112
 113   /* fill string */
 114   a = arg;
 115   p = ret;
 116   while (*a)
 117   {
 118     int len = strlen(*a);
 119     memcpy(p,*a,len);
 120     p += len;
 121     *p++ = delim;
 122     a++;
 123   }
 124   if (delim && p > ret) p[-1] = 0;
 125   else *p = 0;
 126   return ret;
 127 }
 128
 129 /* INTERNAL: Convert va_list to a single 'delim'-separated string, with an
 130  * extra '\0' to terminate it
 131  */
 132 static char* msvcrt_valisttos(const char* arg0, va_list alist, char delim)
 133 {
 134   va_list alist2;
 135   long size;
 136   const char *arg;
 137   char* p;
 138   char *ret;
 139
 140 #ifdef HAVE_VA_COPY
 141   va_copy(alist2,alist);
 142 #else
 143 # ifdef HAVE___VA_COPY
 144   __va_copy(alist2,alist);
 145 # else
 146   alist2 = alist;
 147 # endif
 148 #endif
 149
 150   if (!arg0 && !delim)
 151   {
 152       /* Return NULL for an empty environment list */
 153       return NULL;
 154   }
 155
 156   /* get length */
 157   arg = arg0;
 158   size = 0;
 159   do {
 160       size += strlen(arg) + 1;
 161       arg = va_arg(alist, char*);
 162   } while (arg != NULL);
 163
 164   ret = (char*)MSVCRT_malloc(size + 1);
 165   if (!ret)
 166     return NULL;
 167
 168   /* fill string */
 169   arg = arg0;
 170   p = ret;
 171   do {
 172       int len = strlen(arg);
 173       memcpy(p,arg,len);
 174       p += len;
 175       *p++ = delim;
 176       arg = va_arg(alist2, char*);
 177   } while (arg != NULL);
 178   if (delim && p > ret) p[-1] = 0;
 179   else *p = 0;
 180   return ret;
 181 }
 182
 183 /*********************************************************************
 184  *              _cwait (MSVCRT.@)
 185  */
 186 MSVCRT_intptr_t _cwait(int *status, MSVCRT_intptr_t pid, int action)
 187 {
 188   HANDLE hPid = (HANDLE)pid;
 189   int doserrno;
 190
 191   action = action; /* Remove warning */
 192
 193   if (!WaitForSingleObject(hPid, INFINITE))
 194   {
 195     if (status)
 196     {
 197       DWORD stat;
 198       GetExitCodeProcess(hPid, &stat);
 199       *status = (int)stat;
 200     }
 201     return pid;
 202   }
 203   doserrno = GetLastError();
 204
 205   if (doserrno == ERROR_INVALID_HANDLE)
 206   {
 207     *MSVCRT__errno() =  MSVCRT_ECHILD;
 208     *MSVCRT___doserrno() = doserrno;
 209   }
 210   else
 211     msvcrt_set_errno(doserrno);
 212
 213   return status ? *status = -1 : -1;
 214 }
 215
 216 /*********************************************************************
 217  *              _execl (MSVCRT.@)
 218  *
 219  * Like on Windows, this function does not handle arguments with spaces
 220  * or double-quotes.
 221  */
 222 MSVCRT_intptr_t _execl(const char* name, const char* arg0, ...)
 223 {
 224   va_list ap;
 225   char * args;
 226   MSVCRT_intptr_t ret;
 227
 228   va_start(ap, arg0);
 229   args = msvcrt_valisttos(arg0, ap, ' ');
 230   va_end(ap);
 231
 232   ret = msvcrt_spawn(MSVCRT__P_OVERLAY, name, args, NULL);
 233   MSVCRT_free(args);
 234
 235   return ret;
 236 }
 237
 238 /*********************************************************************
 239  *              _execle (MSVCRT.@)
 240  */
 241 MSVCRT_intptr_t _execle(const char* name, const char* arg0, ...)
 242 {
 243     FIXME("stub\n");
 244     return -1;
 245 }
 246
 247 /*********************************************************************
 248  *              _execlp (MSVCRT.@)
 249  *
 250  * Like on Windows, this function does not handle arguments with spaces
 251  * or double-quotes.
 252  */
 253 MSVCRT_intptr_t _execlp(const char* name, const char* arg0, ...)
 254 {
 255   va_list ap;
 256   char * args;
 257   MSVCRT_intptr_t ret;
 258   char fullname[MAX_PATH];
 259
 260   _searchenv(name, "PATH", fullname);
 261
 262   va_start(ap, arg0);
 263   args = msvcrt_valisttos(arg0, ap, ' ');
 264   va_end(ap);
 265
 266   ret = msvcrt_spawn(MSVCRT__P_OVERLAY, fullname[0] ? fullname : name, args, NULL);
 267   MSVCRT_free(args);
 268
 269   return ret;
 270 }
 271
 272 /*********************************************************************
 273  *              _execlpe (MSVCRT.@)
 274  */
 275 MSVCRT_intptr_t _execlpe(const char* name, const char* arg0, ...)
 276 {
 277     FIXME("stub\n");
 278     return -1;
 279 }
 280
 281 /*********************************************************************
 282  *              _execv (MSVCRT.@)
 283  *
 284  * Like on Windows, this function does not handle arguments with spaces
 285  * or double-quotes.
 286  */
 287 MSVCRT_intptr_t _execv(const char* name, char* const* argv)
 288 {
 289   return _spawnve(MSVCRT__P_OVERLAY, name, (const char* const*) argv, NULL);
 290 }
 291
 292 /*********************************************************************
 293  *              _execve (MSVCRT.@)
 294  *
 295  * Like on Windows, this function does not handle arguments with spaces
 296  * or double-quotes.
 297  */
 298 MSVCRT_intptr_t _execve(const char* name, char* const* argv, const char* const* envv)
 299 {
 300   return _spawnve(MSVCRT__P_OVERLAY, name, (const char* const*) argv, envv);
 301 }
 302
 303 /*********************************************************************
 304  *              _execvpe (MSVCRT.@)
 305  *
 306  * Like on Windows, this function does not handle arguments with spaces
 307  * or double-quotes.
 308  */
 309 MSVCRT_intptr_t _execvpe(const char* name, char* const* argv, const char* const* envv)
 310 {
 311   char fullname[MAX_PATH];
 312
 313   _searchenv(name, "PATH", fullname);
 314   return _spawnve(MSVCRT__P_OVERLAY, fullname[0] ? fullname : name,
 315                   (const char* const*) argv, envv);
 316 }
 317
 318 /*********************************************************************
 319  *              _execvp (MSVCRT.@)
 320  *
 321  * Like on Windows, this function does not handle arguments with spaces
 322  * or double-quotes.
 323  */
 324 MSVCRT_intptr_t _execvp(const char* name, char* const* argv)
 325 {
 326   return _execvpe(name, argv, NULL);
 327 }
 328
 329 /*********************************************************************
 330  *              _spawnl (MSVCRT.@)
 331  *
 332  * Like on Windows, this function does not handle arguments with spaces
 333  * or double-quotes.
 334  */
 335 MSVCRT_intptr_t _spawnl(int flags, const char* name, const char* arg0, ...)
 336 {
 337   va_list ap;
 338   char * args;
 339   MSVCRT_intptr_t ret;
 340
 341   va_start(ap, arg0);
 342   args = msvcrt_valisttos(arg0, ap, ' ');
 343   va_end(ap);
 344
 345   ret = msvcrt_spawn(flags, name, args, NULL);
 346   MSVCRT_free(args);
 347
 348   return ret;
 349 }
 350
 351 /*********************************************************************
 352  *              _spawnle (MSVCRT.@)
 353  */
 354 MSVCRT_intptr_t _spawnle(int flags, const char* name, const char* arg0, ...)
 355 {
 356     va_list ap;
 357     char *args, *envs = NULL;
 358     const char * const *envp;
 359     MSVCRT_intptr_t ret;
 360
 361     va_start(ap, arg0);
 362     args = msvcrt_valisttos(arg0, ap, ' ');
 363     va_end(ap);
 364
 365     va_start(ap, arg0);
 366     while (va_arg( ap, char * ) != NULL) /*nothing*/;
 367     envp = va_arg( ap, const char * const * );
 368     if (envp) envs = msvcrt_argvtos(envp, 0);
 369     va_end(ap);
 370
 371     ret = msvcrt_spawn(flags, name, args, envs);
 372
 373     MSVCRT_free(args);
 374     if (envs) MSVCRT_free(envs);
 375     return ret;
 376 }
 377
 378
 379 /*********************************************************************
 380  *              _spawnlp (MSVCRT.@)
 381  *
 382  * Like on Windows, this function does not handle arguments with spaces
 383  * or double-quotes.
 384  */
 385 MSVCRT_intptr_t _spawnlp(int flags, const char* name, const char* arg0, ...)
 386 {
 387   va_list ap;
 388   char * args;
 389   MSVCRT_intptr_t ret;
 390   char fullname[MAX_PATH];
 391
 392   _searchenv(name, "PATH", fullname);
 393
 394   va_start(ap, arg0);
 395   args = msvcrt_valisttos(arg0, ap, ' ');
 396   va_end(ap);
 397
 398   ret = msvcrt_spawn(flags, fullname[0] ? fullname : name, args, NULL);
 399   MSVCRT_free(args);
 400
 401   return ret;
 402 }
 403
 404 /*********************************************************************
 405  *              _spawnlpe (MSVCRT.@)
 406  */
 407 MSVCRT_intptr_t _spawnlpe(int flags, const char* name, const char* arg0, ...)
 408 {
 409     va_list ap;
 410     char *args, *envs = NULL;
 411     const char * const *envp;
 412     MSVCRT_intptr_t ret;
 413     char fullname[MAX_PATH];
 414
 415     _searchenv(name, "PATH", fullname);
 416
 417     va_start(ap, arg0);
 418     args = msvcrt_valisttos(arg0, ap, ' ');
 419     va_end(ap);
 420
 421     va_start(ap, arg0);
 422     while (va_arg( ap, char * ) != NULL) /*nothing*/;
 423     envp = va_arg( ap, const char * const * );
 424     if (envp) envs = msvcrt_argvtos(envp, 0);
 425     va_end(ap);
 426
 427     ret = msvcrt_spawn(flags, fullname[0] ? fullname : name, args, envs);
 428
 429     MSVCRT_free(args);
 430     if (envs) MSVCRT_free(envs);
 431     return ret;
 432 }
 433
 434 /*********************************************************************
 435  *              _spawnve (MSVCRT.@)
 436  *
 437  * Like on Windows, this function does not handle arguments with spaces
 438  * or double-quotes.
 439  */
 440 MSVCRT_intptr_t _spawnve(int flags, const char* name, const char* const* argv,
 441                             const char* const* envv)
 442 {
 443   char * args = msvcrt_argvtos(argv,' ');
 444   char * envs = msvcrt_argvtos(envv,0);
 445   const char *fullname = name;
 446   MSVCRT_intptr_t ret = -1;
 447
 448   FIXME(":not translating name %s to locate program\n",fullname);
 449   TRACE(":call (%s), params (%s), env (%s)\n",debugstr_a(name),debugstr_a(args),
 450    envs?"Custom":"Null");
 451
 452   if (args)
 453   {
 454     ret = msvcrt_spawn(flags, fullname, args, envs);
 455     MSVCRT_free(args);
 456   }
 457   if (envs)
 458     MSVCRT_free(envs);
 459
 460   return ret;
 461 }
 462
 463 /*********************************************************************
 464  *              _spawnv (MSVCRT.@)
 465  *
 466  * Like on Windows, this function does not handle arguments with spaces
 467  * or double-quotes.
 468  */
 469 MSVCRT_intptr_t _spawnv(int flags, const char* name, const char* const* argv)
 470 {
 471   return _spawnve(flags, name, argv, NULL);
 472 }
 473
 474 /*********************************************************************
 475  *              _spawnvpe (MSVCRT.@)
 476  *
 477  * Like on Windows, this function does not handle arguments with spaces
 478  * or double-quotes.
 479  */
 480 MSVCRT_intptr_t _spawnvpe(int flags, const char* name, const char* const* argv,
 481                             const char* const* envv)
 482 {
 483   char fullname[MAX_PATH];
 484   _searchenv(name, "PATH", fullname);
 485   return _spawnve(flags, fullname[0] ? fullname : name, argv, envv);
 486 }
 487
 488 /*********************************************************************
 489  *              _spawnvp (MSVCRT.@)
 490  *
 491  * Like on Windows, this function does not handle arguments with spaces
 492  * or double-quotes.
 493  */
 494 MSVCRT_intptr_t _spawnvp(int flags, const char* name, const char* const* argv)
 495 {
 496   return _spawnvpe(flags, name, argv, NULL);
 497 }
 498
 499 /*********************************************************************
 500  *              _popen (MSVCRT.@)
 501  * FIXME: convert to _wpopen and call that from here instead?  But it
 502  * would have to convert the command back to ANSI to call msvcrt_spawn,
 503  * less than ideal.
 504  */
 505 MSVCRT_FILE* MSVCRT__popen(const char* command, const char* mode)
 506 {
 507   static const char wcmd[] = "wcmd", cmdFlag[] = " /C ", comSpec[] = "COMSPEC";
 508   MSVCRT_FILE *ret;
 509   BOOL readPipe = TRUE;
 510   int textmode, fds[2], fdToDup, fdToOpen, fdStdHandle = -1, fdStdErr = -1;
 511   const char *p;
 512   char *cmdcopy;
 513   DWORD comSpecLen;
 514
 515   TRACE("(command=%s, mode=%s)\n", debugstr_a(command), debugstr_a(mode));
 516
 517   if (!command || !mode)
 518     return NULL;
 519
 520   textmode = *__p__fmode() & (MSVCRT__O_BINARY | MSVCRT__O_TEXT);
 521   for (p = mode; *p; p++)
 522   {
 523     switch (*p)
 524     {
 525       case 'W':
 526       case 'w':
 527         readPipe = FALSE;
 528         break;
 529       case 'B':
 530       case 'b':
 531         textmode |= MSVCRT__O_BINARY;
 532         textmode &= ~MSVCRT__O_TEXT;
 533         break;
 534       case 'T':
 535       case 't':
 536         textmode |= MSVCRT__O_TEXT;
 537         textmode &= ~MSVCRT__O_BINARY;
 538         break;
 539     }
 540   }
 541   if (_pipe(fds, 0, textmode) == -1)
 542     return NULL;
 543
 544   fdToDup = readPipe ? 1 : 0;
 545   fdToOpen = readPipe ? 0 : 1;
 546
 547   if ((fdStdHandle = _dup(fdToDup)) == -1)
 548     goto error;
 549   if (_dup2(fds[fdToDup], fdToDup) != 0)
 550     goto error;
 551   if (readPipe)
 552   {
 553     if ((fdStdErr = _dup(MSVCRT_STDERR_FILENO)) == -1)
 554       goto error;
 555     if (_dup2(fds[fdToDup], MSVCRT_STDERR_FILENO) != 0)
 556       goto error;
 557   }
 558
 559   _close(fds[fdToDup]);
 560
 561   comSpecLen = GetEnvironmentVariableA(comSpec, NULL, 0);
 562   if (!comSpecLen)
 563     comSpecLen = strlen(wcmd) + 1;
 564   cmdcopy = HeapAlloc(GetProcessHeap(), 0, comSpecLen + strlen(cmdFlag)
 565    + strlen(command));
 566   if (!GetEnvironmentVariableA(comSpec, cmdcopy, comSpecLen))
 567     strcpy(cmdcopy, wcmd);
 568   strcat(cmdcopy, cmdFlag);
 569   strcat(cmdcopy, command);
 570   if (msvcrt_spawn(MSVCRT__P_NOWAIT, NULL, cmdcopy, NULL) == -1)
 571   {
 572     _close(fds[fdToOpen]);
 573     ret = NULL;
 574   }
 575   else
 576   {
 577     ret = MSVCRT__fdopen(fds[fdToOpen], mode);
 578     if (!ret)
 579       _close(fds[fdToOpen]);
 580   }
 581   HeapFree(GetProcessHeap(), 0, cmdcopy);
 582   _dup2(fdStdHandle, fdToDup);
 583   _close(fdStdHandle);
 584   if (readPipe)
 585   {
 586     _dup2(fdStdErr, MSVCRT_STDERR_FILENO);
 587     _close(fdStdErr);
 588   }
 589   return ret;
 590
 591 error:
 592   if (fdStdHandle != -1) _close(fdStdHandle);
 593   if (fdStdErr != -1)    _close(fdStdErr);
 594   _close(fds[0]);
 595   _close(fds[1]);
 596   return NULL;
 597 }
 598
 599 /*********************************************************************
 600  *              _wpopen (MSVCRT.@)
 601  */
 602 MSVCRT_FILE* MSVCRT__wpopen(const MSVCRT_wchar_t* command, const MSVCRT_wchar_t* mode)
 603 {
 604   FIXME("(command=%s, mode=%s): stub\n", debugstr_w(command), debugstr_w(mode));
 605   return NULL;
 606 }
 607
 608 /*********************************************************************
 609  *              _pclose (MSVCRT.@)
 610  */
 611 int MSVCRT__pclose(MSVCRT_FILE* file)
 612 {
 613   return MSVCRT_fclose(file);
 614 }
 615
 616 /*********************************************************************
 617  *              system (MSVCRT.@)
 618  */
 619 int MSVCRT_system(const char* cmd)
 620 {
 621     char* cmdcopy;
 622     int res;
 623
 624     /* Make a writable copy for CreateProcess */
 625     cmdcopy=_strdup(cmd);
 626     /* FIXME: should probably launch cmd interpreter in COMSPEC */
 627     res=msvcrt_spawn(MSVCRT__P_WAIT, NULL, cmdcopy, NULL);
 628     MSVCRT_free(cmdcopy);
 629     return res;
 630 }
 631
 632 /*********************************************************************
 633  *              _loaddll (MSVCRT.@)
 634  */
 635 MSVCRT_intptr_t _loaddll(const char* dllname)
 636 {
 637   return (MSVCRT_intptr_t)LoadLibraryA(dllname);
 638 }
 639
 640 /*********************************************************************
 641  *              _unloaddll (MSVCRT.@)
 642  */
 643 int _unloaddll(MSVCRT_intptr_t dll)
 644 {
 645   if (FreeLibrary((HMODULE)dll))
 646     return 0;
 647   else
 648   {
 649     int err = GetLastError();
 650     msvcrt_set_errno(err);
 651     return err;
 652   }
 653 }
 654
 655 /*********************************************************************
 656  *              _getdllprocaddr (MSVCRT.@)
 657  */
 658 void *_getdllprocaddr(MSVCRT_intptr_t dll, const char *name, int ordinal)
 659 {
 660     if (name)
 661     {
 662         if (ordinal != -1) return NULL;
 663         return GetProcAddress( (HMODULE)dll, name );
 664     }
 665     if (HIWORD(ordinal)) return NULL;
 666     return GetProcAddress( (HMODULE)dll, (LPCSTR)(ULONG_PTR)ordinal );
 667 }