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, __ms_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, __ms_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   __ms_va_list ap;
 395   wchar_t *args;
 396   intptr_t ret;
 397
 398   __ms_va_start(ap, arg0);
 399   args = msvcrt_valisttos(arg0, ap, ' ');
 400   __ms_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   __ms_va_list ap;
 417   wchar_t *nameW, *args;
 418   intptr_t ret;
 419
 420   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 421
 422   __ms_va_start(ap, arg0);
 423   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 424   __ms_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   __ms_va_list ap;
 441   wchar_t *args, *envs = NULL;
 442   const wchar_t * const *envp;
 443   intptr_t ret;
 444
 445   __ms_va_start(ap, arg0);
 446   args = msvcrt_valisttos(arg0, ap, ' ');
 447   __ms_va_end(ap);
 448
 449   __ms_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   __ms_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   __ms_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   __ms_va_start(ap, arg0);
 475   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 476   __ms_va_end(ap);
 477
 478   __ms_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   __ms_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   __ms_va_list ap;
 500   wchar_t *args;
 501   intptr_t ret;
 502
 503   __ms_va_start(ap, arg0);
 504   args = msvcrt_valisttos(arg0, ap, ' ');
 505   __ms_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   __ms_va_list ap;
 522   wchar_t *nameW, *args;
 523   intptr_t ret;
 524
 525   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 526
 527   __ms_va_start(ap, arg0);
 528   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 529   __ms_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   __ms_va_list ap;
 546   wchar_t *args, *envs = NULL;
 547   const wchar_t * const *envp;
 548   intptr_t ret;
 549
 550   __ms_va_start(ap, arg0);
 551   args = msvcrt_valisttos(arg0, ap, ' ');
 552   __ms_va_end(ap);
 553
 554   __ms_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   __ms_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   __ms_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   __ms_va_start(ap, arg0);
 580   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 581   __ms_va_end(ap);
 582
 583   __ms_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   __ms_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   __ms_va_list ap;
 689   wchar_t *args;
 690   intptr_t ret;
 691
 692   __ms_va_start(ap, arg0);
 693   args = msvcrt_valisttos(arg0, ap, ' ');
 694   __ms_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   __ms_va_list ap;
 711   wchar_t *nameW, *args;
 712   intptr_t ret;
 713
 714   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 715
 716   __ms_va_start(ap, arg0);
 717   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 718   __ms_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   __ms_va_list ap;
 735   wchar_t *args, *envs = NULL;
 736   const wchar_t * const *envp;
 737   intptr_t ret;
 738
 739   __ms_va_start(ap, arg0);
 740   args = msvcrt_valisttos(arg0, ap, ' ');
 741   __ms_va_end(ap);
 742
 743   __ms_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   __ms_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   __ms_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   __ms_va_start(ap, arg0);
 769   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 770   __ms_va_end(ap);
 771
 772   __ms_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   __ms_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   __ms_va_list ap;
 794   wchar_t *args;
 795   intptr_t ret;
 796
 797   __ms_va_start(ap, arg0);
 798   args = msvcrt_valisttos(arg0, ap, ' ');
 799   __ms_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   __ms_va_list ap;
 816   wchar_t *nameW, *args;
 817   intptr_t ret;
 818
 819   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 820
 821   __ms_va_start(ap, arg0);
 822   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 823   __ms_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   __ms_va_list ap;
 840   wchar_t *args, *envs = NULL;
 841   const wchar_t * const *envp;
 842   intptr_t ret;
 843
 844   __ms_va_start(ap, arg0);
 845   args = msvcrt_valisttos(arg0, ap, ' ');
 846   __ms_va_end(ap);
 847
 848   __ms_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   __ms_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   __ms_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   __ms_va_start(ap, arg0);
 874   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 875   __ms_va_end(ap);
 876
 877   __ms_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   __ms_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   FILE *ret;
