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
 138   TRACE("%x %s %s %s %d\n", flags, debugstr_w(exe), debugstr_w(cmdline), debugstr_w(env), use_path);
 139
 140   if ((unsigned)flags > MSVCRT__P_DETACH)
 141   {
 142     *MSVCRT__errno() = MSVCRT_EINVAL;
 143     return -1;
 144   }
 145
 146   msvcrt_search_executable(exe, fullname, use_path);
 147
 148   memset(&si, 0, sizeof(si));
 149   si.cb = sizeof(si);
 150   msvcrt_create_io_inherit_block(&si.cbReserved2, &si.lpReserved2);
 151   if (!CreateProcessW(fullname, cmdline, NULL, NULL, TRUE,
 152                      flags == MSVCRT__P_DETACH ? DETACHED_PROCESS : 0,
 153                      env, NULL, &si, &pi))
 154   {
 155     msvcrt_set_errno(GetLastError());
 156     MSVCRT_free(si.lpReserved2);
 157     return -1;
 158   }
 159
 160   MSVCRT_free(si.lpReserved2);
 161   switch(flags)
 162   {
 163   case MSVCRT__P_WAIT:
 164     WaitForSingleObject(pi.hProcess, INFINITE);
 165     GetExitCodeProcess(pi.hProcess,&pi.dwProcessId);
 166     CloseHandle(pi.hProcess);
 167     CloseHandle(pi.hThread);
 168     return pi.dwProcessId;
 169   case MSVCRT__P_DETACH:
 170     CloseHandle(pi.hProcess);
 171     pi.hProcess = 0;
 172     /* fall through */
 173   case MSVCRT__P_NOWAIT:
 174   case MSVCRT__P_NOWAITO:
 175     CloseHandle(pi.hThread);
 176     return (MSVCRT_intptr_t)pi.hProcess;
 177   case  MSVCRT__P_OVERLAY:
 178     MSVCRT__exit(0);
 179   }
 180   return -1; /* can't reach here */
 181 }
 182
 183 /* INTERNAL: Convert wide argv list to a single 'delim'-separated wide string, with an
 184  * extra '\0' to terminate it.
 185  */
 186 static MSVCRT_wchar_t* msvcrt_argvtos(const MSVCRT_wchar_t* const* arg, MSVCRT_wchar_t delim)
 187 {
 188   const MSVCRT_wchar_t* const* a;
 189   int size;
 190   MSVCRT_wchar_t* p;
 191   MSVCRT_wchar_t* ret;
 192
 193   if (!arg)
 194   {
 195       /* Return NULL for an empty environment list */
 196       return NULL;
 197   }
 198
 199   /* get length */
 200   a = arg;
 201   size = 0;
 202   while (*a)
 203   {
 204     size += strlenW(*a) + 1;
 205     a++;
 206   }
 207
 208   ret = MSVCRT_malloc((size + 1) * sizeof(MSVCRT_wchar_t));
 209   if (!ret)
 210     return NULL;
 211
 212   /* fill string */
 213   a = arg;
 214   p = ret;
 215   while (*a)
 216   {
 217     int len = strlenW(*a);
 218     memcpy(p,*a,len * sizeof(MSVCRT_wchar_t));
 219     p += len;
 220     *p++ = delim;
 221     a++;
 222   }
 223   if (delim && p > ret) p[-1] = 0;
 224   else *p = 0;
 225   return ret;
 226 }
 227
 228 /* INTERNAL: Convert ansi argv list to a single 'delim'-separated wide string, with an
 229  * extra '\0' to terminate it.
 230  */
 231 static MSVCRT_wchar_t *msvcrt_argvtos_aw(const char * const *arg, MSVCRT_wchar_t delim)
 232 {
 233   const char * const *a;
 234   unsigned int len;
 235   MSVCRT_wchar_t *p, *ret;
 236
 237   if (!arg)
 238   {
 239       /* Return NULL for an empty environment list */
 240       return NULL;
 241   }
 242
 243   /* get length */
 244   a = arg;
 245   len = 0;
 246   while (*a)
 247   {
 248     len += MultiByteToWideChar(CP_ACP, 0, *a, -1, NULL, 0);
 249     a++;
 250   }
 251
 252   ret = MSVCRT_malloc((len + 1) * sizeof(MSVCRT_wchar_t));
 253   if (!ret)
 254     return NULL;
 255
 256   /* fill string */
 257   a = arg;
 258   p = ret;
 259   while (*a)
 260   {
 261     p += MultiByteToWideChar(CP_ACP, 0, *a, strlen(*a), p, len - (p - ret));
 262     *p++ = delim;
 263     a++;
 264   }
 265   if (delim && p > ret) p[-1] = 0;
 266   else *p = 0;
 267   return ret;
 268 }
 269
 270 /* INTERNAL: Convert wide va_list to a single 'delim'-separated wide string, with an
 271  * extra '\0' to terminate it.
 272  */
 273 static MSVCRT_wchar_t *msvcrt_valisttos(const MSVCRT_wchar_t *arg0, __ms_va_list alist, MSVCRT_wchar_t delim)
 274 {
 275     unsigned int size = 0, pos = 0;
 276     const MSVCRT_wchar_t *arg;
 277     MSVCRT_wchar_t *new, *ret = NULL;
 278
 279     for (arg = arg0; arg; arg = va_arg( alist, MSVCRT_wchar_t * ))
 280     {
 281         unsigned int len = strlenW( arg ) + 1;
 282         if (pos + len >= size)
 283         {
 284             size = max( 256, size * 2 );
 285             size = max( size, pos + len + 1 );
 286             if (!(new = MSVCRT_realloc( ret, size * sizeof(MSVCRT_wchar_t) )))
 287             {
 288                 MSVCRT_free( ret );
 289                 return NULL;
 290             }
 291             ret = new;
 292         }
 293         strcpyW( ret + pos, arg );
 294         pos += len;
 295         ret[pos - 1] = delim;
 296     }
 297     if (pos)
 298     {
 299         if (delim) ret[pos - 1] = 0;
 300         else ret[pos] = 0;
 301     }
 302     return ret;
 303 }
 304
 305 /* INTERNAL: Convert ansi va_list to a single 'delim'-separated wide string, with an
 306  * extra '\0' to terminate it.
 307  */
 308 static MSVCRT_wchar_t *msvcrt_valisttos_aw(const char *arg0, __ms_va_list alist, MSVCRT_wchar_t delim)
 309 {
 310     unsigned int size = 0, pos = 0;
 311     const char *arg;
 312     MSVCRT_wchar_t *new, *ret = NULL;
 313
 314     for (arg = arg0; arg; arg = va_arg( alist, char * ))
 315     {
 316         unsigned int len = MultiByteToWideChar( CP_ACP, 0, arg, -1, NULL, 0 );
 317         if (pos + len >= size)
 318         {
 319             size = max( 256, size * 2 );
 320             size = max( size, pos + len + 1 );
 321             if (!(new = MSVCRT_realloc( ret, size * sizeof(MSVCRT_wchar_t) )))
 322             {
 323                 MSVCRT_free( ret );
 324                 return NULL;
 325             }
 326             ret = new;
 327         }
 328         pos += MultiByteToWideChar( CP_ACP, 0, arg, -1, ret + pos, size - pos );
 329         ret[pos - 1] = delim;
 330     }
 331     if (pos)
 332     {
 333         if (delim) ret[pos - 1] = 0;
 334         else ret[pos] = 0;
 335     }
 336     return ret;
 337 }
 338
 339 /* INTERNAL: retrieve COMSPEC environment variable */
 340 static MSVCRT_wchar_t *msvcrt_get_comspec(void)
 341 {
 342   static const MSVCRT_wchar_t cmd[] = {'c','m','d',0};
 343   static const MSVCRT_wchar_t comspec[] = {'C','O','M','S','P','E','C',0};
 344   MSVCRT_wchar_t *ret;
 345   unsigned int len;
 346
 347   if (!(len = GetEnvironmentVariableW(comspec, NULL, 0))) len = sizeof(cmd)/sizeof(MSVCRT_wchar_t);
 348   if ((ret = HeapAlloc(GetProcessHeap(), 0, len * sizeof(MSVCRT_wchar_t))))
 349   {
 350     if (!GetEnvironmentVariableW(comspec, ret, len)) strcpyW(ret, cmd);
 351   }
 352   return ret;
 353 }
 354
 355 /*********************************************************************
 356  *              _cwait (MSVCRT.@)
 357  */
 358 MSVCRT_intptr_t CDECL _cwait(int *status, MSVCRT_intptr_t pid, int action)
 359 {
 360   HANDLE hPid = (HANDLE)pid;
 361   int doserrno;
 362
 363   if (!WaitForSingleObject(hPid, INFINITE))
 364   {
 365     if (status)
 366     {
 367       DWORD stat;
 368       GetExitCodeProcess(hPid, &stat);
 369       *status = (int)stat;
 370     }
 371     return pid;
 372   }
 373   doserrno = GetLastError();
 374
 375   if (doserrno == ERROR_INVALID_HANDLE)
 376   {
 377     *MSVCRT__errno() =  MSVCRT_ECHILD;
 378     *MSVCRT___doserrno() = doserrno;
 379   }
 380   else
 381     msvcrt_set_errno(doserrno);
 382
 383   return status ? *status = -1 : -1;
 384 }
 385
 386 /*********************************************************************
 387  *      _wexecl (MSVCRT.@)
 388  *
 389  * Unicode version of _execl
 390  */
 391 MSVCRT_intptr_t CDECL _wexecl(const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* arg0, ...)
 392 {
 393   __ms_va_list ap;
 394   MSVCRT_wchar_t *args;
 395   MSVCRT_intptr_t ret;
 396
 397   __ms_va_start(ap, arg0);
 398   args = msvcrt_valisttos(arg0, ap, ' ');
 399   __ms_va_end(ap);
 400
 401   ret = msvcrt_spawn(MSVCRT__P_OVERLAY, name, args, NULL, 0);
 402
 403   MSVCRT_free(args);
 404   return ret;
 405 }
 406
 407 /*********************************************************************
 408  *              _execl (MSVCRT.@)
 409  *
 410  * Like on Windows, this function does not handle arguments with spaces
 411  * or double-quotes.
 412  */
 413 MSVCRT_intptr_t CDECL _execl(const char* name, const char* arg0, ...)
 414 {
 415   __ms_va_list ap;
 416   MSVCRT_wchar_t *nameW, *args;
 417   MSVCRT_intptr_t ret;
 418
 419   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 420
 421   __ms_va_start(ap, arg0);
 422   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 423   __ms_va_end(ap);
 424
 425   ret = msvcrt_spawn(MSVCRT__P_OVERLAY, nameW, args, NULL, 0);
 426
 427   MSVCRT_free(nameW);
 428   MSVCRT_free(args);
 429   return ret;
 430 }
 431
 432 /*********************************************************************
 433  *      _wexecle (MSVCRT.@)
 434  *
 435  * Unicode version of _execle
 436  */
 437 MSVCRT_intptr_t CDECL _wexecle(const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* arg0, ...)
 438 {
 439   __ms_va_list ap;
 440   MSVCRT_wchar_t *args, *envs = NULL;
 441   const MSVCRT_wchar_t * const *envp;
 442   MSVCRT_intptr_t ret;
 443
 444   __ms_va_start(ap, arg0);
 445   args = msvcrt_valisttos(arg0, ap, ' ');
 446   __ms_va_end(ap);
 447
 448   __ms_va_start(ap, arg0);
 449   while (va_arg( ap, MSVCRT_wchar_t * ) != NULL) /*nothing*/;
 450   envp = va_arg( ap, const MSVCRT_wchar_t * const * );
 451   if (envp) envs = msvcrt_argvtos(envp, 0);
 452   __ms_va_end(ap);
 453
 454   ret = msvcrt_spawn(MSVCRT__P_OVERLAY, name, args, envs, 0);
 455
 456   MSVCRT_free(args);
 457   MSVCRT_free(envs);
 458   return ret;
 459 }
 460
 461 /*********************************************************************
 462  *              _execle (MSVCRT.@)
 463  */
 464 MSVCRT_intptr_t CDECL _execle(const char* name, const char* arg0, ...)
 465 {
 466   __ms_va_list ap;
 467   MSVCRT_wchar_t *nameW, *args, *envs = NULL;
 468   const char * const *envp;
 469   MSVCRT_intptr_t ret;
 470
 471   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 472
 473   __ms_va_start(ap, arg0);
 474   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 475   __ms_va_end(ap);
 476
 477   __ms_va_start(ap, arg0);
 478   while (va_arg( ap, char * ) != NULL) /*nothing*/;
 479   envp = va_arg( ap, const char * const * );
 480   if (envp) envs = msvcrt_argvtos_aw(envp, 0);
 481   __ms_va_end(ap);
 482
 483   ret = msvcrt_spawn(MSVCRT__P_OVERLAY, nameW, args, envs, 0);
 484
 485   MSVCRT_free(nameW);
 486   MSVCRT_free(args);
 487   MSVCRT_free(envs);
 488   return ret;
 489 }
 490
 491 /*********************************************************************
 492  *      _wexeclp (MSVCRT.@)
 493  *
 494  * Unicode version of _execlp
 495  */
 496 MSVCRT_intptr_t CDECL _wexeclp(const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* arg0, ...)
 497 {
 498   __ms_va_list ap;
 499   MSVCRT_wchar_t *args;
 500   MSVCRT_intptr_t ret;
 501
 502   __ms_va_start(ap, arg0);
 503   args = msvcrt_valisttos(arg0, ap, ' ');
 504   __ms_va_end(ap);
 505
 506   ret = msvcrt_spawn(MSVCRT__P_OVERLAY, name, args, NULL, 1);
 507
 508   MSVCRT_free(args);
 509   return ret;
 510 }
 511
 512 /*********************************************************************
 513  *              _execlp (MSVCRT.@)
 514  *
 515  * Like on Windows, this function does not handle arguments with spaces
 516  * or double-quotes.
 517  */
 518 MSVCRT_intptr_t CDECL _execlp(const char* name, const char* arg0, ...)
 519 {
 520   __ms_va_list ap;
 521   MSVCRT_wchar_t *nameW, *args;
 522   MSVCRT_intptr_t ret;
 523
 524   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 525
 526   __ms_va_start(ap, arg0);
 527   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 528   __ms_va_end(ap);
 529
 530   ret = msvcrt_spawn(MSVCRT__P_OVERLAY, nameW, args, NULL, 1);
 531
 532   MSVCRT_free(nameW);
 533   MSVCRT_free(args);
 534   return ret;
 535 }
 536
 537 /*********************************************************************
 538  *      _wexeclpe (MSVCRT.@)
 539  *
 540  * Unicode version of _execlpe
 541  */
 542 MSVCRT_intptr_t CDECL _wexeclpe(const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* arg0, ...)
 543 {
 544   __ms_va_list ap;
 545   MSVCRT_wchar_t *args, *envs = NULL;
 546   const MSVCRT_wchar_t * const *envp;
 547   MSVCRT_intptr_t ret;
 548
 549   __ms_va_start(ap, arg0);
 550   args = msvcrt_valisttos(arg0, ap, ' ');
 551   __ms_va_end(ap);
 552
 553   __ms_va_start(ap, arg0);
 554   while (va_arg( ap, MSVCRT_wchar_t * ) != NULL) /*nothing*/;
 555   envp = va_arg( ap, const MSVCRT_wchar_t * const * );
 556   if (envp) envs = msvcrt_argvtos(envp, 0);
 557   __ms_va_end(ap);
 558
 559   ret = msvcrt_spawn(MSVCRT__P_OVERLAY, name, args, envs, 1);
 560
 561   MSVCRT_free(args);
 562   MSVCRT_free(envs);
 563   return ret;
 564 }
 565
 566 /*********************************************************************
 567  *              _execlpe (MSVCRT.@)
 568  */
 569 MSVCRT_intptr_t CDECL _execlpe(const char* name, const char* arg0, ...)
 570 {
 571   __ms_va_list ap;
 572   MSVCRT_wchar_t *nameW, *args, *envs = NULL;
 573   const char * const *envp;
 574   MSVCRT_intptr_t ret;
 575
 576   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 577
 578   __ms_va_start(ap, arg0);
 579   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 580   __ms_va_end(ap);
 581
 582   __ms_va_start(ap, arg0);
 583   while (va_arg( ap, char * ) != NULL) /*nothing*/;
 584   envp = va_arg( ap, const char * const * );
 585   if (envp) envs = msvcrt_argvtos_aw(envp, 0);
 586   __ms_va_end(ap);
 587
 588   ret = msvcrt_spawn(MSVCRT__P_OVERLAY, nameW, args, envs, 1);
 589
 590   MSVCRT_free(nameW);
 591   MSVCRT_free(args);
 592   MSVCRT_free(envs);
 593   return ret;
 594 }
 595
 596 /*********************************************************************
 597  *      _wexecv (MSVCRT.@)
 598  *
 599  * Unicode version of _execv
 600  */
 601 MSVCRT_intptr_t CDECL _wexecv(const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* const* argv)
 602 {
 603   return MSVCRT__wspawnve(MSVCRT__P_OVERLAY, name, argv, NULL);
 604 }
 605
 606 /*********************************************************************
 607  *              _execv (MSVCRT.@)
 608  *
 609  * Like on Windows, this function does not handle arguments with spaces
 610  * or double-quotes.
 611  */
 612 MSVCRT_intptr_t CDECL _execv(const char* name, const char* const* argv)
 613 {
 614   return MSVCRT__spawnve(MSVCRT__P_OVERLAY, name, argv, NULL);
 615 }
 616
 617 /*********************************************************************
 618  *      _wexecve (MSVCRT.@)
 619  *
 620  * Unicode version of _execve
 621  */
 622 MSVCRT_intptr_t CDECL _wexecve(const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* const* argv, const MSVCRT_wchar_t* const* envv)
 623 {
 624   return MSVCRT__wspawnve(MSVCRT__P_OVERLAY, name, argv, envv);
 625 }
 626
 627 /*********************************************************************
 628  *              _execve (MSVCRT.@)
 629  *
 630  * Like on Windows, this function does not handle arguments with spaces
 631  * or double-quotes.
 632  */
 633 MSVCRT_intptr_t CDECL MSVCRT__execve(const char* name, const char* const* argv, const char* const* envv)
 634 {
 635   return MSVCRT__spawnve(MSVCRT__P_OVERLAY, name, argv, envv);
 636 }
 637
 638 /*********************************************************************
 639  *      _wexecvpe (MSVCRT.@)
 640  *
 641  * Unicode version of _execvpe
 642  */
 643 MSVCRT_intptr_t CDECL _wexecvpe(const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* const* argv, const MSVCRT_wchar_t* const* envv)
 644 {
 645   return MSVCRT__wspawnvpe(MSVCRT__P_OVERLAY, name, argv, envv);
 646 }
 647
 648 /*********************************************************************
 649  *              _execvpe (MSVCRT.@)
 650  *
 651  * Like on Windows, this function does not handle arguments with spaces
 652  * or double-quotes.
 653  */
 654 MSVCRT_intptr_t CDECL _execvpe(const char* name, const char* const* argv, const char* const* envv)
 655 {
 656   return MSVCRT__spawnvpe(MSVCRT__P_OVERLAY, name, argv, envv);
 657 }
 658
 659 /*********************************************************************
 660  *      _wexecvp (MSVCRT.@)
 661  *
 662  * Unicode version of _execvp
 663  */
 664 MSVCRT_intptr_t CDECL _wexecvp(const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* const* argv)
 665 {
 666   return _wexecvpe(name, argv, NULL);
 667 }
 668
 669 /*********************************************************************
 670  *              _execvp (MSVCRT.@)
 671  *
 672  * Like on Windows, this function does not handle arguments with spaces
 673  * or double-quotes.
 674  */
 675 MSVCRT_intptr_t CDECL _execvp(const char* name, const char* const* argv)
 676 {
 677   return _execvpe(name, argv, NULL);
 678 }
 679
 680 /*********************************************************************
 681  *      _wspawnl (MSVCRT.@)
 682  *
 683  * Unicode version of _spawnl
 684  */
 685 MSVCRT_intptr_t CDECL _wspawnl(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* arg0, ...)
 686 {
 687   __ms_va_list ap;
 688   MSVCRT_wchar_t *args;
 689   MSVCRT_intptr_t ret;
 690
 691   __ms_va_start(ap, arg0);
 692   args = msvcrt_valisttos(arg0, ap, ' ');
 693   __ms_va_end(ap);
 694
 695   ret = msvcrt_spawn(flags, name, args, NULL, 0);
 696
 697   MSVCRT_free(args);
 698   return ret;
 699 }
 700
 701 /*********************************************************************
 702  *              _spawnl (MSVCRT.@)
 703  *
 704  * Like on Windows, this function does not handle arguments with spaces
 705  * or double-quotes.
 706  */
 707 MSVCRT_intptr_t CDECL _spawnl(int flags, const char* name, const char* arg0, ...)
 708 {
 709   __ms_va_list ap;
 710   MSVCRT_wchar_t *nameW, *args;
 711   MSVCRT_intptr_t ret;
 712
 713   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 714
 715   __ms_va_start(ap, arg0);
 716   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 717   __ms_va_end(ap);
 718
 719   ret = msvcrt_spawn(flags, nameW, args, NULL, 0);
 720
 721   MSVCRT_free(nameW);
 722   MSVCRT_free(args);
 723   return ret;
 724 }
 725
 726 /*********************************************************************
 727  *      _wspawnle (MSVCRT.@)
 728  *
 729  * Unicode version of _spawnle
 730  */
 731 MSVCRT_intptr_t CDECL _wspawnle(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* arg0, ...)
 732 {
 733   __ms_va_list ap;
 734   MSVCRT_wchar_t *args, *envs = NULL;
 735   const MSVCRT_wchar_t * const *envp;
 736   MSVCRT_intptr_t ret;
 737
 738   __ms_va_start(ap, arg0);
 739   args = msvcrt_valisttos(arg0, ap, ' ');
 740   __ms_va_end(ap);
 741
 742   __ms_va_start(ap, arg0);
 743   while (va_arg( ap, MSVCRT_wchar_t * ) != NULL) /*nothing*/;
 744   envp = va_arg( ap, const MSVCRT_wchar_t * const * );
 745   if (envp) envs = msvcrt_argvtos(envp, 0);
 746   __ms_va_end(ap);
 747
 748   ret = msvcrt_spawn(flags, name, args, envs, 0);
 749
 750   MSVCRT_free(args);
 751   MSVCRT_free(envs);
 752   return ret;
 753 }
 754
 755 /*********************************************************************
 756  *              _spawnle (MSVCRT.@)
 757  */
 758 MSVCRT_intptr_t CDECL _spawnle(int flags, const char* name, const char* arg0, ...)
 759 {
 760   __ms_va_list ap;
 761   MSVCRT_wchar_t *nameW, *args, *envs = NULL;
 762   const char * const *envp;
 763   MSVCRT_intptr_t ret;
 764
 765   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 766
 767   __ms_va_start(ap, arg0);
 768   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 769   __ms_va_end(ap);
 770
 771   __ms_va_start(ap, arg0);
 772   while (va_arg( ap, char * ) != NULL) /*nothing*/;
 773   envp = va_arg( ap, const char * const * );
 774   if (envp) envs = msvcrt_argvtos_aw(envp, 0);
 775   __ms_va_end(ap);
 776
 777   ret = msvcrt_spawn(flags, nameW, args, envs, 0);
 778
 779   MSVCRT_free(nameW);
 780   MSVCRT_free(args);
 781   MSVCRT_free(envs);
 782   return ret;
 783 }
 784
 785 /*********************************************************************
 786  *      _wspawnlp (MSVCRT.@)
 787  *
 788  * Unicode version of _spawnlp
 789  */
 790 MSVCRT_intptr_t CDECL _wspawnlp(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* arg0, ...)
 791 {
 792   __ms_va_list ap;
 793   MSVCRT_wchar_t *args;
 794   MSVCRT_intptr_t ret;
 795
 796   __ms_va_start(ap, arg0);
 797   args = msvcrt_valisttos(arg0, ap, ' ');
 798   __ms_va_end(ap);
 799
 800   ret = msvcrt_spawn(flags, name, args, NULL, 1);
 801
 802   MSVCRT_free(args);
 803   return ret;
 804 }
 805
 806 /*********************************************************************
 807  *              _spawnlp (MSVCRT.@)
 808  *
 809  * Like on Windows, this function does not handle arguments with spaces
 810  * or double-quotes.
 811  */
 812 MSVCRT_intptr_t CDECL _spawnlp(int flags, const char* name, const char* arg0, ...)
 813 {
 814   __ms_va_list ap;
 815   MSVCRT_wchar_t *nameW, *args;
 816   MSVCRT_intptr_t ret;
 817
 818   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 819
 820   __ms_va_start(ap, arg0);
 821   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 822   __ms_va_end(ap);
 823
 824   ret = msvcrt_spawn(flags, nameW, args, NULL, 1);
 825
 826   MSVCRT_free(nameW);
 827   MSVCRT_free(args);
 828   return ret;
 829 }
 830
 831 /*********************************************************************
 832  *      _wspawnlpe (MSVCRT.@)
 833  *
 834  * Unicode version of _spawnlpe
 835  */
 836 MSVCRT_intptr_t CDECL _wspawnlpe(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* arg0, ...)
 837 {
 838   __ms_va_list ap;
 839   MSVCRT_wchar_t *args, *envs = NULL;
 840   const MSVCRT_wchar_t * const *envp;
 841   MSVCRT_intptr_t ret;
 842
 843   __ms_va_start(ap, arg0);
 844   args = msvcrt_valisttos(arg0, ap, ' ');
 845   __ms_va_end(ap);
 846
 847   __ms_va_start(ap, arg0);
 848   while (va_arg( ap, MSVCRT_wchar_t * ) != NULL) /*nothing*/;
 849   envp = va_arg( ap, const MSVCRT_wchar_t * const * );
 850   if (envp) envs = msvcrt_argvtos(envp, 0);
 851   __ms_va_end(ap);
 852
 853   ret = msvcrt_spawn(flags, name, args, envs, 1);
 854
 855   MSVCRT_free(args);
 856   MSVCRT_free(envs);
 857   return ret;
 858 }
 859
 860 /*********************************************************************
 861  *              _spawnlpe (MSVCRT.@)
 862  */
 863 MSVCRT_intptr_t CDECL _spawnlpe(int flags, const char* name, const char* arg0, ...)
 864 {
 865   __ms_va_list ap;
 866   MSVCRT_wchar_t *nameW, *args, *envs = NULL;
 867   const char * const *envp;
 868   MSVCRT_intptr_t ret;
 869
 870   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 871
 872   __ms_va_start(ap, arg0);
 873   args = msvcrt_valisttos_aw(arg0, ap, ' ');
 874   __ms_va_end(ap);
 875
 876   __ms_va_start(ap, arg0);
 877   while (va_arg( ap, char * ) != NULL) /*nothing*/;
 878   envp = va_arg( ap, const char * const * );
 879   if (envp) envs = msvcrt_argvtos_aw(envp, 0);
 880   __ms_va_end(ap);
 881
 882   ret = msvcrt_spawn(flags, nameW, args, envs, 1);
 883
 884   MSVCRT_free(nameW);
 885   MSVCRT_free(args);
 886   MSVCRT_free(envs);
 887   return ret;
 888 }
 889
 890 /*********************************************************************
 891  *              _spawnve (MSVCRT.@)
 892  *
 893  * Like on Windows, this function does not handle arguments with spaces
 894  * or double-quotes.
 895  */
 896 MSVCRT_intptr_t CDECL MSVCRT__spawnve(int flags, const char* name, const char* const* argv,
 897                                const char* const* envv)
 898 {
 899   MSVCRT_wchar_t *nameW, *args, *envs;
 900   MSVCRT_intptr_t ret;
 901
 902   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 903
 904   args = msvcrt_argvtos_aw(argv, ' ');
 905   envs = msvcrt_argvtos_aw(envv, 0);
 906
 907   ret = msvcrt_spawn(flags, nameW, args, envs, 0);
 908
 909   MSVCRT_free(nameW);
 910   MSVCRT_free(args);
 911   MSVCRT_free(envs);
 912   return ret;
 913 }
 914
 915 /*********************************************************************
 916  *      _wspawnve (MSVCRT.@)
 917  *
 918  * Unicode version of _spawnve
 919  */
 920 MSVCRT_intptr_t CDECL MSVCRT__wspawnve(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* const* argv,
 921                                 const MSVCRT_wchar_t* const* envv)
 922 {
 923   MSVCRT_wchar_t *args, *envs;
 924   MSVCRT_intptr_t ret;
 925
 926   args = msvcrt_argvtos(argv, ' ');
 927   envs = msvcrt_argvtos(envv, 0);
 928
 929   ret = msvcrt_spawn(flags, name, args, envs, 0);
 930
 931   MSVCRT_free(args);
 932   MSVCRT_free(envs);
 933   return ret;
 934 }
 935
 936 /*********************************************************************
 937  *              _spawnv (MSVCRT.@)
 938  *
 939  * Like on Windows, this function does not handle arguments with spaces
 940  * or double-quotes.
 941  */
 942 MSVCRT_intptr_t CDECL _spawnv(int flags, const char* name, const char* const* argv)
 943 {
 944   return MSVCRT__spawnve(flags, name, argv, NULL);
 945 }
 946
 947 /*********************************************************************
 948  *      _wspawnv (MSVCRT.@)
 949  *
 950  * Unicode version of _spawnv
 951  */
 952 MSVCRT_intptr_t CDECL _wspawnv(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* const* argv)
 953 {
 954   return MSVCRT__wspawnve(flags, name, argv, NULL);
 955 }
 956
 957 /*********************************************************************
 958  *              _spawnvpe (MSVCRT.@)
 959  *
 960  * Like on Windows, this function does not handle arguments with spaces
 961  * or double-quotes.
 962  */
 963 MSVCRT_intptr_t CDECL MSVCRT__spawnvpe(int flags, const char* name, const char* const* argv,
 964                                 const char* const* envv)
 965 {
 966   MSVCRT_wchar_t *nameW, *args, *envs;
 967   MSVCRT_intptr_t ret;
 968
 969   if (!(nameW = msvcrt_wstrdupa(name))) return -1;
 970
 971   args = msvcrt_argvtos_aw(argv, ' ');
 972   envs = msvcrt_argvtos_aw(envv, 0);
 973
 974   ret = msvcrt_spawn(flags, nameW, args, envs, 1);
 975
 976   MSVCRT_free(nameW);
 977   MSVCRT_free(args);
 978   MSVCRT_free(envs);
 979   return ret;
 980 }
 981
 982 /*********************************************************************
 983  *      _wspawnvpe (MSVCRT.@)
 984  *
 985  * Unicode version of _spawnvpe
 986  */
 987 MSVCRT_intptr_t CDECL MSVCRT__wspawnvpe(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* const* argv,
 988                                  const MSVCRT_wchar_t* const* envv)
 989 {
 990   MSVCRT_wchar_t *args, *envs;
 991   MSVCRT_intptr_t ret;
 992
 993   args = msvcrt_argvtos(argv, ' ');
 994   envs = msvcrt_argvtos(envv, 0);
 995
 996   ret = msvcrt_spawn(flags, name, args, envs, 1);
 997
 998   MSVCRT_free(args);
 999   MSVCRT_free(envs);
1000   return ret;
1001 }
1002
1003 /*********************************************************************
1004  *              _spawnvp (MSVCRT.@)
1005  *
1006  * Like on Windows, this function does not handle arguments with spaces
1007  * or double-quotes.
1008  */
1009 MSVCRT_intptr_t CDECL _spawnvp(int flags, const char* name, const char* const* argv)
1010 {
1011   return MSVCRT__spawnvpe(flags, name, argv, NULL);
1012 }
1013
1014 /*********************************************************************
1015  *      _wspawnvp (MSVCRT.@)
1016  *
1017  * Unicode version of _spawnvp
1018  */
1019 MSVCRT_intptr_t CDECL _wspawnvp(int flags, const MSVCRT_wchar_t* name, const MSVCRT_wchar_t* const* argv)
1020 {
1021   return MSVCRT__wspawnvpe(flags, name, argv, NULL);
1022 }
1023
1024 static struct popen_handle {
1025     MSVCRT_FILE *f;
1026     HANDLE proc;
1027 } *popen_handles;
1028 static DWORD popen_handles_size;
1029
1030 void msvcrt_free_popen_data(void)
1031 {
1032     MSVCRT_free(popen_handles);
1033 }
1034
1035 /*********************************************************************
1036  *              _wpopen (MSVCRT.@)
1037  *
1038  * Unicode version of _popen
1039  */
1040 MSVCRT_FILE* CDECL MSVCRT__wpopen(const MSVCRT_wchar_t* command, const MSVCRT_wchar_t* mode)
1041 {
1042   MSVCRT_FILE *ret;
1043   BOOL readPipe = TRUE;
1044   int textmode, fds[2], fdToDup, fdToOpen, fdStdHandle = -1;
1045   const MSVCRT_wchar_t *p;
1046   MSVCRT_wchar_t *comspec, *fullcmd;
1047   unsigned int len;
1048   static const MSVCRT_wchar_t flag[] = {' ','/','c',' ',0};
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   textmode = *__p__fmode() & (MSVCRT__O_BINARY | MSVCRT__O_TEXT);
1058   for (p = mode; *p; p++)
1059   {
1060     switch (*p)
1061     {
1062       case 'W':
1063       case 'w':
1064         readPipe = FALSE;
1065         break;
1066       case 'B':
1067       case 'b':
1068         textmode |= MSVCRT__O_BINARY;
1069         textmode &= ~MSVCRT__O_TEXT;
1070         break;
1071       case 'T':
1072       case 't':
1073         textmode |= MSVCRT__O_TEXT;
1074         textmode &= ~MSVCRT__O_BINARY;
1075         break;
1076     }
1077   }
1078   if (MSVCRT__pipe(fds, 0, textmode) == -1)
1079     return NULL;
1080
1081   fdToDup = readPipe ? 1 : 0;
1082   fdToOpen = readPipe ? 0 : 1;
1083
1084   _mlock(_POPEN_LOCK);
1085   for(i=0; i<popen_handles_size; i++)
1086   {
1087     if (!popen_handles[i].f)
1088       break;
1089   }
1090   if (i==popen_handles_size)
1091   {
1092     i = (popen_handles_size ? popen_handles_size*2 : 8);
1093     container = MSVCRT_realloc(popen_handles, i*sizeof(*container));
1094     if (!container) goto error;
1095
1096     popen_handles = container;
1097     container = popen_handles+popen_handles_size;
1098     memset(container, 0, (i-popen_handles_size)*sizeof(*container));
1099     popen_handles_size = i;
1100   }
1101   else container = popen_handles+i;
1102
1103   if ((fdStdHandle = MSVCRT__dup(fdToDup)) == -1)
1104     goto error;
1105   if (MSVCRT__dup2(fds[fdToDup], fdToDup) != 0)
1106     goto error;
1107
1108   MSVCRT__close(fds[fdToDup]);
1109
1110   if (!(comspec = msvcrt_get_comspec())) goto error;
1111   len = strlenW(comspec) + strlenW(flag) + strlenW(command) + 1;
1112
1113   if (!(fullcmd = HeapAlloc(GetProcessHeap(), 0, len * sizeof(MSVCRT_wchar_t))))
1114   {
1115     HeapFree(GetProcessHeap(), 0, comspec);
1116     goto error;
1117   }
1118
1119   strcpyW(fullcmd, comspec);
1120   strcatW(fullcmd, flag);
1121   strcatW(fullcmd, command);
1122
1123   if ((container->proc = (HANDLE)msvcrt_spawn(MSVCRT__P_NOWAIT, comspec, fullcmd, NULL, 1))
1124           == INVALID_HANDLE_VALUE)
1125   {
1126     MSVCRT__close(fds[fdToOpen]);
1127     ret = NULL;
1128   }
1129   else
1130   {
1131     ret = MSVCRT__wfdopen(fds[fdToOpen], mode);
1132     if (!ret)
1133       MSVCRT__close(fds[fdToOpen]);
1134     container->f = ret;
1135   }
1136   _munlock(_POPEN_LOCK);
1137   HeapFree(GetProcessHeap(), 0, comspec);
1138   HeapFree(GetProcessHeap(), 0, fullcmd);
1139   MSVCRT__dup2(fdStdHandle, fdToDup);
1140   MSVCRT__close(fdStdHandle);
1141   return ret;
1142
1143 error:
1144   _munlock(_POPEN_LOCK);
1145   if (fdStdHandle != -1) MSVCRT__close(fdStdHandle);
1146   MSVCRT__close(fds[0]);
1147   MSVCRT__close(fds[1]);
1148   return NULL;
1149 }
1150
1151 /*********************************************************************
1152  *      _popen (MSVCRT.@)
1153  */
1154 MSVCRT_FILE* CDECL MSVCRT__popen(const char* command, const char* mode)
1155 {
1156   MSVCRT_FILE *ret;
1157   MSVCRT_wchar_t *cmdW, *modeW;
1158
1159   TRACE("(command=%s, mode=%s)\n", debugstr_a(command), debugstr_a(mode));
1160
1161   if (!command || !mode)
1162     return NULL;
1163
1164   if (!(cmdW = msvcrt_wstrdupa(command))) return NULL;
1165   if (!(modeW = msvcrt_wstrdupa(mode)))
1166   {
1167     HeapFree(GetProcessHeap(), 0, cmdW);
1168     return NULL;
1169   }
1170
1171   ret = MSVCRT__wpopen(cmdW, modeW);
1172
1173   HeapFree(GetProcessHeap(), 0, cmdW);
1174   HeapFree(GetProcessHeap(), 0, modeW);
1175   return ret;
1176 }
1177
1178 /*********************************************************************
1179  *              _pclose (MSVCRT.@)
1180  */
1181 int CDECL MSVCRT__pclose(MSVCRT_FILE* file)
1182 {
1183   HANDLE h;
1184   DWORD i;
1185
1186   if (!MSVCRT_CHECK_PMT(file != NULL)) return -1;
1187
1188   _mlock(_POPEN_LOCK);
1189   for(i=0; i<popen_handles_size; i++)
1190   {
1191     if (popen_handles[i].f == file)
1192       break;
1193   }
1194   if(i == popen_handles_size)
1195   {
1196     _munlock(_POPEN_LOCK);
1197     *MSVCRT__errno() = MSVCRT_EBADF;
1198     return -1;
1199   }
1200
1201   h = popen_handles[i].proc;
1202   popen_handles[i].f = NULL;
1203   _munlock(_POPEN_LOCK);
1204
1205   MSVCRT_fclose(file);
1206   if(WaitForSingleObject(h, INFINITE)==WAIT_FAILED || !GetExitCodeProcess(h, &i))
1207   {
1208     msvcrt_set_errno(GetLastError());
1209     CloseHandle(h);
1210     return -1;
1211   }
1212
1213   CloseHandle(h);
1214   return i;
1215 }
1216
1217 /*********************************************************************
1218  *      _wsystem (MSVCRT.@)
1219  *
1220  * Unicode version of system
1221  */
1222 int CDECL _wsystem(const MSVCRT_wchar_t* cmd)
1223 {
1224   int res;
1225   MSVCRT_wchar_t *comspec, *fullcmd;
1226   unsigned int len;
1227   static const MSVCRT_wchar_t flag[] = {' ','/','c',' ',0};
1228
1229   comspec = msvcrt_get_comspec();
1230
1231   if (cmd == NULL)
1232   {
1233     if (comspec == NULL)
1234     {
1235         *MSVCRT__errno() = MSVCRT_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 = strlenW(comspec) + strlenW(flag) + strlenW(cmd) + 1;
1246
1247   if (!(fullcmd = HeapAlloc(GetProcessHeap(), 0, len * sizeof(MSVCRT_wchar_t))))
1248   {
1249     HeapFree(GetProcessHeap(), 0, comspec);
1250     return -1;
1251   }
1252   strcpyW(fullcmd, comspec);
1253   strcatW(fullcmd, flag);
1254   strcatW(fullcmd, cmd);
1255
1256   res = msvcrt_spawn(MSVCRT__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 MSVCRT_system(const char* cmd)
1267 {
1268   int res = -1;
1269   MSVCRT_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 MSVCRT_intptr_t CDECL _loaddll(const char* dllname)
1286 {
1287   return (MSVCRT_intptr_t)LoadLibraryA(dllname);
1288 }
1289
1290 /*********************************************************************
1291  *              _unloaddll (MSVCRT.@)
1292  */
1293 int CDECL _unloaddll(MSVCRT_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(MSVCRT_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 }