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  * Copyright 2007 Hans Leidekker
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  *
  24  * FIXME:
  25  * -File handles need some special handling. Sometimes children get
  26  *  open file handles, sometimes not. The docs are confusing
  27  * -No check for maximum path/argument/environment size is done
  28  */
  29
  30 #include <fcntl.h>
  31 #include <io.h>
  32 #include <process.h>
  33 #include <stdarg.h>
  34
  35 #include "msvcrt.h"
  36 #include <winnls.h>
  37 #include "mtdll.h"
  38 #include "wine/debug.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  41
  42 static void msvcrt_search_executable(const wchar_t *name, wchar_t *fullname, int use_path)
  43 {
  44   static const wchar_t suffix[][5] =
  45     {L".com", L".exe", L".bat", L".cmd"};
  46
  47   wchar_t buffer[MAX_PATH];
  48   const wchar_t *env, *p, *end;
  49   unsigned int i, name_len, path_len;
  50   int extension = 1;
  51
  52   *fullname = '\0';
  53   msvcrt_set_errno(ERROR_FILE_NOT_FOUND);
  54
  55   end = name + MAX_PATH - 1;
  56   for(p = name; p < end; p++)
  57       if(!*p) break;
  58   name_len = p - name;
  59
  60   /* FIXME extra-long names are silently truncated */
  61   memcpy(buffer, name, name_len * sizeof(wchar_t));
  62   buffer[name_len] = '\0';
  63
  64   /* try current dir first */
  65   if (GetFileAttributesW(buffer) != INVALID_FILE_ATTRIBUTES)
  66   {
  67     wcscpy(fullname, buffer);
  68     return;
  69   }
  70
  71   for (p--; p >= name; p--)
  72     if (*p == '\\' || *p == '/' || *p == ':' || *p == '.') break;
  73
  74   /* if there's no extension, try some well-known extensions */
  75   if ((p < name || *p != '.') && name_len <= MAX_PATH - 5)
  76   {
  77     for (i = 0; i < 4; i++)
  78     {
  79       memcpy(buffer + name_len, suffix[i], 5 * sizeof(wchar_t));
  80       if (GetFileAttributesW(buffer) != INVALID_FILE_ATTRIBUTES)
  81       {
  82         wcscpy(fullname, buffer);
  83         return;
  84       }
  85     }
  86     extension = 0;
  87   }
  88
  89   if (!use_path || !(env = _wgetenv(L"PATH"))) return;
  90
  91   /* now try search path */
  92   do
  93   {
  94     p = env;
  95     while (*p && *p != ';') p++;
  96     if (p == env) return;
  97
  98     path_len = p - env;
  99     if (path_len + name_len <= MAX_PATH - 2)
 100     {
 101       memcpy(buffer, env, path_len * sizeof(wchar_t));
 102       if (buffer[path_len] != '/' && buffer[path_len] != '\\')
 103       {
 104         buffer[path_len++] = '\\';
 105         buffer[path_len] = '\0';
 106       }
 107       else buffer[path_len] = '\0';
 108
 109       wcscat(buffer, name);
 110       if (GetFileAttributesW(buffer) != INVALID_FILE_ATTRIBUTES)
 111       {
 112         wcscpy(fullname, buffer);
 113         return;
 114       }
 115     }
 116     /* again, if there's no extension, try some well-known extensions */
 117     if (!extension && path_len + name_len <= MAX_PATH - 5)
 118     {
 119       for (i = 0; i < 4; i++)
 120       {
 121         memcpy(buffer + path_len + name_len, suffix[i], 5 * sizeof(wchar_t));
 122         if (GetFileAttributesW(buffer) != INVALID_FILE_ATTRIBUTES)
 123         {
 124           wcscpy(fullname, buffer);
 125           return;
 126         }
 127       }
 128     }
 129     env = *p ? p + 1 : p;
 130   } while(1);
 131 }
 132
 133 static intptr_t msvcrt_spawn(int flags, const wchar_t* exe, wchar_t* cmdline,
 134                                     wchar_t* env, int use_path)
 135 {
 136   STARTUPINFOW si;
 137   PROCESS_INFORMATION pi;
 138   wchar_t fullname[MAX_PATH];
 139   DWORD create_flags = CREATE_UNICODE_ENVIRONMENT;
 140
 141   TRACE("%x %s %s %s %d\n", flags, debugstr_w(exe), debugstr_w(cmdline), debugstr_w(env), use_path);
 142
 143   if ((unsigned)flags > _P_DETACH)
 144   {
 145     *_errno() = EINVAL;
 146     return -1;
 147   }
 148
 149   msvcrt_search_executable(exe, fullname, use_path);
 150
 151   memset(&si, 0, sizeof(si));
 152   si.cb = sizeof(si);
 153   msvcrt_create_io_inherit_block(&si.cbReserved2, &si.lpReserved2);
 154   if (flags == _P_DETACH) create_flags |= DETACHED_PROCESS;
 155   if (!CreateProcessW(fullname, cmdline, NULL, NULL, TRUE,
 156                       create_flags, env, NULL, &si, &pi))
 157   {
 158     msvcrt_set_errno(GetLastError());
 159     free(si.lpReserved2);
 160     return -1;
 161   }
 162
 163   free(si.lpReserved2);
 164   switch(flags)
 165   {
 166   case _P_WAIT:
 167     WaitForSingleObject(pi.hProcess, INFINITE);
 168     GetExitCodeProcess(pi.hProcess,&pi.dwProcessId);
 169     CloseHandle(pi.hProcess);
 170     CloseHandle(pi.hThread);
 171     return pi.dwProcessId;
 172   case _P_DETACH:
 173     CloseHandle(pi.hProcess);
 174     pi.hProcess = 0;
 175     /* fall through */
 176   case _P_NOWAIT:
 177   case _P_NOWAITO:
 178     CloseHandle(pi.hThread);
 179     return (intptr_t)pi.hProcess;
 180   case  _P_OVERLAY:
 181     _exit(0);
 182   }
 183   return -1; /* can't reach here */
 184 }
 185
 186 /* INTERNAL: Convert wide argv list to a single 'delim'-separated wide string, with an
 187  * extra '\0' to terminate it.
 188  */
 189 static wchar_t* msvcrt_argvtos(const wchar_t* const* arg, wchar_t delim)
 190 {
 191   const wchar_t* const* a;
 192   int size;
 193   wchar_t* p;
 194   wchar_t* ret;
 195
 196   if (!arg)
 197   {
 198       /* Return NULL for an empty environment list */
 199       return NULL;
 200   }
 201
 202   /* get length */
 203   a = arg;
 204   size = 0;
 205   while (*a)
 206   {
 207     size += wcslen(*a) + 1;
 208     a++;
 209   }
 210
 211   ret = malloc((size + 1) * sizeof(wchar_t));
 212   if (!ret)
 213     return NULL;
 214
 215   /* fill string */
 216   a = arg;
 217   p = ret;
 218   while (*a)
 219   {
 220     int len = wcslen(*a);
 221     memcpy(p,*a,len * sizeof(wchar_t));
 222     p += len;
 223     *p++ = delim;
 224     a++;
 225   }
 226   if (delim && p > ret) p[-1] = 0;
 227   else *p = 0;
 228   return ret;
 229 }
 230
 231 /* INTERNAL: Convert ansi argv list to a single 'delim'-separated wide string, with an
 232  * extra '\0' to terminate it.
 233  */
 234 static wchar_t *msvcrt_argvtos_aw(const char * const *arg, wchar_t delim)
 235 {
 236   const char * const *a;
 237   unsigned int len;
 238   wchar_t *p, *ret;
 239
 240   if (!arg)
 241   {
 242       /* Return NULL for an empty environment list */
 243       return NULL;
 244   }
 245
 246   /* get length */
 247   a = arg;
 248   len = 0;
 249   while (*a)
 250   {
 251     len += MultiByteToWideChar(CP_ACP, 0, *a, -1, NULL, 0);
 252     a++;
 253   }
 254
 255   ret = malloc((len + 1) * sizeof(wchar_t));
 256   if (!ret)
 257     return NULL;
 258
 259   /* fill string */
 260   a = arg;
 261   p = ret;
 262   while (*a)
 263   {
 264     p += MultiByteToWideChar(CP_ACP, 0, *a, strlen(*a), p, len - (p - ret));
 265     *p++ = delim;
 266     a++;
 267   }
 268   if (delim && p > ret) p[-1] = 0;
 269   else *p = 0;
 270   return ret;
 271 }
 272
 273 /* INTERNAL: Convert wide va_list to a single 'delim'-separated wide string, with an
 274  * extra '\0' to terminate it.
 275  */
 276 static wchar_t *msvcrt_valisttos(const wchar_t *arg0, va_list alist, wchar_t delim)
 277 {
 278     unsigned int size = 0, pos = 0;
 279     const wchar_t *arg;
 280     wchar_t *new, *ret = NULL;
 281
 282     for (arg = arg0; arg; arg = va_arg( alist, wchar_t * ))
 283     {
 284         unsigned int len = wcslen( arg ) + 1;
 285         if (pos + len >= size)
 286         {
 287             size = max( 256, size * 2 );
 288             size = max( size, pos + len + 1 );
 289             if (!(new = realloc( ret, size * sizeof(wchar_t) )))
 290             {
 291                 free( ret );
 292                 return NULL;
 293             }
 294             ret = new;
 295         }
 296         wcscpy( ret + pos, arg );
 297         pos += len;
 298         ret[pos - 1] = delim;
 299     }
 300     if (pos)
 301     {
 302         if (delim) ret[pos - 1] = 0;
 303         else ret[pos] = 0;
 304     }
 305     return ret;
 306 }
 307
 308 /* INTERNAL: Convert ansi va_list to a single 'delim'-separated wide string, with an
 309  * extra '\0' to terminate it.
 310  */
 311 static wchar_t *msvcrt_valisttos_aw(const char *arg0, va_list alist, wchar_t delim)
 312 {
 313     unsigned int size = 0, pos = 0;
 314     const char *arg;
 315     wchar_t *new, *ret = NULL;
 316
 317     for (arg = arg0; arg; arg = va_arg( alist, char * ))
 318     {
 319         unsigned int len = MultiByteToWideChar( CP_ACP, 0, arg, -1, NULL, 0 );
 320         if (pos + len >= size)
 321         {
 322             size = max( 256, size * 2 );
 323             size = max( size, pos + len + 1 );
 324             if (!(new = realloc( ret, size * sizeof(wchar_t) )))
 325             {
 326                 free( ret );
 327                 return NULL;
 328             }
 329             ret = new;
 330         }
 331         pos += MultiByteToWideChar( CP_ACP, 0, arg, -1, ret + pos, size - pos );
 332         ret[pos - 1] = delim;
 333     }
 334     if (pos)
 335     {
 336         if (delim) ret[pos - 1] = 0;
 337         else ret[pos] = 0;
 338     }
 339     return ret;
 340 }
 341
 342 /* INTERNAL: retrieve COMSPEC environment variable */
 343 static wchar_t *msvcrt_get_comspec(void)
 344 {
 345   wchar_t *ret;
 346   unsigned int len;
 347
 348   if (!(len = GetEnvironmentVariableW(L"COMSPEC", NULL, 0))) len = 4;
 349   if ((ret = HeapAlloc(GetProcessHeap(), 0, len * sizeof(wchar_t))))
 350   {
 351     if (!GetEnvironmentVariableW(L"COMSPEC", ret, len)) wcscpy(ret, L"cmd");
 352   }
 353   return ret;
 354 }
 355
 356 /*********************************************************************
 357  *              _cwait (MSVCRT.@)
 358  */
 359 intptr_t CDECL _cwait(int *status, intptr_t pid, int action)
 360 {
 361   HANDLE hPid = (HANDLE)pid;
 362   int doserrno;
 363
 364   if (!WaitForSingleObject(hPid, INFINITE))
 365   {
 366     if (status)
 367     {
 368       DWORD stat;
 369       GetExitCodeProcess(hPid, &stat);
 370       *status = (int)stat;
 371     }
 372     return pid;
 373   }
 374   doserrno = GetLastError();
 375
 376   if (doserrno == ERROR_INVALID_HANDLE)
 377   {
 378     *_errno() =  ECHILD;
 379     *__doserrno() = doserrno;
 380   }
 381   else
 382     msvcrt_set_errno(doserrno);
 383
 384   return status ? *status = -1 : -1;
 385 }
 386
 387 /*********************************************************************
 388  *      _wexecl (MSVCRT.@)
 389  *
 390  * Unicode version of _execl
 391  */
 392 intptr_t WINAPIV _wexecl(const wchar_t* name, const wchar_t* arg0, ...)
 393 {
 394   va_list ap;
 395   wchar_t *args;
 396   intptr_t ret;
 397
 398   va_start(ap, arg0);
 399   args = msvcrt_valisttos(arg0, ap, ' ');
 400   va_end(ap);
 401
 402   ret = msvcrt_spawn(_P_OVERLAY, name, args, NULL, 0);
 403
 404   free(args);
 405   return ret;
 406 }
 407
 408 /*********************************************************************
 409  *              _execl (MSVCRT.@)
 410  *
 411  * Like on Windows, this function does not handle arguments with spaces
 412  * or double-quotes.
 413  */
 414 intptr_t WINAPIV _execl(const char* name, const char* arg0, ...)
 415 {
 416   va_list ap;
 417   wchar_t *nameW, *args;
 418   intptr_t ret;
 419
 420   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 421
 422   va_start(ap, arg0);
 423   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 424   va_end(ap);
 425
 426   ret = msvcrt_spawn(_P_OVERLAY, nameW, args, NULL, 0);
 427
 428   free(nameW);
 429   free(args);
 430   return ret;
 431 }
 432
 433 /*********************************************************************
 434  *      _wexecle (MSVCRT.@)
 435  *
 436  * Unicode version of _execle
 437  */
 438 intptr_t WINAPIV _wexecle(const wchar_t* name, const wchar_t* arg0, ...)
 439 {
 440   va_list ap;
 441   wchar_t *args, *envs = NULL;
 442   const wchar_t * const *envp;
 443   intptr_t ret;
 444
 445   va_start(ap, arg0);
 446   args = msvcrt_valisttos(arg0, ap, ' ');
 447   va_end(ap);
 448
 449   va_start(ap, arg0);
 450   while (va_arg( ap, wchar_t * ) != NULL) /*nothing*/;
 451   envp = va_arg( ap, const wchar_t * const * );
 452   if (envp) envs = msvcrt_argvtos(envp, 0);
 453   va_end(ap);
 454
 455   ret = msvcrt_spawn(_P_OVERLAY, name, args, envs, 0);
 456
 457   free(args);
 458   free(envs);
 459   return ret;
 460 }
 461
 462 /*********************************************************************
 463  *              _execle (MSVCRT.@)
 464  */
 465 intptr_t WINAPIV _execle(const char* name, const char* arg0, ...)
 466 {
 467   va_list ap;
 468   wchar_t *nameW, *args, *envs = NULL;
 469   const char * const *envp;
 470   intptr_t ret;
 471
 472   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 473
 474   va_start(ap, arg0);
 475   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 476   va_end(ap);
 477
 478   va_start(ap, arg0);
 479   while (va_arg( ap, char * ) != NULL) /*nothing*/;
 480   envp = va_arg( ap, const char * const * );
 481   if (envp) envs = msvcrt_argvtos_aw(envp, 0);
 482   va_end(ap);
 483
 484   ret = msvcrt_spawn(_P_OVERLAY, nameW, args, envs, 0);
 485
 486   free(nameW);
 487   free(args);
 488   free(envs);
 489   return ret;
 490 }
 491
 492 /*********************************************************************
 493  *      _wexeclp (MSVCRT.@)
 494  *
 495  * Unicode version of _execlp
 496  */
 497 intptr_t WINAPIV _wexeclp(const wchar_t* name, const wchar_t* arg0, ...)
 498 {
 499   va_list ap;
 500   wchar_t *args;
 501   intptr_t ret;
 502
 503   va_start(ap, arg0);
 504   args = msvcrt_valisttos(arg0, ap, ' ');
 505   va_end(ap);
 506
 507   ret = msvcrt_spawn(_P_OVERLAY, name, args, NULL, 1);
 508
 509   free(args);
 510   return ret;
 511 }
 512
 513 /*********************************************************************
 514  *              _execlp (MSVCRT.@)
 515  *
 516  * Like on Windows, this function does not handle arguments with spaces
 517  * or double-quotes.
 518  */
 519 intptr_t WINAPIV _execlp(const char* name, const char* arg0, ...)
 520 {
 521   va_list ap;
 522   wchar_t *nameW, *args;
 523   intptr_t ret;
 524
 525   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 526
 527   va_start(ap, arg0);
 528   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 529   va_end(ap);
 530
 531   ret = msvcrt_spawn(_P_OVERLAY, nameW, args, NULL, 1);
 532
 533   free(nameW);
 534   free(args);
 535   return ret;
 536 }
 537
 538 /*********************************************************************
 539  *      _wexeclpe (MSVCRT.@)
 540  *
 541  * Unicode version of _execlpe
 542  */
 543 intptr_t WINAPIV _wexeclpe(const wchar_t* name, const wchar_t* arg0, ...)
 544 {
 545   va_list ap;
 546   wchar_t *args, *envs = NULL;
 547   const wchar_t * const *envp;
 548   intptr_t ret;
 549
 550   va_start(ap, arg0);
 551   args = msvcrt_valisttos(arg0, ap, ' ');
 552   va_end(ap);
 553
 554   va_start(ap, arg0);
 555   while (va_arg( ap, wchar_t * ) != NULL) /*nothing*/;
 556   envp = va_arg( ap, const wchar_t * const * );
 557   if (envp) envs = msvcrt_argvtos(envp, 0);
 558   va_end(ap);
 559
 560   ret = msvcrt_spawn(_P_OVERLAY, name, args, envs, 1);
 561
 562   free(args);
 563   free(envs);
 564   return ret;
 565 }
 566
 567 /*********************************************************************
 568  *              _execlpe (MSVCRT.@)
 569  */
 570 intptr_t WINAPIV _execlpe(const char* name, const char* arg0, ...)
 571 {
 572   va_list ap;
 573   wchar_t *nameW, *args, *envs = NULL;
 574   const char * const *envp;
 575   intptr_t ret;
 576
 577   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 578
 579   va_start(ap, arg0);
 580   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 581   va_end(ap);
 582
 583   va_start(ap, arg0);
 584   while (va_arg( ap, char * ) != NULL) /*nothing*/;
 585   envp = va_arg( ap, const char * const * );
 586   if (envp) envs = msvcrt_argvtos_aw(envp, 0);
 587   va_end(ap);
 588
 589   ret = msvcrt_spawn(_P_OVERLAY, nameW, args, envs, 1);
 590
 591   free(nameW);
 592   free(args);
 593   free(envs);
 594   return ret;
 595 }
 596
 597 /*********************************************************************
 598  *      _wexecv (MSVCRT.@)
 599  *
 600  * Unicode version of _execv
 601  */
 602 intptr_t CDECL _wexecv(const wchar_t* name, const wchar_t* const* argv)
 603 {
 604   return _wspawnve(_P_OVERLAY, name, argv, NULL);
 605 }
 606
 607 /*********************************************************************
 608  *              _execv (MSVCRT.@)
 609  *
 610  * Like on Windows, this function does not handle arguments with spaces
 611  * or double-quotes.
 612  */
 613 intptr_t CDECL _execv(const char* name, const char* const* argv)
 614 {
 615   return _spawnve(_P_OVERLAY, name, argv, NULL);
 616 }
 617
 618 /*********************************************************************
 619  *      _wexecve (MSVCRT.@)
 620  *
 621  * Unicode version of _execve
 622  */
 623 intptr_t CDECL _wexecve(const wchar_t* name, const wchar_t* const* argv, const wchar_t* const* envv)
 624 {
 625   return _wspawnve(_P_OVERLAY, name, argv, envv);
 626 }
 627
 628 /*********************************************************************
 629  *              _execve (MSVCRT.@)
 630  *
 631  * Like on Windows, this function does not handle arguments with spaces
 632  * or double-quotes.
 633  */
 634 intptr_t CDECL _execve(const char* name, const char* const* argv, const char* const* envv)
 635 {
 636   return _spawnve(_P_OVERLAY, name, argv, envv);
 637 }
 638
 639 /*********************************************************************
 640  *      _wexecvpe (MSVCRT.@)
 641  *
 642  * Unicode version of _execvpe
 643  */
 644 intptr_t CDECL _wexecvpe(const wchar_t* name, const wchar_t* const* argv, const wchar_t* const* envv)
 645 {
 646   return _wspawnvpe(_P_OVERLAY, name, argv, envv);
 647 }
 648
 649 /*********************************************************************
 650  *              _execvpe (MSVCRT.@)
 651  *
 652  * Like on Windows, this function does not handle arguments with spaces
 653  * or double-quotes.
 654  */
 655 intptr_t CDECL _execvpe(const char* name, const char* const* argv, const char* const* envv)
 656 {
 657   return _spawnvpe(_P_OVERLAY, name, argv, envv);
 658 }
 659
 660 /*********************************************************************
 661  *      _wexecvp (MSVCRT.@)
 662  *
 663  * Unicode version of _execvp
 664  */
 665 intptr_t CDECL _wexecvp(const wchar_t* name, const wchar_t* const* argv)
 666 {
 667   return _wexecvpe(name, argv, NULL);
 668 }
 669
 670 /*********************************************************************
 671  *              _execvp (MSVCRT.@)
 672  *
 673  * Like on Windows, this function does not handle arguments with spaces
 674  * or double-quotes.
 675  */
 676 intptr_t CDECL _execvp(const char* name, const char* const* argv)
 677 {
 678   return _execvpe(name, argv, NULL);
 679 }
 680
 681 /*********************************************************************
 682  *      _wspawnl (MSVCRT.@)
 683  *
 684  * Unicode version of _spawnl
 685  */
 686 intptr_t WINAPIV _wspawnl(int flags, const wchar_t* name, const wchar_t* arg0, ...)
 687 {
 688   va_list ap;
 689   wchar_t *args;
 690   intptr_t ret;
 691
 692   va_start(ap, arg0);
 693   args = msvcrt_valisttos(arg0, ap, ' ');
 694   va_end(ap);
 695
 696   ret = msvcrt_spawn(flags, name, args, NULL, 0);
 697
 698   free(args);
 699   return ret;
 700 }
 701
 702 /*********************************************************************
 703  *              _spawnl (MSVCRT.@)
 704  *
 705  * Like on Windows, this function does not handle arguments with spaces
 706  * or double-quotes.
 707  */
 708 intptr_t WINAPIV _spawnl(int flags, const char* name, const char* arg0, ...)
 709 {
 710   va_list ap;
 711   wchar_t *nameW, *args;
 712   intptr_t ret;
 713
 714   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 715
 716   va_start(ap, arg0);
 717   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 718   va_end(ap);
 719
 720   ret = msvcrt_spawn(flags, nameW, args, NULL, 0);
 721
 722   free(nameW);
 723   free(args);
 724   return ret;
 725 }
 726
 727 /*********************************************************************
 728  *      _wspawnle (MSVCRT.@)
 729  *
 730  * Unicode version of _spawnle
 731  */
 732 intptr_t WINAPIV _wspawnle(int flags, const wchar_t* name, const wchar_t* arg0, ...)
 733 {
 734   va_list ap;
 735   wchar_t *args, *envs = NULL;
 736   const wchar_t * const *envp;
 737   intptr_t ret;
 738
 739   va_start(ap, arg0);
 740   args = msvcrt_valisttos(arg0, ap, ' ');
 741   va_end(ap);
 742
 743   va_start(ap, arg0);
 744   while (va_arg( ap, wchar_t * ) != NULL) /*nothing*/;
 745   envp = va_arg( ap, const wchar_t * const * );
 746   if (envp) envs = msvcrt_argvtos(envp, 0);
 747   va_end(ap);
 748
 749   ret = msvcrt_spawn(flags, name, args, envs, 0);
 750
 751   free(args);
 752   free(envs);
 753   return ret;
 754 }
 755
 756 /*********************************************************************
 757  *              _spawnle (MSVCRT.@)
 758  */
 759 intptr_t WINAPIV _spawnle(int flags, const char* name, const char* arg0, ...)
 760 {
 761   va_list ap;
 762   wchar_t *nameW, *args, *envs = NULL;
 763   const char * const *envp;
 764   intptr_t ret;
 765
 766   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 767
 768   va_start(ap, arg0);
 769   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 770   va_end(ap);
 771
 772   va_start(ap, arg0);
 773   while (va_arg( ap, char * ) != NULL) /*nothing*/;
 774   envp = va_arg( ap, const char * const * );
 775   if (envp) envs = msvcrt_argvtos_aw(envp, 0);
 776   va_end(ap);
 777
 778   ret = msvcrt_spawn(flags, nameW, args, envs, 0);
 779
 780   free(nameW);
 781   free(args);
 782   free(envs);
 783   return ret;
 784 }
 785
 786 /*********************************************************************
 787  *      _wspawnlp (MSVCRT.@)
 788  *
 789  * Unicode version of _spawnlp
 790  */
 791 intptr_t WINAPIV _wspawnlp(int flags, const wchar_t* name, const wchar_t* arg0, ...)
 792 {
 793   va_list ap;
 794   wchar_t *args;
 795   intptr_t ret;
 796
 797   va_start(ap, arg0);
 798   args = msvcrt_valisttos(arg0, ap, ' ');
 799   va_end(ap);
 800
 801   ret = msvcrt_spawn(flags, name, args, NULL, 1);
 802
 803   free(args);
 804   return ret;
 805 }
 806
 807 /*********************************************************************
 808  *              _spawnlp (MSVCRT.@)
 809  *
 810  * Like on Windows, this function does not handle arguments with spaces
 811  * or double-quotes.
 812  */
 813 intptr_t WINAPIV _spawnlp(int flags, const char* name, const char* arg0, ...)
 814 {
 815   va_list ap;
 816   wchar_t *nameW, *args;
 817   intptr_t ret;
 818
 819   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 820
 821   va_start(ap, arg0);
 822   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 823   va_end(ap);
 824
 825   ret = msvcrt_spawn(flags, nameW, args, NULL, 1);
 826
 827   free(nameW);
 828   free(args);
 829   return ret;
 830 }
 831
 832 /*********************************************************************
 833  *      _wspawnlpe (MSVCRT.@)
 834  *
 835  * Unicode version of _spawnlpe
 836  */
 837 intptr_t WINAPIV _wspawnlpe(int flags, const wchar_t* name, const wchar_t* arg0, ...)
 838 {
 839   va_list ap;
 840   wchar_t *args, *envs = NULL;
 841   const wchar_t * const *envp;
 842   intptr_t ret;
 843
 844   va_start(ap, arg0);
 845   args = msvcrt_valisttos(arg0, ap, ' ');
 846   va_end(ap);
 847
 848   va_start(ap, arg0);
 849   while (va_arg( ap, wchar_t * ) != NULL) /*nothing*/;
 850   envp = va_arg( ap, const wchar_t * const * );
 851   if (envp) envs = msvcrt_argvtos(envp, 0);
 852   va_end(ap);
 853
 854   ret = msvcrt_spawn(flags, name, args, envs, 1);
 855
 856   free(args);
 857   free(envs);
 858   return ret;
 859 }
 860
 861 /*********************************************************************
 862  *              _spawnlpe (MSVCRT.@)
 863  */
 864 intptr_t WINAPIV _spawnlpe(int flags, const char* name, const char* arg0, ...)
 865 {
 866   va_list ap;
 867   wchar_t *nameW, *args, *envs = NULL;
 868   const char * const *envp;
 869   intptr_t ret;
 870
 871   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 872
 873   va_start(ap, arg0);
 874   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 875   va_end(ap);
 876
 877   va_start(ap, arg0);
 878   while (va_arg( ap, char * ) != NULL) /*nothing*/;
 879   envp = va_arg( ap, const char * const * );
 880   if (envp) envs = msvcrt_argvtos_aw(envp, 0);
 881   va_end(ap);
 882
 883   ret = msvcrt_spawn(flags, nameW, args, envs, 1);
 884
 885   free(nameW);
 886   free(args);
 887   free(envs);
 888   return ret;
 889 }
 890
 891 /*********************************************************************
 892  *              _spawnve (MSVCRT.@)
 893  *
 894  * Like on Windows, this function does not handle arguments with spaces
 895  * or double-quotes.
 896  */
 897 intptr_t CDECL _spawnve(int flags, const char* name, const char* const* argv,
 898                                const char* const* envv)
 899 {
 900   wchar_t *nameW, *args, *envs;
 901   intptr_t ret;
 902
 903   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 904
 905   args = msvcrt_argvtos_aw(argv, ' ');
 906   envs = msvcrt_argvtos_aw(envv, 0);
 907
 908   ret = msvcrt_spawn(flags, nameW, args, envs, 0);
 909
 910   free(nameW);
 911   free(args);
 912   free(envs);
 913   return ret;
 914 }
 915
 916 /*********************************************************************
 917  *      _wspawnve (MSVCRT.@)
 918  *
 919  * Unicode version of _spawnve
 920  */
 921 intptr_t CDECL _wspawnve(int flags, const wchar_t* name, const wchar_t* const* argv,
 922                                 const wchar_t* const* envv)
 923 {
 924   wchar_t *args, *envs;
 925   intptr_t ret;
 926
 927   args = msvcrt_argvtos(argv, ' ');
 928   envs = msvcrt_argvtos(envv, 0);
 929
 930   ret = msvcrt_spawn(flags, name, args, envs, 0);
 931
 932   free(args);
 933   free(envs);
 934   return ret;
 935 }
 936
 937 /*********************************************************************
 938  *              _spawnv (MSVCRT.@)
 939  *
 940  * Like on Windows, this function does not handle arguments with spaces
 941  * or double-quotes.
 942  */
 943 intptr_t CDECL _spawnv(int flags, const char* name, const char* const* argv)
 944 {
 945   return _spawnve(flags, name, argv, NULL);
 946 }
 947
 948 /*********************************************************************
 949  *      _wspawnv (MSVCRT.@)
 950  *
 951  * Unicode version of _spawnv
 952  */
 953 intptr_t CDECL _wspawnv(int flags, const wchar_t* name, const wchar_t* const* argv)
 954 {
 955   return _wspawnve(flags, name, argv, NULL);
 956 }
 957
 958 /*********************************************************************
 959  *              _spawnvpe (MSVCRT.@)
 960  *
 961  * Like on Windows, this function does not handle arguments with spaces
 962  * or double-quotes.
 963  */
 964 intptr_t CDECL _spawnvpe(int flags, const char* name, const char* const* argv,
 965                                 const char* const* envv)
 966 {
 967   wchar_t *nameW, *args, *envs;
 968   intptr_t ret;
 969
 970   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 971
 972   args = msvcrt_argvtos_aw(argv, ' ');
 973   envs = msvcrt_argvtos_aw(envv, 0);
 974
 975   ret = msvcrt_spawn(flags, nameW, args, envs, 1);
 976
 977   free(nameW);
 978   free(args);
 979   free(envs);
 980   return ret;
 981 }
 982
 983 /*********************************************************************
 984  *      _wspawnvpe (MSVCRT.@)
 985  *
 986  * Unicode version of _spawnvpe
 987  */
 988 intptr_t CDECL _wspawnvpe(int flags, const wchar_t* name, const wchar_t* const* argv,
 989                                  const wchar_t* const* envv)
 990 {
 991   wchar_t *args, *envs;
 992   intptr_t ret;
 993
 994   args = msvcrt_argvtos(argv, ' ');
 995   envs = msvcrt_argvtos(envv, 0);
 996
 997   ret = msvcrt_spawn(flags, name, args, envs, 1);
 998
 999   free(args);
1000   free(envs);
1001   return ret;
1002 }
1003
1004 /*********************************************************************
1005  *              _spawnvp (MSVCRT.@)
1006  *
1007  * Like on Windows, this function does not handle arguments with spaces
1008  * or double-quotes.
1009  */
1010 intptr_t CDECL _spawnvp(int flags, const char* name, const char* const* argv)
1011 {
1012   return _spawnvpe(flags, name, argv, NULL);
1013 }
1014
1015 /*********************************************************************
1016  *      _wspawnvp (MSVCRT.@)
1017  *
1018  * Unicode version of _spawnvp
1019  */
1020 intptr_t CDECL _wspawnvp(int flags, const wchar_t* name, const wchar_t* const* argv)
1021 {
1022   return _wspawnvpe(flags, name, argv, NULL);
1023 }
1024
1025 static struct popen_handle {
1026     FILE *f;
1027     HANDLE proc;
1028 } *popen_handles;
1029 static DWORD popen_handles_size;
1030
1031 void msvcrt_free_popen_data(void)
1032 {
1033     free(popen_handles);
1034 }
1035
1036 /*********************************************************************
1037  *              _wpopen (MSVCRT.@)
1038  *
1039  * Unicode version of _popen
1040  */
1041 FILE* CDECL _wpopen(const wchar_t* command, const wchar_t* mode)
1042 {
1043     wchar_t *comspec, *fullcmd, fullname[MAX_PATH];
1044     int textmode, fds[2], fd_parent, fd_child;
1045     struct popen_handle *container;
1046     PROCESS_INFORMATION pi;
1047     BOOL read_pipe = TRUE;
1048     const wchar_t *p;
1049     unsigned int len;
1050     STARTUPINFOW si;
1051     FILE *ret;
1052     DWORD i;
1053     BOOL r;
1054
1055     TRACE("(command=%s, mode=%s)\n", debugstr_w(command), debugstr_w(mode));
1056
1057     if (!command || !mode)
1058         return NULL;
1059
1060     _get_fmode(&textmode);
1061     textmode &= _O_BINARY | _O_TEXT;
1062     textmode |= _O_NOINHERIT;
1063     for (p = mode; *p; p++)
1064     {
1065         switch (*p)
1066         {
1067         case 'W':
1068         case 'w':
1069             read_pipe = FALSE;
1070             break;
1071         case 'B':
1072         case 'b':
1073             textmode |= _O_BINARY;
1074             textmode &= ~_O_TEXT;
1075             break;
1076         case 'T':
1077         case 't':
1078             textmode |= _O_TEXT;
1079             textmode &= ~_O_BINARY;
1080             break;
1081         }
1082     }
1083     if (_pipe(fds, 0, textmode) == -1)
1084         return NULL;
1085
1086     if (read_pipe)
1087     {
1088         fd_parent = fds[0];
1089         fd_child = _dup(fds[1]);
1090         _close(fds[1]);
1091     }
1092     else
1093     {
1094         fd_parent = fds[1];
1095         fd_child = _dup(fds[0]);
1096         _close(fds[0]);
1097     }
1098     if (fd_child == -1)
1099     {
1100         _close(fd_parent);
1101         return NULL;
1102     }
1103     ret = _wfdopen(fd_parent, mode);
1104     if (!ret)
1105     {
1106         _close(fd_child);
1107         return NULL;
1108     }
1109
1110     _lock(_POPEN_LOCK);
1111     for (i = 0; i < popen_handles_size; i++)
1112     {
1113         if (!popen_handles[i].f)
1114             break;
1115     }
1116     if (i == popen_handles_size)
1117     {
1118         i = (popen_handles_size ? popen_handles_size * 2 : 8);
1119         container = realloc(popen_handles, i * sizeof(*container));
1120         if (!container) goto error;
1121
1122         popen_handles = container;
1123         container = popen_handles + popen_handles_size;
1124         memset(container, 0, (i - popen_handles_size) * sizeof(*container));
1125         popen_handles_size = i;
1126     }
1127     else container = popen_handles + i;
1128
1129     if (!(comspec = msvcrt_get_comspec())) goto error;
1130     len = wcslen(comspec) + wcslen(command) + 5;
1131
1132     if (!(fullcmd = HeapAlloc(GetProcessHeap(), 0, len * sizeof(wchar_t))))
1133     {
1134         HeapFree(GetProcessHeap(), 0, comspec);
1135         goto error;
1136     }
1137
1138     wcscpy(fullcmd, comspec);
1139     wcscat(fullcmd, L" /c ");
1140     wcscat(fullcmd, command);
1141     msvcrt_search_executable(comspec, fullname, 1);
1142
1143     memset(&si, 0, sizeof(si));
1144     si.cb = sizeof(si);
1145     si.dwFlags = STARTF_USESTDHANDLES;
1146     if (read_pipe)
1147     {
1148         si.hStdInput = (HANDLE)_get_osfhandle(STDIN_FILENO);
1149         si.hStdOutput = (HANDLE)_get_osfhandle(fd_child);
1150     }
1151     else
1152     {
1153         si.hStdInput = (HANDLE)_get_osfhandle(fd_child);
1154         si.hStdOutput = (HANDLE)_get_osfhandle(STDOUT_FILENO);
1155     }
1156     si.hStdError = (HANDLE)_get_osfhandle(STDERR_FILENO);
1157     r = CreateProcessW(fullname, fullcmd, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi);
1158     HeapFree(GetProcessHeap(), 0, comspec);
1159     HeapFree(GetProcessHeap(), 0, fullcmd);
1160     if (!r)
1161     {
1162         msvcrt_set_errno(GetLastError());
1163         goto error;
1164     }
1165     CloseHandle(pi.hThread);
1166     _close(fd_child);
1167     container->proc = pi.hProcess;
1168     container->f = ret;
1169     _unlock(_POPEN_LOCK);
1170     return ret;
1171
1172 error:
1173     _unlock(_POPEN_LOCK);
1174     _close(fd_child);
1175     fclose(ret);
1176     return NULL;
1177 }
1178
1179 /*********************************************************************
1180  *      _popen (MSVCRT.@)
1181  */
1182 FILE* CDECL _popen(const char* command, const char* mode)
1183 {
1184   FILE *ret;
1185   wchar_t *cmdW, *modeW;
1186
1187   TRACE("(command=%s, mode=%s)\n", debugstr_a(command), debugstr_a(mode));
1188
1189   if (!command || !mode)
1190     return NULL;
1191
1192   if (!(cmdW = msvcrt_wstrdupa(command))) return NULL;
1193   if (!(modeW = msvcrt_wstrdupa(mode)))
1194   {
1195     free(cmdW);
1196     return NULL;
1197   }
1198
1199   ret = _wpopen(cmdW, modeW);
1200
1201   free(cmdW);
1202   free(modeW);
1203   return ret;
1204 }
1205
1206 /*********************************************************************
1207  *              _pclose (MSVCRT.@)
1208  */
1209 int CDECL _pclose(FILE* file)
1210 {
1211   HANDLE h;
1212   DWORD i;
1213
1214   if (!MSVCRT_CHECK_PMT(file != NULL)) return -1;
1215
1216   _lock(_POPEN_LOCK);
1217   for(i=0; i<popen_handles_size; i++)
1218   {
1219     if (popen_handles[i].f == file)
1220       break;
1221   }
1222   if(i == popen_handles_size)
1223   {
1224     _unlock(_POPEN_LOCK);
1225     *_errno() = EBADF;
1226     return -1;
1227   }
1228
1229   h = popen_handles[i].proc;
1230   popen_handles[i].f = NULL;
1231   _unlock(_POPEN_LOCK);
1232
1233   fclose(file);
1234   if(WaitForSingleObject(h, INFINITE)==WAIT_FAILED || !GetExitCodeProcess(h, &i))
1235   {
1236     msvcrt_set_errno(GetLastError());
1237     CloseHandle(h);
1238     return -1;
1239   }
1240
1241   CloseHandle(h);
1242   return i;
1243 }
1244
1245 /*********************************************************************
1246  *      _wsystem (MSVCRT.@)
1247  *
1248  * Unicode version of system
1249  */
1250 int CDECL _wsystem(const wchar_t* cmd)
1251 {
1252   int res;
1253   wchar_t *comspec, *fullcmd;
1254   unsigned int len;
1255
1256   comspec = msvcrt_get_comspec();
1257
1258   if (cmd == NULL)
1259   {
1260     if (comspec == NULL)
1261     {
1262         *_errno() = ENOENT;
1263         return 0;
1264     }
1265     HeapFree(GetProcessHeap(), 0, comspec);
1266     return 1;
1267   }
1268
1269   if (comspec == NULL)
1270     return -1;
1271
1272   len = wcslen(comspec) + wcslen(cmd) + 5;
1273
1274   if (!(fullcmd = HeapAlloc(GetProcessHeap(), 0, len * sizeof(wchar_t))))
1275   {
1276     HeapFree(GetProcessHeap(), 0, comspec);
1277     return -1;
1278   }
1279   wcscpy(fullcmd, comspec);
1280   wcscat(fullcmd, L" /c ");
1281   wcscat(fullcmd, cmd);
1282
1283   res = msvcrt_spawn(_P_WAIT, comspec, fullcmd, NULL, 1);
1284
1285   HeapFree(GetProcessHeap(), 0, comspec);
1286   HeapFree(GetProcessHeap(), 0, fullcmd);
1287   return res;
1288 }
1289
1290 /*********************************************************************
1291  *              system (MSVCRT.@)
1292  */
1293 int CDECL system(const char* cmd)
1294 {
1295   int res = -1;
1296   wchar_t *cmdW;
1297
1298   if (cmd == NULL)
1299     return _wsystem(NULL);
1300
1301   if ((cmdW = msvcrt_wstrdupa(cmd)))
1302   {
1303     res = _wsystem(cmdW);
1304     free(cmdW);
1305   }
1306   return res;
1307 }
1308
1309 /*********************************************************************
1310  *              _loaddll (MSVCRT.@)
1311  */
1312 intptr_t CDECL _loaddll(const char* dllname)
1313 {
1314   return (intptr_t)LoadLibraryA(dllname);
1315 }
1316
1317 /*********************************************************************
1318  *              _unloaddll (MSVCRT.@)
1319  */
1320 int CDECL _unloaddll(intptr_t dll)
1321 {
1322   if (FreeLibrary((HMODULE)dll))
1323     return 0;
1324   else
1325   {
1326     int err = GetLastError();
1327     msvcrt_set_errno(err);
1328     return err;
1329   }
1330 }
1331
1332 /*********************************************************************
1333  *              _getdllprocaddr (MSVCRT.@)
1334  */
1335 void * CDECL _getdllprocaddr(intptr_t dll, const char *name, int ordinal)
1336 {
1337     if (name)
1338     {
1339         if (ordinal != -1) return NULL;
1340         return GetProcAddress( (HMODULE)dll, name );
1341     }
1342     if (HIWORD(ordinal)) return NULL;
1343     return GetProcAddress( (HMODULE)dll, (LPCSTR)(ULONG_PTR)ordinal );
1344 }
1345
1346 /*********************************************************************
1347  *              _getpid (MSVCRT.@)
1348  */
1349 int CDECL _getpid(void)
1350 {
1351     return GetCurrentProcessId();
1352 }
1353
1354 #if _MSVCR_VER>=110
1355 /*********************************************************************
1356  *  __crtTerminateProcess (MSVCR110.@)
1357  */
1358 int CDECL __crtTerminateProcess(UINT exit_code)
1359 {
1360     return TerminateProcess(GetCurrentProcess(), exit_code);
1361 }
1362 #endif