1044   BOOL readPipe = TRUE;
1045   int textmode, fds[2], fdToDup, fdToOpen, fdStdHandle = -1, fmode;
1046   const wchar_t *p;
1047   wchar_t *comspec, *fullcmd;
1048   unsigned int len;
1049   struct popen_handle *container;
1050   DWORD i;
1051
1052   TRACE("(command=%s, mode=%s)\n", debugstr_w(command), debugstr_w(mode));
1053
1054   if (!command || !mode)
1055     return NULL;
1056
1057   _get_fmode(&fmode);
1058   textmode = fmode & (_O_BINARY | _O_TEXT);
1059   for (p = mode; *p; p++)
1060   {
1061     switch (*p)
1062     {
1063       case 'W':
1064       case 'w':
1065         readPipe = FALSE;
1066         break;
1067       case 'B':
1068       case 'b':
1069         textmode |= _O_BINARY;
1070         textmode &= ~_O_TEXT;
1071         break;
1072       case 'T':
1073       case 't':
1074         textmode |= _O_TEXT;
1075         textmode &= ~_O_BINARY;
1076         break;
1077     }
1078   }
1079   if (_pipe(fds, 0, textmode) == -1)
1080     return NULL;
1081
1082   fdToDup = readPipe ? 1 : 0;
1083   fdToOpen = readPipe ? 0 : 1;
1084
1085   _lock(_POPEN_LOCK);
1086   for(i=0; i<popen_handles_size; i++)
1087   {
1088     if (!popen_handles[i].f)
1089       break;
1090   }
1091   if (i==popen_handles_size)
1092   {
1093     i = (popen_handles_size ? popen_handles_size*2 : 8);
1094     container = realloc(popen_handles, i*sizeof(*container));
1095     if (!container) goto error;
1096
1097     popen_handles = container;
1098     container = popen_handles+popen_handles_size;
1099     memset(container, 0, (i-popen_handles_size)*sizeof(*container));
1100     popen_handles_size = i;
1101   }
1102   else container = popen_handles+i;
1103
1104   if ((fdStdHandle = _dup(fdToDup)) == -1)
1105     goto error;
1106   if (_dup2(fds[fdToDup], fdToDup) != 0)
1107     goto error;
1108
1109   _close(fds[fdToDup]);
1110
1111   if (!(comspec = msvcrt_get_comspec())) goto error;
1112   len = wcslen(comspec) + wcslen(command) + 5;
1113
1114   if (!(fullcmd = HeapAlloc(GetProcessHeap(), 0, len * sizeof(wchar_t))))
1115   {
1116     HeapFree(GetProcessHeap(), 0, comspec);
1117     goto error;
1118   }
1119
1120   wcscpy(fullcmd, comspec);
1121   wcscat(fullcmd, L" /c ");
1122   wcscat(fullcmd, command);
1123
1124   if ((container->proc = (HANDLE)msvcrt_spawn(_P_NOWAIT, comspec, fullcmd, NULL, 1))
1125           == INVALID_HANDLE_VALUE)
1126   {
1127     _close(fds[fdToOpen]);
1128     ret = NULL;
1129   }
1130   else
1131   {
1132     ret = _wfdopen(fds[fdToOpen], mode);
1133     if (!ret)
1134       _close(fds[fdToOpen]);
1135     container->f = ret;
1136   }
1137   _unlock(_POPEN_LOCK);
1138   HeapFree(GetProcessHeap(), 0, comspec);
1139   HeapFree(GetProcessHeap(), 0, fullcmd);
1140   _dup2(fdStdHandle, fdToDup);
1141   _close(fdStdHandle);
1142   return ret;
1143
1144 error:
1145   _unlock(_POPEN_LOCK);
1146   if (fdStdHandle != -1) _close(fdStdHandle);
1147   _close(fds[0]);
1148   _close(fds[1]);
1149   return NULL;
1150 }
1151
1152 /*********************************************************************
1153  *      _popen (MSVCRT.@)
1154  */
1155 FILE* CDECL _popen(const char* command, const char* mode)
1156 {
1157   FILE *ret;
1158   wchar_t *cmdW, *modeW;
1159
1160   TRACE("(command=%s, mode=%s)\n", debugstr_a(command), debugstr_a(mode));
1161
1162   if (!command || !mode)
1163     return NULL;
1164
1165   if (!(cmdW = msvcrt_wstrdupa(command))) return NULL;
1166   if (!(modeW = msvcrt_wstrdupa(mode)))
1167   {
1168     HeapFree(GetProcessHeap(), 0, cmdW);
1169     return NULL;
1170   }
1171
1172   ret = _wpopen(cmdW, modeW);
1173
1174   HeapFree(GetProcessHeap(), 0, cmdW);
1175   HeapFree(GetProcessHeap(), 0, modeW);
1176   return ret;
1177 }
1178
1179 /*********************************************************************
1180  *              _pclose (MSVCRT.@)
1181  */
1182 int CDECL _pclose(FILE* file)
1183 {
1184   HANDLE h;
1185   DWORD i;
1186
1187   if (!MSVCRT_CHECK_PMT(file != NULL)) return -1;
1188
1189   _lock(_POPEN_LOCK);
1190   for(i=0; i<popen_handles_size; i++)
1191   {
1192     if (popen_handles[i].f == file)
1193       break;
1194   }
1195   if(i == popen_handles_size)
1196   {
1197     _unlock(_POPEN_LOCK);
1198     *_errno() = EBADF;
1199     return -1;
1200   }
1201
1202   h = popen_handles[i].proc;
1203   popen_handles[i].f = NULL;
1204   _unlock(_POPEN_LOCK);
1205
1206   fclose(file);
1207   if(WaitForSingleObject(h, INFINITE)==WAIT_FAILED || !GetExitCodeProcess(h, &i))
1208   {
1209     msvcrt_set_errno(GetLastError());
1210     CloseHandle(h);
1211     return -1;
1212   }
1213
1214   CloseHandle(h);
1215   return i;
1216 }
1217
1218 /*********************************************************************
1219  *      _wsystem (MSVCRT.@)
1220  *
1221  * Unicode version of system
1222  */
1223 int CDECL _wsystem(const wchar_t* cmd)
1224 {
1225   int res;
1226   wchar_t *comspec, *fullcmd;
1227   unsigned int len;
1228
1229   comspec = msvcrt_get_comspec();
1230
1231   if (cmd == NULL)
1232   {
1233     if (comspec == NULL)
1234     {
1235         *_errno() = ENOENT;
1236         return 0;
1237     }
1238     HeapFree(GetProcessHeap(), 0, comspec);
1239     return 1;
1240   }
1241
1242   if (comspec == NULL)
1243     return -1;
1244
1245   len = wcslen(comspec) + wcslen(cmd) + 5;
1246
1247   if (!(fullcmd = HeapAlloc(GetProcessHeap(), 0, len * sizeof(wchar_t))))
1248   {
1249     HeapFree(GetProcessHeap(), 0, comspec);
1250     return -1;
1251   }
1252   wcscpy(fullcmd, comspec);
1253   wcscat(fullcmd, L" /c ");
1254   wcscat(fullcmd, cmd);
1255
1256   res = msvcrt_spawn(_P_WAIT, comspec, fullcmd, NULL, 1);
1257
1258   HeapFree(GetProcessHeap(), 0, comspec);
1259   HeapFree(GetProcessHeap(), 0, fullcmd);
1260   return res;
1261 }
1262
1263 /*********************************************************************
1264  *              system (MSVCRT.@)
1265  */
1266 int CDECL system(const char* cmd)
1267 {
1268   int res = -1;
1269   wchar_t *cmdW;
1270
1271   if (cmd == NULL)
1272     return _wsystem(NULL);
1273
1274   if ((cmdW = msvcrt_wstrdupa(cmd)))
1275   {
1276     res = _wsystem(cmdW);
1277     HeapFree(GetProcessHeap(), 0, cmdW);
1278   }
1279   return res;
1280 }
1281
1282 /*********************************************************************
1283  *              _loaddll (MSVCRT.@)
1284  */
1285 intptr_t CDECL _loaddll(const char* dllname)
1286 {
1287   return (intptr_t)LoadLibraryA(dllname);
1288 }
1289
1290 /*********************************************************************
1291  *              _unloaddll (MSVCRT.@)
1292  */
1293 int CDECL _unloaddll(intptr_t dll)
1294 {
1295   if (FreeLibrary((HMODULE)dll))
1296     return 0;
1297   else
1298   {
1299     int err = GetLastError();
1300     msvcrt_set_errno(err);
1301     return err;
1302   }
1303 }
1304
1305 /*********************************************************************
1306  *              _getdllprocaddr (MSVCRT.@)
1307  */
1308 void * CDECL _getdllprocaddr(intptr_t dll, const char *name, int ordinal)
1309 {
1310     if (name)
1311     {
1312         if (ordinal != -1) return NULL;
1313         return GetProcAddress( (HMODULE)dll, name );
1314     }
1315     if (HIWORD(ordinal)) return NULL;
1316     return GetProcAddress( (HMODULE)dll, (LPCSTR)(ULONG_PTR)ordinal );
1317 }
1318
1319 /*********************************************************************
1320  *              _getpid (MSVCRT.@)
1321  */
1322 int CDECL _getpid(void)
1323 {
1324     return GetCurrentProcessId();
1325 }
1326
1327 #if _MSVCR_VER>=110
1328 /*********************************************************************
1329  *  __crtTerminateProcess (MSVCR110.@)
1330  */
1331 int CDECL __crtTerminateProcess(UINT exit_code)
1332 {
1333     return TerminateProcess(GetCurrentProcess(), exit_code);
1334 }
1335 #endif