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