Git conversion: Make reactos the root directory, move rosapps, rostests, wallpapers...
[reactos.git] / sdk / lib / crt / process / process.c
1 /*
2 * PROJECT: ReactOS CRT library
3 * LICENSE: GPL (?) - See COPYING in the top level directory
4 * FILE: lib/sdk/crt/process/process.c
5 * PURPOSE: Process management functions
6 * PROGRAMMERS: ???
7 */
8
9 #include <precomp.h>
10 #include <process.h>
11 #include <tchar.h>
12 #include <internal/wine/msvcrt.h>
13
14 #ifdef _UNICODE
15 #define sT "S"
16 #define find_execT find_execW
17 #define argvtosT argvtosW
18 #define do_spawnT do_spawnW
19 #define valisttosT valisttosW
20 #define extT extW
21 #define access_dirT access_dirW
22 #else
23 #define sT "s"
24 #define find_execT find_execA
25 #define argvtosT argvtosA
26 #define do_spawnT do_spawnA
27 #define valisttosT valisttosA
28 #define extT extA
29 #define access_dirT access_dirA
30 #endif
31
32 #define MK_STR(s) #s
33
34 int access_dirT(const _TCHAR *_path);
35
36 _TCHAR const* extT[] =
37 {
38 _T(""),
39 _T(".bat"),
40 _T(".cmd"),
41 _T(".com"),
42 _T(".exe")
43 };
44
45 const _TCHAR* find_execT(const _TCHAR* path, _TCHAR* rpath)
46 {
47 _TCHAR *rp;
48 const _TCHAR *rd;
49 unsigned int i, found = 0;
50
51 TRACE(MK_STR(find_execT)"('%"sT"', %x)\n", path, rpath);
52
53 if (path == NULL)
54 {
55 return NULL;
56 }
57 if (_tcslen(path) > FILENAME_MAX - 1)
58 {
59 return path;
60 }
61 /* copy path in rpath */
62 for (rd = path, rp = rpath; *rd; *rp++ = *rd++)
63 ;
64 *rp = 0;
65 /* try first with the name as is */
66 for (i = 0; i < sizeof(extT) / sizeof(*extT); i++)
67 {
68 _tcscpy(rp, extT[i]);
69
70 TRACE("trying '%"sT"'\n", rpath);
71
72 if (_taccess(rpath, F_OK) == 0 && access_dirT(rpath) != 0)
73 {
74 found = 1;
75 break;
76 }
77 }
78 if (!found)
79 {
80 _TCHAR* env = _tgetenv(_T("PATH"));
81 if (env)
82 {
83 _TCHAR* ep = env;
84 while (*ep && !found)
85 {
86 if (*ep == ';')
87 ep++;
88 rp=rpath;
89 for (; *ep && (*ep != ';'); *rp++ = *ep++)
90 ;
91 if (rp > rpath)
92 {
93 rp--;
94 if (*rp != '/' && *rp != '\\')
95 {
96 *++rp = '\\';
97 }
98 rp++;
99 }
100 for (rd=path; *rd; *rp++ = *rd++)
101 ;
102 for (i = 0; i < sizeof(extT) / sizeof(*extT); i++)
103 {
104 _tcscpy(rp, extT[i]);
105
106 TRACE("trying '%"sT"'\n", rpath);
107
108 if (_taccess(rpath, F_OK) == 0 && access_dirT(rpath) != 0)
109 {
110 found = 1;
111 break;
112 }
113 }
114 }
115 }
116 }
117
118 return found ? rpath : path;
119 }
120
121 static _TCHAR*
122 argvtosT(const _TCHAR* const* argv, _TCHAR delim)
123 {
124 int i;
125 size_t len;
126 _TCHAR *ptr, *str;
127
128 if (argv == NULL)
129 return NULL;
130
131 for (i = 0, len = 0; argv[i]; i++)
132 {
133 len += _tcslen(argv[i]) + 1;
134 }
135
136 str = ptr = (_TCHAR*) malloc((len + 1) * sizeof(_TCHAR));
137 if (str == NULL)
138 return NULL;
139
140 for(i = 0; argv[i]; i++)
141 {
142 len = _tcslen(argv[i]);
143 memcpy(ptr, argv[i], len * sizeof(_TCHAR));
144 ptr += len;
145 *ptr++ = delim;
146 }
147 *ptr = 0;
148
149 return str;
150 }
151
152 static _TCHAR*
153 valisttosT(const _TCHAR* arg0, va_list alist, _TCHAR delim)
154 {
155 va_list alist2;
156 _TCHAR *ptr, *str;
157 size_t len;
158
159 if (arg0 == NULL)
160 return NULL;
161
162 va_copy(alist2, alist);
163 ptr = (_TCHAR*)arg0;
164 len = 0;
165 do
166 {
167 len += _tcslen(ptr) + 1;
168 ptr = va_arg(alist, _TCHAR*);
169 }
170 while(ptr != NULL);
171
172 str = (_TCHAR*) malloc((len + 1) * sizeof(_TCHAR));
173 if (str == NULL)
174 {
175 va_end(alist2);
176 return NULL;
177 }
178
179 ptr = str;
180 do
181 {
182 len = _tcslen(arg0);
183 memcpy(ptr, arg0, len * sizeof(_TCHAR));
184 ptr += len;
185 *ptr++ = delim;
186 arg0 = va_arg(alist2, _TCHAR*);
187 }
188 while(arg0 != NULL);
189 *ptr = 0;
190
191 va_end(alist2);
192 return str;
193 }
194
195 static intptr_t
196 do_spawnT(int mode, const _TCHAR* cmdname, const _TCHAR* args, const _TCHAR* envp)
197 {
198 STARTUPINFO StartupInfo = {0};
199 PROCESS_INFORMATION ProcessInformation;
200 // char* fmode;
201 // HANDLE* hFile;
202 // int i, last;
203 BOOL bResult;
204 DWORD dwExitCode;
205 DWORD dwError;
206
207 TRACE(MK_STR(do_spawnT)"(%i,'%"sT"','%"sT"','%"sT"')",mode,cmdname,args,envp);
208
209
210 if (mode != _P_NOWAIT && mode != _P_NOWAITO && mode != _P_WAIT && mode != _P_DETACH && mode != _P_OVERLAY)
211 {
212 _set_errno ( EINVAL );
213 return( -1);
214 }
215
216 if (0 != _taccess(cmdname, F_OK))
217 {
218 _set_errno ( ENOENT );
219 return(-1);
220 }
221 if (0 == access_dirT(cmdname))
222 {
223 _set_errno ( EISDIR );
224 return(-1);
225 }
226
227 memset (&StartupInfo, 0, sizeof(StartupInfo));
228 StartupInfo.cb = sizeof(StartupInfo);
229
230 #if 0
231
232 for (last = i = 0; i < FDINFO_FD_MAX; i++)
233 {
234 if ((void*)-1 != _get_osfhandle(i))
235 {
236 last = i + 1;
237 }
238 }
239
240 if (last)
241 {
242 StartupInfo.cbReserved2 = sizeof(ULONG) + last * (sizeof(char) + sizeof(HANDLE));
243 StartupInfo.lpReserved2 = malloc(StartupInfo.cbReserved2);
244 if (StartupInfo.lpReserved2 == NULL)
245 {
246 _set_errno ( ENOMEM );
247 return -1;
248 }
249
250 *(DWORD*)StartupInfo.lpReserved2 = last;
251 fmode = (char*)(StartupInfo.lpReserved2 + sizeof(ULONG));
252 hFile = (HANDLE*)(StartupInfo.lpReserved2 + sizeof(ULONG) + last * sizeof(char));
253 for (i = 0; i < last; i++)
254 {
255 int _mode = __fileno_getmode(i);
256 HANDLE h = _get_osfhandle(i);
257 /* FIXME: The test of console handles (((ULONG)Handle) & 0x10000003) == 0x3)
258 * is possible wrong
259 */
260 if ((((ULONG)h) & 0x10000003) == 0x3 || _mode & _O_NOINHERIT || (i < 3 && mode == _P_DETACH))
261 {
262 *hFile = INVALID_HANDLE_VALUE;
263 *fmode = 0;
264 }
265 else
266 {
267 DWORD dwFlags;
268 BOOL bFlag;
269 bFlag = GetHandleInformation(h, &dwFlags);
270 if (bFlag && (dwFlags & HANDLE_FLAG_INHERIT))
271 {
272 *hFile = h;
273 *fmode = (_O_ACCMODE & _mode) | (((_O_TEXT | _O_BINARY) & _mode) >> 8);
274 }
275 else
276 {
277 *hFile = INVALID_HANDLE_VALUE;
278 *fmode = 0;
279 }
280 }
281 fmode++;
282 hFile++;
283 }
284 }
285 #endif
286
287 create_io_inherit_block(&StartupInfo.cbReserved2, &StartupInfo.lpReserved2);
288
289 bResult = CreateProcess((_TCHAR *)cmdname,
290 (_TCHAR *)args,
291 NULL,
292 NULL,
293 TRUE,
294 mode == _P_DETACH ? DETACHED_PROCESS : 0,
295 (LPVOID)envp,
296 NULL,
297 &StartupInfo,
298 &ProcessInformation);
299
300 if (StartupInfo.lpReserved2)
301 {
302 free(StartupInfo.lpReserved2);
303 }
304
305 if (!bResult)
306 {
307 dwError = GetLastError();
308 ERR("%x\n", dwError);
309 _dosmaperr(dwError);
310 return(-1);
311 }
312 CloseHandle(ProcessInformation.hThread);
313 switch(mode)
314 {
315 case _P_NOWAIT:
316 case _P_NOWAITO:
317 return((intptr_t)ProcessInformation.hProcess);
318 case _P_OVERLAY:
319 CloseHandle(ProcessInformation.hProcess);
320 _exit(0);
321 case _P_WAIT:
322 WaitForSingleObject(ProcessInformation.hProcess, INFINITE);
323 GetExitCodeProcess(ProcessInformation.hProcess, &dwExitCode);
324 CloseHandle(ProcessInformation.hProcess);
325 return( (int)dwExitCode); //CORRECT?
326 case _P_DETACH:
327 CloseHandle(ProcessInformation.hProcess);
328 return( 0);
329 }
330 return( (intptr_t)ProcessInformation.hProcess);
331 }
332
333 /*
334 * @implemented
335 */
336 intptr_t _tspawnl(int mode, const _TCHAR *cmdname, const _TCHAR* arg0, ...)
337 {
338 va_list argp;
339 _TCHAR* args;
340 intptr_t ret = -1;
341
342 TRACE(MK_STR(_tspawnl)"('%"sT"')\n", cmdname);
343
344 va_start(argp, arg0);
345 args = valisttosT(arg0, argp, ' ');
346
347 if (args)
348 {
349 ret = do_spawnT(mode, cmdname, args, NULL);
350 free(args);
351 }
352 va_end(argp);
353 return ret;
354 }
355
356 /*
357 * @implemented
358 */
359 intptr_t _tspawnv(int mode, const _TCHAR *cmdname, const _TCHAR* const* argv)
360 {
361 _TCHAR* args;
362 intptr_t ret = -1;
363
364 TRACE(MK_STR(_tspawnv)"('%"sT"')\n", cmdname);
365
366 args = argvtosT(argv, ' ');
367
368 if (args)
369 {
370 ret = do_spawnT(mode, cmdname, args, NULL);
371 free(args);
372 }
373 return ret;
374 }
375
376 /*
377 * @implemented
378 */
379 intptr_t _tspawnle(int mode, const _TCHAR *cmdname, const _TCHAR* arg0, ... /*, NULL, const char* const* envp*/)
380 {
381 va_list argp;
382 _TCHAR* args;
383 _TCHAR* envs;
384 _TCHAR const * const* ptr;
385 intptr_t ret = -1;
386
387 TRACE(MK_STR(_tspawnle)"('%"sT"')\n", cmdname);
388
389 va_start(argp, arg0);
390 args = valisttosT(arg0, argp, ' ');
391 do
392 {
393 ptr = (_TCHAR const* const*)va_arg(argp, _TCHAR*);
394 }
395 while (ptr != NULL);
396 ptr = (_TCHAR const* const*)va_arg(argp, _TCHAR*);
397 envs = argvtosT(ptr, 0);
398 if (args)
399 {
400 ret = do_spawnT(mode, cmdname, args, envs);
401 free(args);
402 }
403 if (envs)
404 {
405 free(envs);
406 }
407 va_end(argp);
408 return ret;
409
410 }
411
412 /*
413 * @implemented
414 */
415 intptr_t _tspawnve(int mode, const _TCHAR *cmdname, const _TCHAR* const* argv, const _TCHAR* const* envp)
416 {
417 _TCHAR *args;
418 _TCHAR *envs;
419 intptr_t ret = -1;
420
421 TRACE(MK_STR(_tspawnve)"('%"sT"')\n", cmdname);
422
423 args = argvtosT(argv, ' ');
424 envs = argvtosT(envp, 0);
425
426 if (args)
427 {
428 ret = do_spawnT(mode, cmdname, args, envs);
429 free(args);
430 }
431 if (envs)
432 {
433 free(envs);
434 }
435 return ret;
436 }
437
438 /*
439 * @implemented
440 */
441 intptr_t _tspawnvp(int mode, const _TCHAR* cmdname, const _TCHAR* const* argv)
442 {
443 _TCHAR pathname[FILENAME_MAX];
444
445 TRACE(MK_STR(_tspawnvp)"('%"sT"')\n", cmdname);
446
447 return _tspawnv(mode, find_execT(cmdname, pathname), argv);
448 }
449
450 /*
451 * @implemented
452 */
453 intptr_t _tspawnlp(int mode, const _TCHAR* cmdname, const _TCHAR* arg0, .../*, NULL*/)
454 {
455 va_list argp;
456 _TCHAR* args;
457 intptr_t ret = -1;
458 _TCHAR pathname[FILENAME_MAX];
459
460 TRACE(MK_STR(_tspawnlp)"('%"sT"')\n", cmdname);
461
462 va_start(argp, arg0);
463 args = valisttosT(arg0, argp, ' ');
464 if (args)
465 {
466 ret = do_spawnT(mode, find_execT(cmdname, pathname), args, NULL);
467 free(args);
468 }
469 va_end(argp);
470 return ret;
471 }
472
473
474 /*
475 * @implemented
476 */
477 intptr_t _tspawnlpe(int mode, const _TCHAR* cmdname, const _TCHAR* arg0, .../*, NULL, const char* const* envp*/)
478 {
479 va_list argp;
480 _TCHAR* args;
481 _TCHAR* envs;
482 _TCHAR const* const * ptr;
483 intptr_t ret = -1;
484 _TCHAR pathname[FILENAME_MAX];
485
486 TRACE(MK_STR(_tspawnlpe)"('%"sT"')\n", cmdname);
487
488 va_start(argp, arg0);
489 args = valisttosT(arg0, argp, ' ');
490 do
491 {
492 ptr = (_TCHAR const* const*)va_arg(argp, _TCHAR*);
493 }
494 while (ptr != NULL);
495 ptr = (_TCHAR const* const*)va_arg(argp, _TCHAR*);
496 envs = argvtosT(ptr, 0);
497 if (args)
498 {
499 ret = do_spawnT(mode, find_execT(cmdname, pathname), args, envs);
500 free(args);
501 }
502 if (envs)
503 {
504 free(envs);
505 }
506 va_end(argp);
507 return ret;
508 }
509
510 /*
511 * @implemented
512 */
513 intptr_t _tspawnvpe(int mode, const _TCHAR* cmdname, const _TCHAR* const* argv, const _TCHAR* const* envp)
514 {
515 _TCHAR pathname[FILENAME_MAX];
516
517 TRACE(MK_STR(_tspawnvpe)"('%"sT"')\n", cmdname);
518
519 return _tspawnve(mode, find_execT(cmdname, pathname), argv, envp);
520 }
521
522 /*
523 * @implemented
524 */
525 intptr_t _texecl(const _TCHAR* cmdname, const _TCHAR* arg0, ...)
526 {
527 _TCHAR* args;
528 va_list argp;
529 intptr_t ret = -1;
530
531 TRACE(MK_STR(_texecl)"('%"sT"')\n", cmdname);
532
533 va_start(argp, arg0);
534 args = valisttosT(arg0, argp, ' ');
535
536 if (args)
537 {
538 ret = do_spawnT(_P_OVERLAY, cmdname, args, NULL);
539 free(args);
540 }
541 va_end(argp);
542 return ret;
543 }
544
545 /*
546 * @implemented
547 */
548 intptr_t _texecv(const _TCHAR* cmdname, const _TCHAR* const* argv)
549 {
550 TRACE(MK_STR(_texecv)"('%"sT"')\n", cmdname);
551 return _tspawnv(_P_OVERLAY, cmdname, argv);
552 }
553
554 /*
555 * @implemented
556 */
557 intptr_t _texecle(const _TCHAR* cmdname, const _TCHAR* arg0, ... /*, NULL, char* const* envp */)
558 {
559 va_list argp;
560 _TCHAR* args;
561 _TCHAR* envs;
562 _TCHAR const* const* ptr;
563 intptr_t ret = -1;
564
565 TRACE(MK_STR(_texecle)"('%"sT"')\n", cmdname);
566
567 va_start(argp, arg0);
568 args = valisttosT(arg0, argp, ' ');
569 do
570 {
571 ptr = (_TCHAR const* const*)va_arg(argp, _TCHAR*);
572 }
573 while (ptr != NULL);
574 ptr = (_TCHAR const* const*)va_arg(argp, _TCHAR*);
575 envs = argvtosT(ptr, 0);
576 if (args)
577 {
578 ret = do_spawnT(_P_OVERLAY, cmdname, args, envs);
579 free(args);
580 }
581 if (envs)
582 {
583 free(envs);
584 }
585 va_end(argp);
586 return ret;
587 }
588
589 /*
590 * @implemented
591 */
592 intptr_t _texecve(const _TCHAR* cmdname, const _TCHAR* const* argv, const _TCHAR* const* envp)
593 {
594 TRACE(MK_STR(_texecve)"('%"sT"')\n", cmdname);
595 return _tspawnve(_P_OVERLAY, cmdname, argv, envp);
596 }
597
598 /*
599 * @implemented
600 */
601 intptr_t _texeclp(const _TCHAR* cmdname, const _TCHAR* arg0, ...)
602 {
603 _TCHAR* args;
604 va_list argp;
605 intptr_t ret = -1;
606 _TCHAR pathname[FILENAME_MAX];
607
608 TRACE(MK_STR(_texeclp)"('%"sT"')\n", cmdname);
609
610 va_start(argp, arg0);
611 args = valisttosT(arg0, argp, ' ');
612
613 if (args)
614 {
615 ret = do_spawnT(_P_OVERLAY, find_execT(cmdname, pathname), args, NULL);
616 free(args);
617 }
618 va_end(argp);
619 return ret;
620 }
621
622 /*
623 * @implemented
624 */
625 intptr_t _texecvp(const _TCHAR* cmdname, const _TCHAR* const* argv)
626 {
627 TRACE(MK_STR(_texecvp)"('%"sT"')\n", cmdname);
628 return _tspawnvp(_P_OVERLAY, cmdname, argv);
629 }
630
631 /*
632 * @implemented
633 */
634 intptr_t _texeclpe(const _TCHAR* cmdname, const _TCHAR* arg0, ... /*, NULL, char* const* envp */)
635 {
636 va_list argp;
637 _TCHAR* args;
638 _TCHAR* envs;
639 _TCHAR const* const* ptr;
640 intptr_t ret = -1;
641 _TCHAR pathname[FILENAME_MAX];
642
643 TRACE(MK_STR(_texeclpe)"('%"sT"')\n", cmdname);
644
645 va_start(argp, arg0);
646 args = valisttosT(arg0, argp, ' ');
647 do
648 {
649 ptr = (_TCHAR const* const*)va_arg(argp, _TCHAR*);
650 }
651 while (ptr != NULL);
652 ptr = (_TCHAR const* const*)va_arg(argp, _TCHAR*);
653 envs = argvtosT(ptr, 0);
654 if (args)
655 {
656 ret = do_spawnT(_P_OVERLAY, find_execT(cmdname, pathname), args, envs);
657 free(args);
658 }
659 if (envs)
660 {
661 free(envs);
662 }
663 va_end(argp);
664 return ret;
665 }
666
667 /*
668 * @implemented
669 */
670 intptr_t _texecvpe(const _TCHAR* cmdname, const _TCHAR* const* argv, const _TCHAR* const* envp)
671 {
672 TRACE(MK_STR(_texecvpe)"('%"sT"')\n", cmdname);
673 return _tspawnvpe(_P_OVERLAY, cmdname, argv, envp);
674 }
675
676