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 #include "config.h"
  30
  31 #include <stdarg.h>
  32
  33 #include "msvcrt.h"
  34 #include "mtdll.h"
  35 #include "wine/debug.h"
  36 #include "wine/unicode.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
  39
  40 static void msvcrt_search_executable(const MSVCRT_wchar_t *name, MSVCRT_wchar_t *fullname, int use_path)
  41 {
  42   static const MSVCRT_wchar_t path[] = {'P','A','T','H',0};
  43   static const MSVCRT_wchar_t suffix[][5] =
  44     {{'.','c','o','m',0}, {'.','e','x','e',0}, {'.','b','a','t',0}, {'.','c','m','d',0}};
  45
  46   MSVCRT_wchar_t buffer[MAX_PATH];
  47   const MSVCRT_wchar_t *env, *p;
  48   unsigned int i, name_len, path_len;
  49   int extension = 1;
  50
  51   *fullname = '\0';
  52   msvcrt_set_errno(ERROR_FILE_NOT_FOUND);
  53
  54   p = memchrW(name, '\0', MAX_PATH);
  55   if (!p) p = name + MAX_PATH - 1;
  56   name_len = p - name;
  57
  58   /* FIXME extra-long names are silently truncated */
  59   memcpy(buffer, name, name_len * sizeof(MSVCRT_wchar_t));
  60   buffer[name_len] = '\0';
  61
  62   /* try current dir first */
  63   if (GetFileAttributesW(buffer) != INVALID_FILE_ATTRIBUTES)
  64   {
  65     strcpyW(fullname, buffer);
  66     return;
  67   }
  68
  69   for (p--; p >= name; p--)
  70     if (*p == '\\' || *p == '/' || *p == ':' || *p == '.') break;
  71
  72   /* if there's no extension, try some well-known extensions */
  73   if ((p < name || *p != '.') && name_len <= MAX_PATH - 5)
  74   {
  75     for (i = 0; i < 4; i++)
  76     {
  77       memcpy(buffer + name_len, suffix[i], 5 * sizeof(MSVCRT_wchar_t));
  78       if (GetFileAttributesW(buffer) != INVALID_FILE_ATTRIBUTES)
  79       {
  80         strcpyW(fullname, buffer);
  81         return;
  82       }
  83     }
  84     extension = 0;
  85   }
  86
  87   if (!use_path || !(env = MSVCRT__wgetenv(path))) return;
  88
  89   /* now try search path */
  90   do
  91   {
  92     p = env;
  93     while (*p && *p != ';') p++;
  94     if (p == env) return;
  95
  96     path_len = p - env;
  97     if (path_len + name_len <= MAX_PATH - 2)
  98     {
  99       memcpy(buffer, env, path_len * sizeof(MSVCRT_wchar_t));
 100       if (buffer[path_len] != '/' && buffer[path_len] != '\\')
 101       {
 102         buffer[path_len++] = '\\';
 103         buffer[path_len] = '\0';
 104       }
 105       else buffer[path_len] = '\0';
 106
 107       strcatW(buffer, name);
 108       if (GetFileAttributesW(buffer) != INVALID_FILE_ATTRIBUTES)
 109       {
 110         strcpyW(fullname, buffer);
 111         return;
 112       }
 113     }
 114     /* again, if there's no extension, try some well-known extensions */
 115     if (!extension && path_len + name_len <= MAX_PATH - 5)
 116     {
 117       for (i = 0; i < 4; i++)
 118       {
 119         memcpy(buffer + path_len + name_len, suffix[i], 5 * sizeof(MSVCRT_wchar_t));
 120         if (GetFileAttributesW(buffer) != INVALID_FILE_ATTRIBUTES)
 121         {
 122           strcpyW(fullname, buffer);
 123           return;
 124         }
 125       }
 126     }
 127     env = *p ? p + 1 : p;
 128   } while(1);
 129 }
 130
 131 static MSVCRT_intptr_t msvcrt_spawn(int flags, const MSVCRT_wchar_t* exe, MSVCRT_wchar_t* cmdline,
 132                                     MSVCRT_wchar_t* env, int use_path)
 133 {
 134   STARTUPINFOW si;
 135   PROCESS_INFORMATION pi;
 136   MSVCRT_wchar_t fullname[MAX_PATH];
 137   DWORD create_flags = CREATE_UNICODE_ENVIRONMENT;
 138
 139   TRACE("%x %s %s %s %d\n", flags, debugstr_w(exe), debugstr_w(cmdline), debugstr_w(env), use_path);
 140
 141   if ((unsigned)flags > MSVCRT__P_DETACH)
 142   {
 143     *MSVCRT__errno() = MSVCRT_EINVAL;
 144     return -1;
 145   }
 146
 147   msvcrt_search_executable(exe, fullname, use_path);
 148
 149   memset(&si, 0, sizeof(si));
 150   si.cb = sizeof(si);
 151   msvcrt_create_io_inherit_block(&si.cbReserved2, &si.lpReserved2);
 152   if (flags == MSVCRT__P_DETACH) create_flags |= DETACHED_PROCESS;
 153   if (!CreateProcessW(fullname, cmdline, NULL, NULL, TRUE,
 154                       create_flags, env, NULL, &si, &pi))
 155   {
 156     msvcrt_set_errno(GetLastError());
 157     MSVCRT_free(si.lpReserved2);
 158     return -1;
 159   }
 160
 161   MSVCRT_free(si.lpReserved2);
 162   switch(flags)
 163   {
 164   case MSVCRT__P_WAIT:
 165     WaitForSingleObject(pi.hProcess, INFINITE);
 166     GetExitCodeProcess(pi.hProcess,&pi.dwProcessId);
 167     CloseHandle(pi.hProcess);
 168     CloseHandle(pi.hThread);
 169     return pi.dwProcessId;
 170   case MSVCRT__P_DETACH:
 171     CloseHandle(pi.hProcess);
 172     pi.hProcess = 0;
 173     /* fall through */
 174   case MSVCRT__P_NOWAIT:
 175   case MSVCRT__P_NOWAITO:
 176     CloseHandle(pi.hThread);
 177     return (MSVCRT_intptr_t)pi.hProcess;
 178   case  MSVCRT__P_OVERLAY:
 179     MSVCRT__exit(0);
 180   }
 181   return -1; /* can't reach here */
 182 }
 183
 184 /* INTERNAL: Convert wide argv list to a single 'delim'-separated wide string, with an
 185  * extra '\0' to terminate it.
 186  */
 187 static MSVCRT_wchar_t* msvcrt_argvtos(const MSVCRT_wchar_t* const* arg, MSVCRT_wchar_t delim)
 188 {
 189   const MSVCRT_wchar_t* const* a;
 190   int size;
 191   MSVCRT_wchar_t* p;
 192   MSVCRT_wchar_t* ret;
 193
 194   if (!arg)
 195   {
 196       /* Return NULL for an empty environment list */
 197       return NULL;
 198   }
 199
 200   /* get length */
 201   a = arg;
 202   size = 0;
 203   while (*a)
 204   {
 205     size += strlenW(*a) + 1;
 206     a++;
 207   }
 208
 209   ret = MSVCRT_malloc((size + 1) * sizeof(MSVCRT_wchar_t));
 210   if (!ret)
 211     return NULL;
 212
 213   /* fill string */
 214   a = arg;
 215   p = ret;
 216   while (*a)
 217   {
 218     int len = strlenW(*a);
 219     memcpy(p,*a,len * sizeof(MSVCRT_wchar_t));
 220     p += len;
 221     *p++ = delim;
 222     a++;
 223   }
 224   if (delim && p > ret) p[-1] = 0;
 225   else *p = 0;
 226   return ret;
 227 }
 228
 229 /* INTERNAL: Convert ansi argv list to a single 'delim'-separated wide string, with an
 230  * extra '\0' to terminate it.
 231  */
 232 static MSVCRT_wchar_t *msvcrt_argvtos_aw(const char * const *arg, MSVCRT_wchar_t delim)
 233 {
 234   const char * const *a;
 235   unsigned int len;
 236   MSVCRT_wchar_t *p, *ret;
 237
 238   if (!arg)
 239   {
 240       /* Return NULL for an empty environment list */
 241       return NULL;
 242   }
 243
 244   /* get length */
 245   a = arg;
 246   len = 0;
 247   while (*a)
 248   {
 249     len += MultiByteToWideChar(CP_ACP, 0, *a, -1, NULL, 0);
 250     a++;
 251   }
 252
 253   ret = MSVCRT_malloc((len + 1) * sizeof(MSVCRT_wchar_t));
 254   if (!ret)
 255     return NULL;
 256
 257   /* fill string */
 258   a = arg;
 259   p = ret;
 260   while (*a)
 261   {
 262     p += MultiByteToWideChar(CP_ACP, 0, *a, strlen(*a), p, len - (p - ret));
 263     *p++ = delim;
 264     a++;
 265   }
 266   if (delim && p > ret) p[-1] = 0;
 267   else *p = 0;
 268   return ret;
 269 }
 270
 271 /* INTERNAL: Convert wide va_list to a single 'delim'-separated wide string, with an
 272  * extra '\0' to terminate it.
 273  */
 274 static MSVCRT_wchar_t *msvcrt_valisttos(const MSVCRT_wchar_t *arg0, __ms_va_list alist, MSVCRT_wchar_t delim)
 275 {
 276     unsigned int size = 0, pos = 0;
 277     const MSVCRT_wchar_t *arg;
 278     MSVCRT_wchar_t *new, *ret = NULL;
 279
 280     for (arg = arg0; arg; arg = va_arg( alist, MSVCRT_wchar_t * ))
 281     {
 282         unsigned int len = strlenW( arg ) + 1;
 283         if (pos + len >= size)
 284         {
 285             size = max( 256, size * 2 );
 286             size = max( size, pos + len + 1 );
 287             if (!(new = MSVCRT_realloc( ret, size * sizeof(MSVCRT_wchar_t) )))
 288             {
 289                 MSVCRT_free( ret );
 290                 return NULL;
 291             }
 292             ret = new;
 293         }
 294         strcpyW( ret + pos, arg );
 295         pos += len;
 296         ret[pos - 1] = delim;
 297     }
 298     if (pos)
 299     {
 300         if (delim) ret[pos - 1] = 0;
 301         else ret[pos] = 0;
 302     }
 303     return ret;
 304 }
 305
 306 /* INTERNAL: Convert ansi va_list to a single 'delim'-separated wide string, with an
 307  * extra '\0' to terminate it.
 308  */
 309 static MSVCRT_wchar_t *msvcrt_valisttos_aw(const char *arg0, __ms_va_list alist, MSVCRT_wchar_t delim)
 310 {
 311     unsigned int size = 0, pos = 0;
 312     const char *arg;
 313     MSVCRT_wchar_t *new, *ret = NULL;
 314
 315     for (arg = arg0; arg; arg = va_arg( alist, char * ))
 316     {
 317         unsigned int len = MultiByteToWideChar( CP_ACP, 0, arg, -1, NULL, 0 );
 318         if (pos + len >= size)
 319         {
 320             size = max( 256, size * 2 );
 321             size = max( size, pos + len + 1 );
 322             if (!(new = MSVCRT_realloc( ret, size * sizeof(MSVCRT_wchar_t) )))
 323             {
 324                 MSVCRT_free( ret );
 325                 return NULL;
 326             }
 327             ret = new;
 328         }
 329         pos += MultiByteToWideChar( CP_ACP, 0, arg, -1, ret + pos, size - pos );
 330         ret[pos - 1] = delim;
 331     }
 332     if (pos)
 333     {
 334         if (delim) ret[pos - 1] = 0;
 335         else ret[pos] = 0;
 336     }
 337     return ret;
 338 }
 339
 340 /* INTERNAL: retrieve COMSPEC environment variable */
 341 static MSVCRT_wchar_t *msvcrt_get_comspec(void)
 342 {
 343   static const MSVCRT_wchar_t cmd[] = {'c','m','d',0};
 344   static const MSVCRT_wchar_t comspec[] = {'C','O','M','S','P','E','C',0};
 345   MSVCRT_wchar_t *ret;
 346   unsigned int len;
 347
 348   if (!(len = GetEnvironmentVariableW(comspec, NULL, 0))) len = sizeof(cmd)/sizeof(MSVCRT_wchar_t);
 349   if ((ret = HeapAlloc(GetProcessHeap(), 0, len * sizeof(MSVCRT_wchar_t))))
 350   {
 351     if (!GetEnvironmentVariableW(comspec, ret, len)) strcpyW(ret, cmd);
 352   }
 353   return ret;
 354 }
 355
 356 /*********************************************************************
 357  *              _cwait (MSVCRT.@)
 358  */
 359 MSVCRT_intptr_t CDECL _cwait(int *status, MSVCRT_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     *MSVCRT__errno() =  MSVCRT_ECHILD;
 379     *MSVCRT___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 MSVCRT_intptr_t WINAPIV _wexecl(const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* arg0, ...)
 393 {
 394   __ms_va_list ap;
 395   MSVCRT_wchar_t *args;
 396   MSVCRT_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(MSVCRT__P_OVERLAY, name, args, NULL, 0);
 403
 404   MSVCRT_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 MSVCRT_intptr_t WINAPIV _execl(const char* name, const char* arg0, ...)
 415 {
 416   __ms_va_list ap;
 417   MSVCRT_wchar_t *nameW, *args;
 418   MSVCRT_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(MSVCRT__P_OVERLAY, nameW, args, NULL, 0);
 427
 428   MSVCRT_free(nameW);
 429   MSVCRT_free(args);
 430   return ret;
 431 }
 432
 433 /*********************************************************************
 434  *      _wexecle (MSVCRT.@)
 435  *
 436  * Unicode version of _execle
 437  */
 438 MSVCRT_intptr_t WINAPIV _wexecle(const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* arg0, ...)
 439 {
 440   __ms_va_list ap;
 441   MSVCRT_wchar_t *args, *envs = NULL;
 442   const MSVCRT_wchar_t * const *envp;
 443   MSVCRT_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, MSVCRT_wchar_t * ) != NULL) /*nothing*/;
 451   envp = va_arg( ap, const MSVCRT_wchar_t * const * );
 452   if (envp) envs = msvcrt_argvtos(envp, 0);
 453   __ms_va_end(ap);
 454
 455   ret = msvcrt_spawn(MSVCRT__P_OVERLAY, name, args, envs, 0);
 456
 457   MSVCRT_free(args);
 458   MSVCRT_free(envs);
 459   return ret;
 460 }
 461
 462 /*********************************************************************
 463  *              _execle (MSVCRT.@)
 464  */
 465 MSVCRT_intptr_t WINAPIV _execle(const char* name, const char* arg0, ...)
 466 {
 467   __ms_va_list ap;
 468   MSVCRT_wchar_t *nameW, *args, *envs = NULL;
 469   const char * const *envp;
 470   MSVCRT_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(MSVCRT__P_OVERLAY, nameW, args, envs, 0);
 485
 486   MSVCRT_free(nameW);
 487   MSVCRT_free(args);
 488   MSVCRT_free(envs);
 489   return ret;
 490 }
 491
 492 /*********************************************************************
 493  *      _wexeclp (MSVCRT.@)
 494  *
 495  * Unicode version of _execlp
 496  */
 497 MSVCRT_intptr_t WINAPIV _wexeclp(const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* arg0, ...)
 498 {
 499   __ms_va_list ap;
 500   MSVCRT_wchar_t *args;
 501   MSVCRT_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(MSVCRT__P_OVERLAY, name, args, NULL, 1);
 508
 509   MSVCRT_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 MSVCRT_intptr_t WINAPIV _execlp(const char* name, const char* arg0, ...)
 520 {
 521   __ms_va_list ap;
 522   MSVCRT_wchar_t *nameW, *args;
 523   MSVCRT_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(MSVCRT__P_OVERLAY, nameW, args, NULL, 1);
 532
 533   MSVCRT_free(nameW);
 534   MSVCRT_free(args);
 535   return ret;
 536 }
 537
 538 /*********************************************************************
 539  *      _wexeclpe (MSVCRT.@)
 540  *
 541  * Unicode version of _execlpe
 542  */
 543 MSVCRT_intptr_t WINAPIV _wexeclpe(const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* arg0, ...)
 544 {
 545   __ms_va_list ap;
 546   MSVCRT_wchar_t *args, *envs = NULL;
 547   const MSVCRT_wchar_t * const *envp;
 548   MSVCRT_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, MSVCRT_wchar_t * ) != NULL) /*nothing*/;
 556   envp = va_arg( ap, const MSVCRT_wchar_t * const * );
 557   if (envp) envs = msvcrt_argvtos(envp, 0);
 558   __ms_va_end(ap);
 559
 560   ret = msvcrt_spawn(MSVCRT__P_OVERLAY, name, args, envs, 1);
 561
 562   MSVCRT_free(args);
 563   MSVCRT_free(envs);
 564   return ret;
 565 }
 566
 567 /*********************************************************************
 568  *              _execlpe (MSVCRT.@)
 569  */
 570 MSVCRT_intptr_t WINAPIV _execlpe(const char* name, const char* arg0, ...)
 571 {
 572   __ms_va_list ap;
 573   MSVCRT_wchar_t *nameW, *args, *envs = NULL;
 574   const char * const *envp;
 575   MSVCRT_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(MSVCRT__P_OVERLAY, nameW, args, envs, 1);
 590
 591   MSVCRT_free(nameW);
 592   MSVCRT_free(args);
 593   MSVCRT_free(envs);
 594   return ret;
 595 }
 596
 597 /*********************************************************************
 598  *      _wexecv (MSVCRT.@)
 599  *
 600  * Unicode version of _execv
 601  */
 602 MSVCRT_intptr_t CDECL _wexecv(const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* const* argv)
 603 {
 604   return MSVCRT__wspawnve(MSVCRT__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 MSVCRT_intptr_t CDECL _execv(const char* name, const char* const* argv)
 614 {
 615   return MSVCRT__spawnve(MSVCRT__P_OVERLAY, name, argv, NULL);
 616 }
 617
 618 /*********************************************************************
 619  *      _wexecve (MSVCRT.@)
 620  *
 621  * Unicode version of _execve
 622  */
 623 MSVCRT_intptr_t CDECL _wexecve(const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* const* argv, const MSVCRT_wchar_t* const* envv)
 624 {
 625   return MSVCRT__wspawnve(MSVCRT__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 MSVCRT_intptr_t CDECL MSVCRT__execve(const char* name, const char* const* argv, const char* const* envv)
 635 {
 636   return MSVCRT__spawnve(MSVCRT__P_OVERLAY, name, argv, envv);
 637 }
 638
 639 /*********************************************************************
 640  *      _wexecvpe (MSVCRT.@)
 641  *
 642  * Unicode version of _execvpe
 643  */
 644 MSVCRT_intptr_t CDECL _wexecvpe(const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* const* argv, const MSVCRT_wchar_t* const* envv)
 645 {
 646   return MSVCRT__wspawnvpe(MSVCRT__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 MSVCRT_intptr_t CDECL _execvpe(const char* name, const char* const* argv, const char* const* envv)
 656 {
 657   return MSVCRT__spawnvpe(MSVCRT__P_OVERLAY, name, argv, envv);
 658 }
 659
 660 /*********************************************************************
 661  *      _wexecvp (MSVCRT.@)
 662  *
 663  * Unicode version of _execvp
 664  */
 665 MSVCRT_intptr_t CDECL _wexecvp(const MSVCRT_wchar_t* name, const MSVCRT_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 MSVCRT_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 MSVCRT_intptr_t WINAPIV _wspawnl(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* arg0, ...)
 687 {
 688   __ms_va_list ap;
 689   MSVCRT_wchar_t *args;
 690   MSVCRT_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   MSVCRT_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 MSVCRT_intptr_t WINAPIV _spawnl(int flags, const char* name, const char* arg0, ...)
 709 {
 710   __ms_va_list ap;
 711   MSVCRT_wchar_t *nameW, *args;
 712   MSVCRT_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   MSVCRT_free(nameW);
 723   MSVCRT_free(args);
 724   return ret;
 725 }
 726
 727 /*********************************************************************
 728  *      _wspawnle (MSVCRT.@)
 729  *
 730  * Unicode version of _spawnle
 731  */
 732 MSVCRT_intptr_t WINAPIV _wspawnle(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* arg0, ...)
 733 {
 734   __ms_va_list ap;
 735   MSVCRT_wchar_t *args, *envs = NULL;
 736   const MSVCRT_wchar_t * const *envp;
 737   MSVCRT_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, MSVCRT_wchar_t * ) != NULL) /*nothing*/;
 745   envp = va_arg( ap, const MSVCRT_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   MSVCRT_free(args);
 752   MSVCRT_free(envs);
 753   return ret;
 754 }
 755
 756 /*********************************************************************
 757  *              _spawnle (MSVCRT.@)
 758  */
 759 MSVCRT_intptr_t WINAPIV _spawnle(int flags, const char* name, const char* arg0, ...)
 760 {
 761   __ms_va_list ap;
 762   MSVCRT_wchar_t *nameW, *args, *envs = NULL;
 763   const char * const *envp;
 764   MSVCRT_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   MSVCRT_free(nameW);
 781   MSVCRT_free(args);
 782   MSVCRT_free(envs);
 783   return ret;
 784 }
 785
 786 /*********************************************************************
 787  *      _wspawnlp (MSVCRT.@)
 788  *
 789  * Unicode version of _spawnlp
 790  */
 791 MSVCRT_intptr_t WINAPIV _wspawnlp(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* arg0, ...)
 792 {
 793   __ms_va_list ap;
 794   MSVCRT_wchar_t *args;
 795   MSVCRT_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   MSVCRT_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 MSVCRT_intptr_t WINAPIV _spawnlp(int flags, const char* name, const char* arg0, ...)
 814 {
 815   __ms_va_list ap;
 816   MSVCRT_wchar_t *nameW, *args;
 817   MSVCRT_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   MSVCRT_free(nameW);
 828   MSVCRT_free(args);
 829   return ret;
 830 }
 831
 832 /*********************************************************************
 833  *      _wspawnlpe (MSVCRT.@)
 834  *
 835  * Unicode version of _spawnlpe
 836  */
 837 MSVCRT_intptr_t WINAPIV _wspawnlpe(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* arg0, ...)
 838 {
 839   __ms_va_list ap;
 840   MSVCRT_wchar_t *args, *envs = NULL;
 841   const MSVCRT_wchar_t * const *envp;
 842   MSVCRT_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, MSVCRT_wchar_t * ) != NULL) /*nothing*/;
 850   envp = va_arg( ap, const MSVCRT_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   MSVCRT_free(args);
 857   MSVCRT_free(envs);
 858   return ret;
 859 }
 860
 861 /*********************************************************************
 862  *              _spawnlpe (MSVCRT.@)
 863  */
 864 MSVCRT_intptr_t WINAPIV _spawnlpe(int flags, const char* name, const char* arg0, ...)
 865 {
 866   __ms_va_list ap;
 867   MSVCRT_wchar_t *nameW, *args, *envs = NULL;
 868   const char * const *envp;
 869   MSVCRT_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   MSVCRT_free(nameW);
 886   MSVCRT_free(args);
 887   MSVCRT_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 MSVCRT_intptr_t CDECL MSVCRT__spawnve(int flags, const char* name, const char* const* argv,
 898                                const char* const* envv)
 899 {
 900   MSVCRT_wchar_t *nameW, *args, *envs;
 901   MSVCRT_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   MSVCRT_free(nameW);
 911   MSVCRT_free(args);
 912   MSVCRT_free(envs);
 913   return ret;
 914 }
 915
 916 /*********************************************************************
 917  *      _wspawnve (MSVCRT.@)
 918  *
 919  * Unicode version of _spawnve
 920  */
 921 MSVCRT_intptr_t CDECL MSVCRT__wspawnve(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* const* argv,
 922                                 const MSVCRT_wchar_t* const* envv)
 923 {
 924   MSVCRT_wchar_t *args, *envs;
 925   MSVCRT_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   MSVCRT_free(args);
 933   MSVCRT_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 MSVCRT_intptr_t CDECL _spawnv(int flags, const char* name, const char* const* argv)
 944 {
 945   return MSVCRT__spawnve(flags, name, argv, NULL);
 946 }
 947
 948 /*********************************************************************
 949  *      _wspawnv (MSVCRT.@)
 950  *
 951  * Unicode version of _spawnv
 952  */
 953 MSVCRT_intptr_t CDECL _wspawnv(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* const* argv)
 954 {
 955   return MSVCRT__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 MSVCRT_intptr_t CDECL MSVCRT__spawnvpe(int flags, const char* name, const char* const* argv,
 965                                 const char* const* envv)
 966 {
 967   MSVCRT_wchar_t *nameW, *args, *envs;
 968   MSVCRT_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   MSVCRT_free(nameW);
 978   MSVCRT_free(args);
 979   MSVCRT_free(envs);
 980   return ret;
 981 }
 982
 983 /*********************************************************************
 984  *      _wspawnvpe (MSVCRT.@)
 985  *
 986  * Unicode version of _spawnvpe
 987  */
 988 MSVCRT_intptr_t CDECL MSVCRT__wspawnvpe(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* const* argv,
 989                                  const MSVCRT_wchar_t* const* envv)
 990 {
 991   MSVCRT_wchar_t *args, *envs;
 992   MSVCRT_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   MSVCRT_free(args);
1000   MSVCRT_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 MSVCRT_intptr_t CDECL _spawnvp(int flags, const char* name, const char* const* argv)
1011 {
1012   return MSVCRT__spawnvpe(flags, name, argv, NULL);
1013 }
1014
1015 /*********************************************************************
1016  *      _wspawnvp (MSVCRT.@)
1017  *
1018  * Unicode version of _spawnvp
1019  */
1020 MSVCRT_intptr_t CDECL _wspawnvp(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* const* argv)
1021 {
1022   return MSVCRT__wspawnvpe(flags, name, argv, NULL);
1023 }
1024
1025 static struct popen_handle {
1026     MSVCRT_FILE *f;
1027     HANDLE proc;
1028 } *popen_handles;
1029 static DWORD popen_handles_size;
1030
1031 void msvcrt_free_popen_data(void)
1032 {
1033     MSVCRT_free(popen_handles);
1034 }
1035
1036 /*********************************************************************
1037  *              _wpopen (MSVCRT.@)
1038  *
1039  * Unicode version of _popen
1040  */
1041 MSVCRT_FILE* CDECL MSVCRT__wpopen(const MSVCRT_wchar_t* command, const MSVCRT_wchar_t* mode)
1042 {
1043   MSVCRT_FILE *ret;
1044   BOOL readPipe = TRUE;
1045   int textmode, fds[2], fdToDup, fdToOpen, fdStdHandle = -1;
1046   const MSVCRT_wchar_t *p;
1047   MSVCRT_wchar_t *comspec, *fullcmd;
1048   unsigned int len;
1049   static const MSVCRT_wchar_t flag[] = {' ','/','c',' ',0};
1050   struct popen_handle *container;
1051   DWORD i;
1052
1053   TRACE("(command=%s, mode=%s)\n", debugstr_w(command), debugstr_w(mode));
1054
1055   if (!command || !mode)
1056     return NULL;
1057
1058   textmode = *__p__fmode() & (MSVCRT__O_BINARY | MSVCRT__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 |= MSVCRT__O_BINARY;
1070         textmode &= ~MSVCRT__O_TEXT;
1071         break;
1072       case 'T':
1073       case 't':
1074         textmode |= MSVCRT__O_TEXT;
1075         textmode &= ~MSVCRT__O_BINARY;
1076         break;
1077     }
1078   }
1079   if (MSVCRT__pipe(fds, 0, textmode) == -1)
1080     return NULL;
1081
1082   fdToDup = readPipe ? 1 : 0;
1083   fdToOpen = readPipe ? 0 : 1;
1084
1085   _mlock(_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 = MSVCRT_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 = MSVCRT__dup(fdToDup)) == -1)
1105     goto error;
1106   if (MSVCRT__dup2(fds[fdToDup], fdToDup) != 0)
1107     goto error;
1108
1109   MSVCRT__close(fds[fdToDup]);
1110
1111   if (!(comspec = msvcrt_get_comspec())) goto error;
1112   len = strlenW(comspec) + strlenW(flag) + strlenW(command) + 1;
1113
1114   if (!(fullcmd = HeapAlloc(GetProcessHeap(), 0, len * sizeof(MSVCRT_wchar_t))))
1115   {
1116     HeapFree(GetProcessHeap(), 0, comspec);
1117     goto error;
1118   }
1119
1120   strcpyW(fullcmd, comspec);
1121   strcatW(fullcmd, flag);
1122   strcatW(fullcmd, command);
1123
1124   if ((container->proc = (HANDLE)msvcrt_spawn(MSVCRT__P_NOWAIT, comspec, fullcmd, NULL, 1))
1125           == INVALID_HANDLE_VALUE)
1126   {
1127     MSVCRT__close(fds[fdToOpen]);
1128     ret = NULL;
1129   }
1130   else
1131   {
1132     ret = MSVCRT__wfdopen(fds[fdToOpen], mode);
1133     if (!ret)
1134       MSVCRT__close(fds[fdToOpen]);
1135     container->f = ret;
1136   }
1137   _munlock(_POPEN_LOCK);
1138   HeapFree(GetProcessHeap(), 0, comspec);
1139   HeapFree(GetProcessHeap(), 0, fullcmd);
1140   MSVCRT__dup2(fdStdHandle, fdToDup);
1141   MSVCRT__close(fdStdHandle);
1142   return ret;
1143
1144 error:
1145   _munlock(_POPEN_LOCK);
1146   if (fdStdHandle != -1) MSVCRT__close(fdStdHandle);
1147   MSVCRT__close(fds[0]);
1148   MSVCRT__close(fds[1]);
1149   return NULL;
1150 }
1151
1152 /*********************************************************************
1153  *      _popen (MSVCRT.@)
1154  */
1155 MSVCRT_FILE* CDECL MSVCRT__popen(const char* command, const char* mode)
1156 {
1157   MSVCRT_FILE *ret;
1158   MSVCRT_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 = MSVCRT__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 MSVCRT__pclose(MSVCRT_FILE* file)
1183 {
1184   HANDLE h;
1185   DWORD i;
1186
1187   if (!MSVCRT_CHECK_PMT(file != NULL)) return -1;
1188
1189   _mlock(_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     _munlock(_POPEN_LOCK);
1198     *MSVCRT__errno() = MSVCRT_EBADF;
1199     return -1;
1200   }
1201
1202   h = popen_handles[i].proc;
1203   popen_handles[i].f = NULL;
1204   _munlock(_POPEN_LOCK);
1205
1206   MSVCRT_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 MSVCRT_wchar_t* cmd)
1224 {
1225   int res;
1226   MSVCRT_wchar_t *comspec, *fullcmd;
1227   unsigned int len;
1228   static const MSVCRT_wchar_t flag[] = {' ','/','c',' ',0};
1229
1230   comspec = msvcrt_get_comspec();
1231
1232   if (cmd == NULL)
1233   {
1234     if (comspec == NULL)
1235     {
1236         *MSVCRT__errno() = MSVCRT_ENOENT;
1237         return 0;
1238     }
1239     HeapFree(GetProcessHeap(), 0, comspec);
1240     return 1;
1241   }
1242
1243   if ( comspec == NULL)
1244     return -1;
1245
1246   len = strlenW(comspec) + strlenW(flag) + strlenW(cmd) + 1;
1247
1248   if (!(fullcmd = HeapAlloc(GetProcessHeap(), 0, len * sizeof(MSVCRT_wchar_t))))
1249   {
1250     HeapFree(GetProcessHeap(), 0, comspec);
1251     return -1;
1252   }
1253   strcpyW(fullcmd, comspec);
1254   strcatW(fullcmd, flag);
1255   strcatW(fullcmd, cmd);
1256
1257   res = msvcrt_spawn(MSVCRT__P_WAIT, comspec, fullcmd, NULL, 1);
1258
1259   HeapFree(GetProcessHeap(), 0, comspec);
1260   HeapFree(GetProcessHeap(), 0, fullcmd);
1261   return res;
1262 }
1263
1264 /*********************************************************************
1265  *              system (MSVCRT.@)
1266  */
1267 int CDECL MSVCRT_system(const char* cmd)
1268 {
1269   int res = -1;
1270   MSVCRT_wchar_t *cmdW;
1271
1272   if (cmd == NULL)
1273     return _wsystem(NULL);
1274
1275   if ((cmdW = msvcrt_wstrdupa(cmd)))
1276   {
1277     res = _wsystem(cmdW);
1278     HeapFree(GetProcessHeap(), 0, cmdW);
1279   }
1280   return res;
1281 }
1282
1283 /*********************************************************************
1284  *              _loaddll (MSVCRT.@)
1285  */
1286 MSVCRT_intptr_t CDECL _loaddll(const char* dllname)
1287 {
1288   return (MSVCRT_intptr_t)LoadLibraryA(dllname);
1289 }
1290
1291 /*********************************************************************
1292  *              _unloaddll (MSVCRT.@)
1293  */
1294 int CDECL _unloaddll(MSVCRT_intptr_t dll)
1295 {
1296   if (FreeLibrary((HMODULE)dll))
1297     return 0;
1298   else
1299   {
1300     int err = GetLastError();
1301     msvcrt_set_errno(err);
1302     return err;
1303   }
1304 }
1305
1306 /*********************************************************************
1307  *              _getdllprocaddr (MSVCRT.@)
1308  */
1309 void * CDECL _getdllprocaddr(MSVCRT_intptr_t dll, const char *name, int ordinal)
1310 {
1311     if (name)
1312     {
1313         if (ordinal != -1) return NULL;
1314         return GetProcAddress( (HMODULE)dll, name );
1315     }
1316     if (HIWORD(ordinal)) return NULL;
1317     return GetProcAddress( (HMODULE)dll, (LPCSTR)(ULONG_PTR)ordinal );
1318 }
1319
1320 /*********************************************************************
1321  *              _getpid (MSVCRT.@)
1322  */
1323 int CDECL _getpid(void)
1324 {
1325     return GetCurrentProcessId();
1326 }
1327
1328 /*********************************************************************
1329  *  __crtTerminateProcess (MSVCR110.@)
1330  */
1331 int CDECL MSVCR110__crtTerminateProcess(UINT exit_code)
1332 {
1333     return TerminateProcess(GetCurrentProcess(), exit_code);
1334 }