redirect.c

Last change on this file was 3564, checked in by bird, 3 years ago
kmk_redirect: Must redirect stdout/err according to the pCtx when not on windows. [build fix]
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 75.4 KB

Line
1	/* $Id: redirect.c 3564 2022-03-08 11:12:18Z bird $ */
2	/** @file
3	* kmk_redirect - Do simple program <-> file redirection (++).
4	*/
5
6	/*
7	* Copyright (c) 2007-2016 knut st. osmundsen <[email protected]>
8	*
9	* This file is part of kBuild.
10	*
11	* kBuild is free software; you can redistribute it and/or modify
12	* it under the terms of the GNU General Public License as published by
13	* the Free Software Foundation; either version 3 of the License, or
14	* (at your option) any later version.
15	*
16	* kBuild is distributed in the hope that it will be useful,
17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19	* GNU General Public License for more details.
20	*
21	* You should have received a copy of the GNU General Public License
22	* along with kBuild. If not, see <http://www.gnu.org/licenses/>
23	*
24	*/
25
26	/*******************************************************************************
27	* Header Files *
28	*******************************************************************************/
29	#if defined(__APPLE__)
30	/# define _POSIX_C_SOURCE 1 / 10.4 sdk and unsetenv * / - breaks O_CLOEXEC on 10.8 */
31	#endif
32	#include "makeint.h"
33	#include <assert.h>
34	#include <stdio.h>
35	#include <stdarg.h>
36	#include <stdlib.h>
37	#include <string.h>
38	#include <errno.h>
39	#include <fcntl.h>
40	#if defined(KBUILD_OS_WINDOWS) \|\| defined(KBUILD_OS_OS2)
41	# include <process.h>
42	#endif
43	#ifdef KBUILD_OS_WINDOWS
44	# include <Windows.h>
45	#endif
46	#if defined(_MSC_VER)
47	# include <ctype.h>
48	# include <io.h>
49	# include "quote_argv.h"
50	#else
51	# ifdef __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__
52	# if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1050
53	# define USE_POSIX_SPAWN
54	# endif
55	# elif !defined(KBUILD_OS_WINDOWS) && !defined(KBUILD_OS_OS2)
56	# define USE_POSIX_SPAWN
57	# endif
58	# include <unistd.h>
59	# ifdef USE_POSIX_SPAWN
60	# include <spawn.h>
61	# endif
62	# include <sys/wait.h>
63	#endif
64
65	#include <k/kDefs.h>
66	#include <k/kTypes.h>
67	#include "err.h"
68	#include "kbuild_version.h"
69	#ifdef KBUILD_OS_WINDOWS
70	# include "nt/nt_child_inject_standard_handles.h"
71	#endif
72	#if defined(__gnu_hurd__) && !defined(KMK_BUILTIN_STANDALONE) /* need constant */
73	# undef GET_PATH_MAX
74	# undef PATH_MAX
75	# define GET_PATH_MAX PATH_MAX
76	#endif
77	#include "kmkbuiltin.h"
78	#ifdef KMK
79	# ifdef KBUILD_OS_WINDOWS
80	# ifndef CONFIG_NEW_WIN_CHILDREN
81	# include "sub_proc.h"
82	# else
83	# include "../w32/winchildren.h"
84	# endif
85	# include "pathstuff.h"
86	# endif
87	#endif
88
89	#ifdef __OS2__
90	# define INCL_BASE
91	# include <os2.h>
92	# ifndef LIBPATHSTRICT
93	# define LIBPATHSTRICT 3
94	# endif
95	#endif
96
97	#ifndef KMK_BUILTIN_STANDALONE
98	extern void kmk_cache_exec_image_a(const char ); / imagecache.c */
99	#endif
100
101
102	/*********************************************************************************************************************************
103	* Defined Constants And Macros *
104	*********************************************************************************************************************************/
105	/* String + strlen tuple. */
106	#define TUPLE(a_sz) a_sz, sizeof(a_sz) - 1
107
108	/** Only standard handles on windows. */
109	#ifdef KBUILD_OS_WINDOWS
110	# define ONLY_TARGET_STANDARD_HANDLES
111	#endif
112
113
114	static int kmk_redirect_usage(PKMKBUILTINCTX pCtx, int fIsErr)
115	{
116	/* 0 1 2 3 4 5 6 7 8 */
117	/* 012345678901234567890123456789012345678901234567890123456789012345678901234567890 */
118	kmk_builtin_ctx_printf(pCtx, fIsErr,
119	"Usage: %s [-[rwa+tb]<fd> <file>] [-d<fd>=<src-fd>] [-c<fd>] [--stdin-pipe]\n"
120	" [-Z] [-E <var=val>] [-A <var=val>] [-P <var=val>] [-D <var>]\n"
121	" [-C <dir>] [--wcc-brain-damage] [-v] -- <program> [args]\n"
122	" or: %s --help\n"
123	" or: %s --version\n"
124	"\n"
125	"Options:\n"
126	"-[rwa+tb]<fd> <file>\n"
127	" The rwa+tb is like for fopen, if not specified it defaults to w+.\n"
128	" The <fd> is either a number or an alias for the standard handles:\n"
129	" i = stdin\n"
130	" o = stdout\n"
131	" e = stderr\n"
132	"-d\n"
133	" The -d switch duplicate the right hand file descriptor (src-fd) to the left\n"
134	" hand side one (fd). The latter is limited to standard handles on windows.\n"
135	"-c <fd>, --close <fd>\n"
136	" The -c switch will close the specified file descriptor. Limited to standard\n"
137	" handles on windows.\n"
138	"--stdin-pipe\n"
139	" The --stdin-pipe switch will replace stdin with the read end of an\n"
140	" anonymous pipe. This is for tricking things like rsh.exe that blocks\n"
141	" reading on stdin.\n"
142	"-Z, --zap-env, --ignore-environment\n"
143	" The -Z switch zaps the environment.\n"
144	"-E <var=val>, --set <var=val>, --env <var=val>\n"
145	" The -E (--set, --env) switch is for making changes to the environment\n"
146	" in an putenv fashion.\n"
147	"-A <var=val>, --append <var=val>\n"
148	" The -A switch appends to an environment variable in a putenv fashion.\n"
149	"-D <var=val>, --prepend <var=val>\n"
150	" The -D switch prepends to an environment variable in a putenv fashion.\n"
151	"-U <var>, --unset <var>\n"
152	" The -U switch deletes an environment variable.\n"
153	/* 0 1 2 3 4 5 6 7 8 */
154	/* 012345678901234567890123456789012345678901234567890123456789012345678901234567890 */
155	"-C <dir>, --chdir <dir>\n"
156	" The -C switch is for changing the current directory. Please specify an\n"
157	" absolute program path as it's platform dependent whether this takes\n"
158	" effect before or after the executable is located.\n"
159	"--wcc-brain-damage, --watcom-brain-damage\n"
160	" The --wcc-brain-damage switch is to work around wcc and wcc386\n"
161	" (Open Watcom) not following normal quoting conventions on Windows and OS/2.\n"
162	"-v, --verbose\n"
163	" The -v switch is for making the thing more verbose.\n"
164	"\n"
165	"On OS/2 the kernel variables BEGINLIBPATH, ENDLIBPATH and LIBPATHSTRICT can be\n"
166	"accessed as-if they were regular enviornment variables.\n"
167	"\n"
168	"This command was originally just a quick hack to avoid invoking the shell\n"
169	"on Windows (cygwin) where forking is very expensive and has exhibited\n"
170	"stability issues on SMP machines. It has since grown into something like\n"
171	"/usr/bin/env on steroids.\n"
172	/* 0 1 2 3 4 5 6 7 8 */
173	/* 012345678901234567890123456789012345678901234567890123456789012345678901234567890 */
174	,
175	pCtx->pszProgName, pCtx->pszProgName, pCtx->pszProgName);
176	return 2;
177	}
178
179
180	/**
181	* Decoded file descriptor operations.
182	*/
183	typedef struct REDIRECTORDERS
184	{
185	enum {
186	kRedirectOrder_Invalid = 0,
187	kRedirectOrder_Close,
188	kRedirectOrder_Open,
189	kRedirectOrder_Dup
190	} enmOrder;
191	/** The target file handle. */
192	int fdTarget;
193	/** The source file name, -1 on close only.
194	* This is an opened file if pszFilename is set. */
195	int fdSource;
196	/** Whether to remove the file on failure cleanup. */
197	int fRemoveOnFailure;
198	/** The open flags (for O_TEXT/O_BINARY) on windows. */
199	int fOpen;
200	/** The filename - NULL if close only. */
201	const char *pszFilename;
202	/** The other pipe end, needs closing in cleanup. */
203	int fdOtherPipeEnd;
204	#ifndef USE_POSIX_SPAWN
205	/** Saved file descriptor. */
206	int fdSaved;
207	/** Saved flags. */
208	int fSaved;
209	#endif
210	} REDIRECTORDERS;
211
212
213	static KBOOL kRedirectHasConflict(int fd, unsigned cOrders, REDIRECTORDERS *paOrders)
214	{
215	#ifdef ONLY_TARGET_STANDARD_HANDLES
216	return fd < 3;
217	#else
218	while (cOrders-- > 0)
219	if (paOrders[cOrders].fdTarget == fd)
220	return K_TRUE;
221	return K_FALSE;
222	#endif
223	}
224
225
226	/**
227	* Creates a pair of pipe descriptors that does not conflict with any previous
228	* orders.
229	*
230	* The pipe is open with both descriptors being inherited by the child as it's
231	* supposed to be a dummy pipe for stdin that won't break.
232	*
233	* @returns 0 on success, exit code on failure (error message displayed).
234	* @param pCtx The command execution context.
235	* @param paFds Where to return the pipe descriptors
236	* @param cOrders The number of orders.
237	* @param paOrders The order array.
238	* @param fdTarget The target descriptor (0).
239	*/
240	static int kRedirectCreateStdInPipeWithoutConflict(PKMKBUILTINCTX pCtx, int paFds[2],
241	unsigned cOrders, REDIRECTORDERS *paOrders, int fdTarget)
242	{
243	struct
244	{
245	int aFds[2];
246	} aTries[32];
247	unsigned cTries = 0;
248
249	while (cTries < K_ELEMENTS(aTries))
250	{
251	#ifdef _MSC_VER
252	int rc = _pipe(aTries[cTries].aFds, 0, _O_BINARY);
253	#else
254	int rc = pipe(aTries[cTries].aFds);
255	#endif
256	if (rc >= 0)
257	{
258	if ( !kRedirectHasConflict(aTries[cTries].aFds[0], cOrders, paOrders)
259	&& !kRedirectHasConflict(aTries[cTries].aFds[1], cOrders, paOrders)
260	#ifndef _MSC_VER
261	&& aTries[cTries].aFds[0] != fdTarget
262	&& aTries[cTries].aFds[1] != fdTarget
263	#endif
264	)
265	{
266	paFds[0] = aTries[cTries].aFds[0];
267	paFds[1] = aTries[cTries].aFds[1];
268
269	while (cTries-- > 0)
270	{
271	close(aTries[cTries].aFds[0]);
272	close(aTries[cTries].aFds[1]);
273	}
274	return 0;
275	}
276	}
277	else
278	{
279	err(pCtx, -1, "failed to create stdin pipe (try #%u)", cTries + 1);
280	break;
281	}
282	cTries++;
283	}
284	if (cTries >= K_ELEMENTS(aTries))
285	errx(pCtx, -1, "failed to find a conflict free pair of pipe descriptor for stdin!");
286
287	/* cleanup */
288	while (cTries-- > 0)
289	{
290	close(aTries[cTries].aFds[0]);
291	close(aTries[cTries].aFds[1]);
292	}
293	return 1;
294	}
295
296
297	/**
298	* Creates a file descriptor for @a pszFilename that does not conflict with any
299	* previous orders.
300	*
301	* We need to be careful that there isn't a close or dup targetting the
302	* temporary file descriptor we return. Also, we need to take care with the
303	* descriptor's inheritability. It should only be inheritable if the returned
304	* descriptor matches the target descriptor (@a fdTarget).
305	*
306	* @returns File descriptor on success, -1 & err/errx on failure.
307	*
308	* The returned file descriptor is not inherited (i.e. close-on-exec),
309	* unless it matches @a fdTarget
310	*
311	* @param pCtx The command execution context.
312	* @param pszFilename The filename to open.
313	* @param fOpen The open flags.
314	* @param fMode The file creation mode (if applicable).
315	* @param cOrders The number of orders.
316	* @param paOrders The order array.
317	* @param fRemoveOnFailure Whether to remove the file on failure.
318	* @param fdTarget The target descriptor.
319	*/
320	static int kRedirectOpenWithoutConflict(PKMKBUILTINCTX pCtx, const char *pszFilename, int fOpen, mode_t fMode,
321	unsigned cOrders, REDIRECTORDERS *paOrders, int fRemoveOnFailure, int fdTarget)
322	{
323	#ifdef _O_NOINHERIT
324	int const fNoInherit = _O_NOINHERIT;
325	#elif defined(O_NOINHERIT)
326	int const fNoInherit = O_NOINHERIT;
327	#elif defined(O_CLOEXEC)
328	int const fNoInherit = O_CLOEXEC;
329	#else
330	int const fNoInherit = 0;
331	# define USE_FD_CLOEXEC
332	#endif
333	int aFdTries[32];
334	unsigned cTries;
335	int fdOpened;
336
337	#ifdef KBUILD_OS_WINDOWS
338	if (strcmp(pszFilename, "/dev/null") == 0)
339	pszFilename = "nul";
340	#endif
341
342	/* Open it first. */
343	fdOpened = open(pszFilename, fOpen \| fNoInherit, fMode);
344	if (fdOpened < 0)
345	return err(pCtx, -1, "open(%s,%#x,) failed", pszFilename, fOpen);
346
347	/* Check for conflicts. */
348	if (!kRedirectHasConflict(fdOpened, cOrders, paOrders))
349	{
350	#ifndef KBUILD_OS_WINDOWS
351	if (fdOpened != fdTarget)
352	return fdOpened;
353	# ifndef USE_FD_CLOEXEC
354	if (fcntl(fdOpened, F_SETFD, 0) != -1)
355	# endif
356	#endif
357	return fdOpened;
358	}
359
360	/*
361	* Do conflict resolving.
362	*/
363	cTries = 1;
364	aFdTries[cTries++] = fdOpened;
365	while (cTries < K_ELEMENTS(aFdTries))
366	{
367	fdOpened = open(pszFilename, fOpen \| fNoInherit, fMode);
368	if (fdOpened >= 0)
369	{
370	if (!kRedirectHasConflict(fdOpened, cOrders, paOrders))
371	{
372	#ifndef KBUILD_OS_WINDOWS
373	# ifdef USE_FD_CLOEXEC
374	if ( fdOpened == fdTarget
375	\|\| fcntl(fdOpened, F_SETFD, FD_CLOEXEC) != -1)
376	# else
377	if ( fdOpened != fdTarget
378	\|\| fcntl(fdOpened, F_SETFD, 0) != -1)
379	# endif
380	#endif
381	{
382	while (cTries-- > 0)
383	close(aFdTries[cTries]);
384	return fdOpened;
385	}
386	}
387
388	}
389	else
390	{
391	err(pCtx, -1, "open(%s,%#x,) #%u failed", pszFilename, cTries + 1, fOpen);
392	break;
393	}
394	aFdTries[cTries++] = fdOpened;
395	}
396
397	/*
398	* Give up.
399	*/
400	if (fdOpened >= 0)
401	errx(pCtx, -1, "failed to find a conflict free file descriptor for '%s'!", pszFilename);
402
403	while (cTries-- > 0)
404	close(aFdTries[cTries]);
405	return -1;
406	}
407
408
409	/**
410	* Cleans up the file operation orders.
411	*
412	* This does not restore stuff, just closes handles we've opened for the child.
413	*
414	* @param cOrders Number of file operation orders.
415	* @param paOrders The file operation orders.
416	* @param fFailed Set if it's a failure.
417	*/
418	static void kRedirectCleanupFdOrders(unsigned cOrders, REDIRECTORDERS *paOrders, KBOOL fFailure)
419	{
420	unsigned i = cOrders;
421	while (i-- > 0)
422	{
423	if ( paOrders[i].enmOrder == kRedirectOrder_Open
424	&& paOrders[i].fdSource != -1)
425	{
426	close(paOrders[i].fdSource);
427	paOrders[i].fdSource = -1;
428
429	if (paOrders[i].fdOtherPipeEnd >= 0)
430	{
431	close(paOrders[i].fdOtherPipeEnd);
432	paOrders[i].fdOtherPipeEnd = -1;
433	}
434
435	if ( fFailure
436	&& paOrders[i].fRemoveOnFailure
437	&& paOrders[i].pszFilename)
438	remove(paOrders[i].pszFilename);
439	}
440	}
441	}
442
443	#if !defined(USE_POSIX_SPAWN) && !defined(KBUILD_OS_WINDOWS)
444
445	/**
446	* Wrapper that chooses between fprintf and kmk_builtin_ctx_printf to get
447	* an error message to the user.
448	*
449	* @param pCtx The command execution context.
450	* @param pWorkingStdErr Work stderr.
451	* @param pszFormat The message format string.
452	* @param ... Format arguments.
453	*/
454	static void safe_err_printf(PKMKBUILTINCTX pCtx, FILE pWorkingStdErr, const char pszFormat, ...)
455	{
456	char szMsg[4096];
457	size_t cchMsg;
458	va_list va;
459
460	va_start(va, pszFormat);
461	vsnprintf(szMsg, sizeof(szMsg) - 1, pszFormat, va);
462	va_end(va);
463	szMsg[sizeof(szMsg) - 1] = '\0';
464	cchMsg = strlen(szMsg);
465
466	#ifdef KMK_BUILTIN_STANDALONE
467	(void)pCtx;
468	#else
469	if (pCtx->pOut && pCtx->pOut->syncout)
470	output_write_text(pCtx->pOut, 1, szMsg, cchMsg);
471	else
472	#endif
473	fwrite(szMsg, cchMsg, 1, pWorkingStdErr);
474	}
475
476
477	/**
478	* Saves a file handle to one which isn't inherited and isn't affected by the
479	* file orders.
480	*
481	* @returns 0 on success, non-zero exit code on failure.
482	* @param pCtx The command execution context.
483	* @param pToSave Pointer to the file order to save the target
484	* descriptor of.
485	* @param cOrders Number of file orders.
486	* @param paOrders The array of file orders.
487	* @param ppWorkingStdErr Pointer to a pointer to a working stderr. This will
488	* get replaced if we're saving stderr, so that we'll
489	* keep having a working one to report failures to.
490	*/
491	static int kRedirectSaveHandle(PKMKBUILTINCTX pCtx, REDIRECTORDERS *pToSave, unsigned cOrders,
492	REDIRECTORDERS paOrders, FILE *ppWorkingStdErr)
493	{
494	int fdToSave = pToSave->fdTarget;
495	int rcRet = 10;
496
497	/*
498	* First, check if there's actually handle here that needs saving.
499	*/
500	pToSave->fSaved = fcntl(pToSave->fdTarget, F_GETFD, 0);
501	if (pToSave->fSaved != -1)
502	{
503	/*
504	* Try up to 32 times to get a duplicate descriptor that doesn't conflict.
505	*/
506	int aFdTries[32];
507	int cTries = 0;
508	do
509	{
510	/* Duplicate the handle (windows makes this complicated). */
511	int fdDup;
512	fdDup = dup(fdToSave);
513	if (fdDup == -1)
514	{
515	safe_err_printf(pCtx, *ppWorkingStdErr, "%s: dup(%#x) failed: %u\n", pCtx->pszProgName, fdToSave, strerror(errno));
516	break;
517	}
518	/* Is the duplicate usable? */
519	if (!kRedirectHasConflict(fdDup, cOrders, paOrders))
520	{
521	pToSave->fdSaved = fdDup;
522	if ( *ppWorkingStdErr == stderr
523	&& fdToSave == fileno(*ppWorkingStdErr))
524	{
525	*ppWorkingStdErr = fdopen(fdDup, "wt");
526	if (*ppWorkingStdErr == NULL)
527	{
528	safe_err_printf(pCtx, stderr, "%s: fdopen(%d,\"wt\") failed: %s\n", pCtx->pszProgName, fdDup, strerror(errno));
529	*ppWorkingStdErr = stderr;
530	close(fdDup);
531	break;
532	}
533	}
534	rcRet = 0;
535	break;
536	}
537
538	/* Not usuable, stash it and try again. */
539	aFdTries[cTries++] = fdDup;
540	} while (cTries < K_ELEMENTS(aFdTries));
541
542	/*
543	* Clean up unused duplicates.
544	*/
545	while (cTries-- > 0)
546	close(aFdTries[cTries]);
547	}
548	else
549	{
550	/*
551	* Nothing to save.
552	*/
553	pToSave->fdSaved = -1;
554	rcRet = 0;
555	}
556	return rcRet;
557	}
558
559
560	/**
561	* Restores the target file descriptors affected by the file operation orders.
562	*
563	* @param pCtx The command execution context.
564	* @param cOrders Number of file operation orders.
565	* @param paOrders The file operation orders.
566	* @param ppWorkingStdErr Pointer to a pointer to the working stderr. If this
567	* is one of the saved file descriptors, we'll restore
568	* it to stderr.
569	*/
570	static void kRedirectRestoreFdOrders(PKMKBUILTINCTX pCtx, unsigned cOrders, REDIRECTORDERS paOrders, FILE *ppWorkingStdErr)
571	{
572	int iSavedErrno = errno;
573	unsigned i = cOrders;
574	while (i-- > 0)
575	{
576	if (paOrders[i].fdSaved != -1)
577	{
578	KBOOL fRestoreStdErr = *ppWorkingStdErr != stderr
579	&& paOrders[i].fdSaved == fileno(*ppWorkingStdErr);
580	if (dup2(paOrders[i].fdSaved, paOrders[i].fdTarget) != -1)
581	{
582	close(paOrders[i].fdSaved);
583	paOrders[i].fdSaved = -1;
584
585	if (fRestoreStdErr)
586	{
587	*ppWorkingStdErr = stderr;
588	assert(fileno(stderr) == paOrders[i].fdTarget);
589	}
590	}
591	else
592	safe_err_printf(pCtx, *ppWorkingStdErr, "%s: dup2(%d,%d) failed: %s\n",
593	pCtx->pszProgName, paOrders[i].fdSaved, paOrders[i].fdTarget, strerror(errno));
594	}
595
596	if (paOrders[i].fSaved != -1)
597	{
598	if (fcntl(paOrders[i].fdTarget, F_SETFD, paOrders[i].fSaved & FD_CLOEXEC) != -1)
599	paOrders[i].fSaved = -1;
600	else
601	safe_err_printf(pCtx, *ppWorkingStdErr, "%s: fcntl(%d,F_SETFD,%s) failed: %s\n",
602	pCtx->pszProgName, paOrders[i].fdTarget, paOrders[i].fSaved & FD_CLOEXEC ? "FD_CLOEXEC" : "0",
603	strerror(errno));
604	}
605	}
606	errno = iSavedErrno;
607	}
608
609
610	/**
611	* Executes the file operation orders.
612	*
613	* @returns 0 on success, exit code on failure.
614	* @param pCtx The command execution context.
615	* @param cOrders Number of file operation orders.
616	* @param paOrders File operation orders to execute.
617	* @param ppWorkingStdErr Where to return a working stderr (mainly for
618	* kRedirectRestoreFdOrders).
619	*/
620	static int kRedirectExecFdOrders(PKMKBUILTINCTX pCtx, unsigned cOrders, REDIRECTORDERS paOrders, FILE *ppWorkingStdErr)
621	{
622	unsigned i;
623
624	*ppWorkingStdErr = stderr;
625	for (i = 0; i < cOrders; i++)
626	{
627	int rcExit = 10;
628	switch (paOrders[i].enmOrder)
629	{
630	case kRedirectOrder_Close:
631	{
632	/* If the handle isn't used by any of the following operation,
633	just mark it as non-inheritable if necessary. */
634	int const fdTarget = paOrders[i].fdTarget;
635	unsigned j;
636	for (j = i + 1; j < cOrders; j++)
637	if (paOrders[j].fdTarget == fdTarget)
638	break;
639	if (j >= cOrders)
640	{
641	paOrders[j].fSaved = fcntl(fdTarget, F_GETFD, 0);
642	if (paOrders[j].fSaved != -1)
643	{
644	if (paOrders[j].fSaved & FD_CLOEXEC)
645	rcExit = 0;
646	else if ( fcntl(fdTarget, F_SETFD, FD_CLOEXEC) != -1
647	\|\| errno == EBADF)
648	rcExit = 0;
649	else
650	safe_err_printf(pCtx, *ppWorkingStdErr, "%s: fcntl(%d,F_SETFD,FD_CLOEXEC) failed: %s\n",
651	pCtx->pszProgName, fdTarget, strerror(errno));
652	}
653	else if (errno == EBADF)
654	rcExit = 0;
655	else
656	safe_err_printf(pCtx, *ppWorkingStdErr, "%s: fcntl(%d,F_GETFD,0) failed: %s\n",
657	pCtx->pszProgName, fdTarget, strerror(errno));
658	}
659	else
660	rcExit = kRedirectSaveHandle(pCtx, &paOrders[i], cOrders, paOrders, ppWorkingStdErr);
661	break;
662	}
663
664	case kRedirectOrder_Dup:
665	case kRedirectOrder_Open:
666	rcExit = kRedirectSaveHandle(pCtx, &paOrders[i], cOrders, paOrders, ppWorkingStdErr);
667	if (rcExit == 0)
668	{
669	if (dup2(paOrders[i].fdSource, paOrders[i].fdTarget) != -1)
670	rcExit = 0;
671	else
672	{
673	if (paOrders[i].enmOrder == kRedirectOrder_Open)
674	safe_err_printf(pCtx, *ppWorkingStdErr, "%s: dup2(%d [%s],%d) failed: %s\n", pCtx->pszProgName,
675	paOrders[i].fdSource, paOrders[i].pszFilename, paOrders[i].fdTarget, strerror(errno));
676	else
677	safe_err_printf(pCtx, *ppWorkingStdErr, "%s: dup2(%d,%d) failed: %s\n",
678	pCtx->pszProgName, paOrders[i].fdSource, paOrders[i].fdTarget, strerror(errno));
679	rcExit = 10;
680	}
681	}
682	break;
683
684	default:
685	safe_err_printf(pCtx, *ppWorkingStdErr, "%s: error! invalid enmOrder=%d\n", pCtx->pszProgName, paOrders[i].enmOrder);
686	rcExit = 99;
687	break;
688	}
689
690	if (rcExit != 0)
691	{
692	kRedirectRestoreFdOrders(pCtx, i, paOrders, ppWorkingStdErr);
693	return rcExit;
694	}
695	}
696
697	return 0;
698	}
699
700	#endif /* !USE_POSIX_SPAWN */
701	#ifdef KBUILD_OS_WINDOWS
702
703	/**
704	* Registers the child process with a care provider or waits on it to complete.
705	*
706	* @returns 0 or non-zero success indicator or child exit code, depending on
707	* the value pfIsChildExitCode points to.
708	* @param pCtx The command execution context.
709	* @param hProcess The child process handle.
710	* @param cVerbosity The verbosity level.
711	* @param pPidSpawned Where to return the PID of the spawned child
712	* when we're inside KMK and we're return without
713	* waiting.
714	* @param pfIsChildExitCode Where to indicate whether the return exit code
715	* is from the child or from our setup efforts.
716	*/
717	static int kRedirectPostnatalCareOnWindows(PKMKBUILTINCTX pCtx, HANDLE hProcess, unsigned cVerbosity,
718	pid_t pPidSpawned, KBOOL pfIsChildExitCode)
719	{
720	int rcExit;
721	DWORD dwTmp;
722
723	# ifndef KMK_BUILTIN_STANDALONE
724	/*
725	* Try register the child with a childcare provider, i.e. winchildren.c
726	* or sub_proc.c.
727	*/
728	# ifndef CONFIG_NEW_WIN_CHILDREN
729	if (process_kmk_register_redirect(hProcess, pPidSpawned) == 0)
730	# else
731	if ( pPidSpawned
732	&& MkWinChildCreateRedirect((intptr_t)hProcess, pPidSpawned) == 0)
733	# endif
734	{
735	if (cVerbosity > 0)
736	warnx(pCtx, "debug: spawned %d", *pPidSpawned);
737	*pfIsChildExitCode = K_FALSE;
738	return 0;
739	}
740	# ifndef CONFIG_NEW_WIN_CHILDREN
741	warn(pCtx, "sub_proc is out of slots, waiting for child...");
742	# else
743	if (pPidSpawned)
744	warn(pCtx, "MkWinChildCreateRedirect failed...");
745	# endif
746	# endif
747
748	/*
749	* Either the provider is outbooked or we're not in a context (like
750	* standalone) where we get help with waiting and must to it ourselves
751	*/
752	dwTmp = WaitForSingleObject(hProcess, INFINITE);
753	if (dwTmp != WAIT_OBJECT_0)
754	warnx(pCtx, "WaitForSingleObject failed: %#x\n", dwTmp);
755
756	if (GetExitCodeProcess(hProcess, &dwTmp))
757	rcExit = (int)dwTmp;
758	else
759	{
760	warnx(pCtx, "GetExitCodeProcess failed: %u\n", GetLastError());
761	TerminateProcess(hProcess, 127);
762	rcExit = 127;
763	}
764
765	CloseHandle(hProcess);
766	*pfIsChildExitCode = K_TRUE;
767	return rcExit;
768	}
769
770
771	/**
772	* Tries to locate the executable image.
773	*
774	* This isn't quite perfect yet...
775	*
776	* @returns pszExecutable or pszBuf with valid string.
777	* @param pszExecutable The specified executable.
778	* @param pszBuf Buffer to return a modified path in.
779	* @param cbBuf Size of return buffer.
780	* @param pszPath The search path.
781	*/
782	static const char kRedirectCreateProcessWindowsFindImage(const char pszExecutable, char *pszBuf, size_t cbBuf,
783	const char *pszPath)
784	{
785	/*
786	* Analyze the name.
787	*/
788	size_t const cchExecutable = strlen(pszExecutable);
789	BOOL fHavePath = FALSE;
790	BOOL fHaveSuffix = FALSE;
791	size_t off = cchExecutable;
792	while (off > 0)
793	{
794	char ch = pszExecutable[--off];
795	if (ch == '.')
796	{
797	fHaveSuffix = TRUE;
798	break;
799	}
800	if (ch == '\\' \|\| ch == '/' \|\| ch == ':')
801	{
802	fHavePath = TRUE;
803	break;
804	}
805	}
806	if (!fHavePath)
807	while (off > 0)
808	{
809	char ch = pszExecutable[--off];
810	if (ch == '\\' \|\| ch == '/' \|\| ch == ':')
811	{
812	fHavePath = TRUE;
813	break;
814	}
815	}
816	/*
817	* If no path, search the path value.
818	*/
819	if (!fHavePath)
820	{
821	char *pszFilename;
822	DWORD cchFound = SearchPathA(pszPath, pszExecutable, fHaveSuffix ? NULL : ".exe", cbBuf, pszBuf, &pszFilename);
823	if (cchFound)
824	return pszBuf;
825	}
826
827	/*
828	* If no suffix, try add .exe.
829	*/
830	if ( !fHaveSuffix
831	&& GetFileAttributesA(pszExecutable) == INVALID_FILE_ATTRIBUTES
832	&& cchExecutable + 4 < cbBuf)
833	{
834	memcpy(pszBuf, pszExecutable, cchExecutable);
835	memcpy(&pszBuf[cchExecutable], ".exe", 5);
836	if (GetFileAttributesA(pszBuf) != INVALID_FILE_ATTRIBUTES)
837	return pszBuf;
838	}
839
840	return pszExecutable;
841	}
842
843
844	/**
845	* Turns the orders into input for nt_child_inject_standard_handles and
846	* winchildren.c
847	*
848	* @returns 0 on success, non-zero on failure.
849	* @param pCtx The command execution context.
850	* @param cOrders Number of file operation orders.
851	* @param paOrders The file operation orders.
852	* @param pafReplace Replace (TRUE) or leave alone (FALSE) indicator
853	* for each of the starndard handles.
854	* @param pahChild Array of standard handles for injecting into the
855	* child. Parallel to pafReplace.
856	*/
857	static int kRedirectOrderToWindowsHandles(PKMKBUILTINCTX pCtx, unsigned cOrders, REDIRECTORDERS *paOrders,
858	BOOL pafReplace[3], HANDLE pahChild[3])
859	{
860	int i;
861	for (i = 0; i < (int)cOrders; i++)
862	{
863	int fdTarget = paOrders[i].fdTarget;
864	assert(fdTarget >= 0 && fdTarget < 3);
865	switch (paOrders[i].enmOrder)
866	{
867	case kRedirectOrder_Open:
868	if ( (paOrders[i].fOpen & O_APPEND)
869	&& lseek(paOrders[i].fdSource, 0, SEEK_END) < 0)
870	return err(pCtx, 10, "lseek-to-end failed on %d (for %d)", paOrders[i].fdSource, fdTarget);
871	/* fall thru */
872	case kRedirectOrder_Dup:
873	pahChild[fdTarget] = (HANDLE)_get_osfhandle(paOrders[i].fdSource);
874	if (pahChild[fdTarget] == NULL \|\| pahChild[fdTarget] == INVALID_HANDLE_VALUE)
875	return err(pCtx, 10, "_get_osfhandle failed on %d (for %d)", paOrders[i].fdSource, fdTarget);
876	break;
877
878	case kRedirectOrder_Close:
879	pahChild[fdTarget] = NULL;
880	break;
881
882	default:
883	assert(0);
884	}
885	pafReplace[fdTarget] = TRUE;
886	}
887	return 0;
888	}
889
890
891	/**
892	* Alternative approach on windows that use CreateProcess and doesn't require
893	* any serialization wrt handles and CWD.
894	*
895	* @returns 0 on success, non-zero on failure to create.
896	* @param pCtx The command execution context.
897	* @param pszExecutable The child process executable.
898	* @param cArgs Number of arguments.
899	* @param papszArgs The child argument vector.
900	* @param papszEnvVars The child environment vector.
901	* @param pszCwd The current working directory of the child.
902	* @param cOrders Number of file operation orders.
903	* @param paOrders The file operation orders.
904	* @param phProcess Where to return process handle.
905	*/
906	static int kRedirectCreateProcessWindows(PKMKBUILTINCTX pCtx, const char pszExecutable, int cArgs, char *papszArgs,
907	char *papszEnvVars, const char pszCwd, unsigned cOrders,
908	REDIRECTORDERS paOrders, HANDLE phProcess)
909	{
910	size_t cbArgs;
911	char *pszCmdLine;
912	size_t cbEnv;
913	char *pszzEnv;
914	char *pch;
915	int i;
916	int rc;
917
918	/*
919	* Start by making the the command line. We just need to put spaces
920	* between the arguments since quote_argv don't the quoting already.
921	*/
922	cbArgs = 0;
923	for (i = 0; i < cArgs; i++)
924	cbArgs += strlen(papszArgs[i]) + 1;
925	pszCmdLine = pch = (char *)malloc(cbArgs);
926	if (!pszCmdLine)
927	return errx(pCtx, 9, "out of memory!");
928	for (i = 0; i < cArgs; i++)
929	{
930	size_t cch;
931	if (i != 0)
932	*pch++ = ' ';
933	cch = strlen(papszArgs[i]);
934	memcpy(pch, papszArgs[i], cch);
935	pch += cch;
936	}
937	*pch++ = '\0';
938	assert(pch - pszCmdLine == cbArgs);
939
940	/*
941	* The environment vector is also simple.
942	*/
943	cbEnv = 0;
944	for (i = 0; papszEnvVars[i]; i++)
945	cbEnv += strlen(papszEnvVars[i]) + 1;
946	cbEnv++;
947	pszzEnv = pch = (char *)malloc(cbEnv);
948	if (pszzEnv)
949	{
950	char szAbsExe[1024];
951	const char *pszPathVal = NULL;
952	STARTUPINFOA StartupInfo;
953	PROCESS_INFORMATION ProcInfo = { NULL, NULL, 0, 0 };
954
955	for (i = 0; papszEnvVars[i]; i++)
956	{
957	size_t cbSrc = strlen(papszEnvVars[i]) + 1;
958	memcpy(pch, papszEnvVars[i], cbSrc);
959	if ( !pszPathVal
960	&& cbSrc >= 5
961	&& pch[4] == '='
962	&& (pch[0] == 'P' \|\| pch[0] == 'p')
963	&& (pch[1] == 'A' \|\| pch[1] == 'a')
964	&& (pch[2] == 'T' \|\| pch[2] == 't')
965	&& (pch[3] == 'H' \|\| pch[3] == 'h'))
966	pszPathVal = &pch[5];
967	pch += cbSrc;
968	}
969	*pch++ = '\0';
970	assert(pch - pszzEnv == cbEnv);
971
972	/*
973	* Locate the executable.
974	*/
975	pszExecutable = kRedirectCreateProcessWindowsFindImage(pszExecutable, szAbsExe, sizeof(szAbsExe), pszPathVal);
976
977	/*
978	* Do basic startup info preparation.
979	*/
980	memset(&StartupInfo, 0, sizeof(StartupInfo));
981	StartupInfo.cb = sizeof(StartupInfo);
982	GetStartupInfoA(&StartupInfo);
983	StartupInfo.lpReserved2 = 0; /* No CRT file handle + descriptor info possible, sorry. */
984	StartupInfo.cbReserved2 = 0;
985	StartupInfo.dwFlags &= ~STARTF_USESTDHANDLES;
986
987	/*
988	* If there are no redirection orders, we're good.
989	*/
990	if (!cOrders)
991	{
992	if (CreateProcessA(pszExecutable, pszCmdLine, NULL /pProcAttrs/, NULL /pThreadAttrs/,
993	FALSE /fInheritHandles/, 0 /fFlags/, pszzEnv, pszCwd, &StartupInfo, &ProcInfo))
994	{
995	CloseHandle(ProcInfo.hThread);
996	*phProcess = ProcInfo.hProcess;
997	# ifndef KMK_BUILTIN_STANDALONE
998	kmk_cache_exec_image_a(pszExecutable);
999	# endif
1000	rc = 0;
1001	}
1002	else
1003	rc = errx(pCtx, 10, "CreateProcessA(%s) failed: %u", pszExecutable, GetLastError());
1004	}
1005	else
1006	{
1007	/*
1008	* Execute the orders, ending up with three handles we need to
1009	* implant into the guest process.
1010	*
1011	* This isn't 100% perfect wrt O_APPEND, but it'll have to do for now.
1012	*/
1013	BOOL afReplace[3] = { FALSE, FALSE, FALSE };
1014	HANDLE ahChild[3] = { NULL, NULL, NULL };
1015	rc = kRedirectOrderToWindowsHandles(pCtx, cOrders, paOrders, afReplace, ahChild);
1016	if (rc == 0)
1017	{
1018	/*
1019	* Start the process in suspended animation so we can inject handles.
1020	*/
1021	if (CreateProcessA(pszExecutable, pszCmdLine, NULL /pProcAttrs/, NULL /pThreadAttrs/,
1022	FALSE /fInheritHandles/, CREATE_SUSPENDED, pszzEnv, pszCwd, &StartupInfo, &ProcInfo))
1023	{
1024	unsigned i;
1025
1026	/* Inject the handles and try make it start executing. */
1027	char szErrMsg[128];
1028	rc = nt_child_inject_standard_handles(ProcInfo.hProcess, afReplace, ahChild, szErrMsg, sizeof(szErrMsg));
1029	if (rc)
1030	rc = errx(pCtx, 10, "%s", szErrMsg);
1031	else if (!ResumeThread(ProcInfo.hThread))
1032	rc = errx(pCtx, 10, "ResumeThread failed: %u", GetLastError());
1033
1034	/* Duplicate the write end of any stdin pipe handles into the child. */
1035	for (i = 0; i < cOrders; i++)
1036	if (paOrders[i].fdOtherPipeEnd >= 0)
1037	{
1038	HANDLE hIgnored = INVALID_HANDLE_VALUE;
1039	HANDLE hPipeW = (HANDLE)_get_osfhandle(paOrders[i].fdOtherPipeEnd);
1040	if (!DuplicateHandle(GetCurrentProcess(), hPipeW, ProcInfo.hProcess, &hIgnored, 0 /fDesiredAccess/,
1041	TRUE /fInheritable/, DUPLICATE_SAME_ACCESS))
1042	rc = errx(pCtx, 10, "DuplicateHandle failed on other stdin pipe end %d/%p: %u",
1043	paOrders[i].fdOtherPipeEnd, hPipeW, GetLastError());
1044	}
1045
1046	/* Kill it if any of that fails. */
1047	if (rc != 0)
1048	TerminateProcess(ProcInfo.hProcess, rc);
1049
1050	CloseHandle(ProcInfo.hThread);
1051	*phProcess = ProcInfo.hProcess;
1052	# ifndef KMK_BUILTIN_STANDALONE
1053	kmk_cache_exec_image_a(pszExecutable);
1054	# endif
1055	rc = 0;
1056	}
1057	else
1058	rc = errx(pCtx, 10, "CreateProcessA(%s) failed: %u", pszExecutable, GetLastError());
1059	}
1060	}
1061	free(pszzEnv);
1062	}
1063	else
1064	rc = errx(pCtx, 9, "out of memory!");
1065	free(pszCmdLine);
1066	return rc;
1067	}
1068
1069	# if !defined(KMK_BUILTIN_STANDALONE) && defined(CONFIG_NEW_WIN_CHILDREN)
1070	/**
1071	* Pass the problem on to winchildren.c when we're on one of its workers.
1072	*
1073	* @returns 0 on success, non-zero on failure to create.
1074	* @param pCtx The command execution context.
1075	* @param pszExecutable The child process executable.
1076	* @param cArgs Number of arguments.
1077	* @param papszArgs The child argument vector.
1078	* @param papszEnvVars The child environment vector.
1079	* @param pszCwd The current working directory of the child.
1080	* @param cOrders Number of file operation orders.
1081	* @param paOrders The file operation orders.
1082	* @param phProcess Where to return process handle.
1083	* @param pfIsChildExitCode Where to indicate whether the return exit code
1084	* is from the child or from our setup efforts.
1085	*/
1086	static int kRedirectExecProcessWithinOnWorker(PKMKBUILTINCTX pCtx, const char pszExecutable, int cArgs, char *papszArgs,
1087	char *papszEnvVars, const char pszCwd, unsigned cOrders,
1088	REDIRECTORDERS paOrders, KBOOL pfIsChildExitCode)
1089	{
1090	BOOL afReplace[3] = { FALSE, FALSE, FALSE };
1091	HANDLE ahChild[3] = { NULL, NULL, NULL };
1092	int rc = kRedirectOrderToWindowsHandles(pCtx, cOrders, paOrders, afReplace, ahChild);
1093	if (rc == 0)
1094	{
1095	rc = MkWinChildBuiltInExecChild(pCtx->pvWorker, pszExecutable, papszArgs, TRUE /fQuotedArgv/,
1096	papszEnvVars, pszCwd, afReplace, ahChild);
1097	*pfIsChildExitCode = K_TRUE;
1098	}
1099	return rc;
1100	}
1101	# endif /* !KMK_BUILTIN_STANDALONE */
1102
1103	#endif /* KBUILD_OS_WINDOWS */
1104
1105	/**
1106	* Does the child spawning .
1107	*
1108	* @returns Exit code.
1109	* @param pCtx The command execution context.
1110	* @param pszExecutable The child process executable.
1111	* @param cArgs Number of arguments.
1112	* @param papszArgs The child argument vector.
1113	* @param fWatcomBrainDamage Whether MSC need to do quoting according to
1114	* weird Watcom WCC rules.
1115	* @param papszEnvVars The child environment vector.
1116	* @param pszCwd The current working directory of the child.
1117	* @param pszSavedCwd The saved current working directory. This is
1118	* NULL if the CWD doesn't need changing.
1119	* @param cOrders Number of file operation orders.
1120	* @param paOrders The file operation orders.
1121	* @param pFileActions The posix_spawn file actions.
1122	* @param cVerbosity The verbosity level.
1123	* @param pPidSpawned Where to return the PID of the spawned child
1124	* when we're inside KMK and we're return without
1125	* waiting.
1126	* @param pfIsChildExitCode Where to indicate whether the return exit code
1127	* is from the child or from our setup efforts.
1128	*/
1129	static int kRedirectDoSpawn(PKMKBUILTINCTX pCtx, const char pszExecutable, int cArgs, char *papszArgs, int fWatcomBrainDamage,
1130	char *papszEnvVars, const char pszCwd, const char *pszSavedCwd,
1131	unsigned cOrders, REDIRECTORDERS *paOrders,
1132	#ifdef USE_POSIX_SPAWN
1133	posix_spawn_file_actions_t *pFileActions,
1134	#endif
1135	unsigned cVerbosity,
1136	#ifdef KMK
1137	pid_t *pPidSpawned,
1138	#endif
1139	KBOOL *pfIsChildExitCode)
1140	{
1141	int rcExit = 0;
1142	int i;
1143	#ifdef _MSC_VER
1144	char **papszArgsOriginal = papszArgs;
1145	#endif
1146	*pfIsChildExitCode = K_FALSE;
1147
1148	#ifdef _MSC_VER
1149	/*
1150	* Do MSC parameter quoting.
1151	*/
1152	papszArgs = malloc((cArgs + 1) * sizeof(papszArgs[0]));
1153	if (papszArgs)
1154	memcpy(papszArgs, papszArgsOriginal, (cArgs + 1) * sizeof(papszArgs[0]));
1155	else
1156	return errx(pCtx, 9, "out of memory!");
1157
1158	rcExit = quote_argv(cArgs, papszArgs, fWatcomBrainDamage, 0 /fFreeOrLeak/);
1159	if (rcExit == 0)
1160	#endif
1161	{
1162	/*
1163	* Display what we're about to execute if we're in verbose mode.
1164	*/
1165	if (cVerbosity > 0)
1166	{
1167	for (i = 0; i < cArgs; i++)
1168	warnx(pCtx, "debug: argv[%i]=%s<eos>", i, papszArgs[i]);
1169	for (i = 0; i < (int)cOrders; i++)
1170	switch (paOrders[i].enmOrder)
1171	{
1172	case kRedirectOrder_Close:
1173	warnx(pCtx, "debug: close %d\n", paOrders[i].fdTarget);
1174	break;
1175	case kRedirectOrder_Dup:
1176	warnx(pCtx, "debug: dup %d to %d\n", paOrders[i].fdSource, paOrders[i].fdTarget);
1177	break;
1178	case kRedirectOrder_Open:
1179	warnx(pCtx, "debug: open '%s' (%#x) as [%d ->] %d\n",
1180	paOrders[i].pszFilename, paOrders[i].fOpen, paOrders[i].fdSource, paOrders[i].fdTarget);
1181	break;
1182	default:
1183	warnx(pCtx, "error! invalid enmOrder=%d", paOrders[i].enmOrder);
1184	assert(0);
1185	break;
1186	}
1187	if (pszSavedCwd)
1188	warnx(pCtx, "debug: chdir %s\n", pszCwd);
1189	}
1190
1191	#ifndef KBUILD_OS_WINDOWS
1192	/*
1193	* Change working directory if so requested.
1194	*/
1195	if (pszSavedCwd)
1196	{
1197	if (chdir(pszCwd) < 0)
1198	rcExit = errx(pCtx, 10, "Failed to change directory to '%s'", pszCwd);
1199	}
1200	#endif /* KBUILD_OS_WINDOWS */
1201	if (rcExit == 0)
1202	{
1203	# if !defined(USE_POSIX_SPAWN) && !defined(KBUILD_OS_WINDOWS)
1204	/*
1205	* Execute the file orders.
1206	*/
1207	FILE *pWorkingStdErr = NULL;
1208	rcExit = kRedirectExecFdOrders(pCtx, cOrders, paOrders, &pWorkingStdErr);
1209	if (rcExit == 0)
1210	# endif
1211	{
1212	# ifdef KMK
1213	/*
1214	* We're spawning from within kmk.
1215	*/
1216	# ifdef KBUILD_OS_WINDOWS
1217	/* Windows is slightly complicated due to handles and winchildren.c. */
1218	if (pPidSpawned)
1219	*pPidSpawned = 0;
1220	# ifdef CONFIG_NEW_WIN_CHILDREN
1221	if (pCtx->pvWorker && !pPidSpawned)
1222	rcExit = kRedirectExecProcessWithinOnWorker(pCtx, pszExecutable, cArgs, papszArgs, papszEnvVars,
1223	pszSavedCwd ? pszCwd : NULL, cOrders, paOrders,
1224	pfIsChildExitCode);
1225	else
1226	# endif
1227	{
1228	HANDLE hProcess = INVALID_HANDLE_VALUE;
1229	rcExit = kRedirectCreateProcessWindows(pCtx, pszExecutable, cArgs, papszArgs, papszEnvVars,
1230	pszSavedCwd ? pszCwd : NULL, cOrders, paOrders, &hProcess);
1231	if (rcExit == 0)
1232	rcExit = kRedirectPostnatalCareOnWindows(pCtx, hProcess, cVerbosity, pPidSpawned, pfIsChildExitCode);
1233	}
1234
1235	# elif defined(KBUILD_OS_OS2)
1236	*pPidSpawned = _spawnvpe(P_NOWAIT, pszExecutable, papszArgs, papszEnvVars);
1237	kRedirectRestoreFdOrders(pCtx, cOrders, paOrders, &pWorkingStdErr);
1238	if (*pPidSpawned != -1)
1239	{
1240	if (cVerbosity > 0)
1241	warnx(pCtx, "debug: spawned %d", *pPidSpawned);
1242	}
1243	else
1244	{
1245	rcExit = err(pCtx, 10, "_spawnvpe(%s) failed", pszExecutable);
1246	*pPidSpawned = 0;
1247	}
1248	# else
1249	rcExit = posix_spawnp(pPidSpawned, pszExecutable, pFileActions, NULL /pAttr/, papszArgs, papszEnvVars);
1250	if (rcExit == 0)
1251	{
1252	if (cVerbosity > 0)
1253	warnx(pCtx, "debug: spawned %d", *pPidSpawned);
1254	}
1255	else
1256	{
1257	rcExit = errx(pCtx, 10, "posix_spawnp(%s) failed: %s", pszExecutable, strerror(rcExit));
1258	*pPidSpawned = 0;
1259	}
1260	# endif
1261
1262	#else /* !KMK */
1263	/*
1264	* Spawning from inside the kmk_redirect executable.
1265	*/
1266	# ifdef KBUILD_OS_WINDOWS
1267	HANDLE hProcess = INVALID_HANDLE_VALUE;
1268	rcExit = kRedirectCreateProcessWindows(pCtx, pszExecutable, cArgs, papszArgs, papszEnvVars,
1269	pszSavedCwd ? pszCwd : NULL, cOrders, paOrders, &hProcess);
1270	if (rcExit == 0)
1271	{
1272	DWORD dwWait;
1273	do
1274	dwWait = WaitForSingleObject(hProcess, INFINITE);
1275	while (dwWait == WAIT_IO_COMPLETION \|\| dwWait == WAIT_TIMEOUT);
1276
1277	dwWait = 11;
1278	if (GetExitCodeProcess(hProcess, &dwWait))
1279	{
1280	*pfIsChildExitCode = K_TRUE;
1281	rcExit = dwWait;
1282	}
1283	else
1284	rcExit = errx(pCtx, 11, "GetExitCodeProcess(%s) failed: %u", pszExecutable, GetLastError());
1285	}
1286
1287	#elif defined(KBUILD_OS_OS2)
1288	errno = 0;
1289	rcExit = (int)_spawnvpe(P_WAIT, pszExecutable, papszArgs, papszEnvVars);
1290	kRedirectRestoreFdOrders(pCtx, cOrders, paOrders, &pWorkingStdErr);
1291	if (rcExit != -1 \|\| errno == 0)
1292	{
1293	*pfIsChildExitCode = K_TRUE;
1294	if (cVerbosity > 0)
1295	warnx(pCtx, "debug: exit code: %d", rcExit);
1296	}
1297	else
1298	rcExit = err(pCtx, 10, "_spawnvpe(%s) failed", pszExecutable);
1299
1300	# else
1301	pid_t pidChild = 0;
1302	rcExit = posix_spawnp(&pidChild, pszExecutable, pFileActions, NULL /pAttr/, papszArgs, papszEnvVars);
1303	if (rcExit == 0)
1304	{
1305	*pfIsChildExitCode = K_TRUE;
1306	if (cVerbosity > 0)
1307	warnx(pCtx, "debug: spawned %d", pidChild);
1308
1309	/* Wait for the child. */
1310	for (;;)
1311	{
1312	int rcExitRaw = 1;
1313	pid_t pid = waitpid(pidChild, &rcExitRaw, 0 /block/);
1314	if (pid == pidChild)
1315	{
1316	rcExit = WIFEXITED(rcExitRaw) ? WEXITSTATUS(rcExitRaw) : 63;
1317	if (cVerbosity > 0)
1318	warnx(pCtx, "debug: %d exit code: %d (%d)", pidChild, rcExit, rcExitRaw);
1319	break;
1320	}
1321	if ( errno != EINTR
1322	# ifdef ERESTART
1323	&& errno != ERESTART
1324	# endif
1325	)
1326	{
1327	rcExit = err(pCtx, 11, "waitpid failed");
1328	kill(pidChild, SIGKILL);
1329	break;
1330	}
1331	}
1332	}
1333	else
1334	rcExit = errx(pCtx, 10, "posix_spawnp(%s) failed: %s", pszExecutable, strerror(rcExit));
1335	# endif
1336	#endif /* !KMK */
1337	}
1338	}
1339
1340	#ifndef KBUILD_OS_WINDOWS
1341	/*
1342	* Restore the current directory.
1343	*/
1344	if (pszSavedCwd)
1345	{
1346	if (chdir(pszSavedCwd) < 0)
1347	warn(pCtx, "Failed to restore directory to '%s'", pszSavedCwd);
1348	}
1349	#endif
1350	}
1351	#ifdef _MSC_VER
1352	else
1353	rcExit = errx(pCtx, 9, "quite_argv failed: %u", rcExit);
1354
1355	/* Restore the original argv strings, freeing the quote_argv replacements. */
1356	i = cArgs;
1357	while (i-- > 0)
1358	if (papszArgs[i] != papszArgsOriginal[i])
1359	free(papszArgs[i]);
1360	free(papszArgs);
1361	#endif
1362	return rcExit;
1363	}
1364
1365
1366	/**
1367	* The function that does almost everything here... ugly.
1368	*/
1369	int kmk_builtin_redirect(int argc, char argv, char envp, PKMKBUILTINCTX pCtx, struct child pChild, pid_t pPidSpawned)
1370	{
1371	int rcExit = 0;
1372	KBOOL fChildExitCode = K_FALSE;
1373	#ifdef USE_POSIX_SPAWN
1374	posix_spawn_file_actions_t FileActions;
1375	#endif
1376	unsigned cOrders = 0;
1377	REDIRECTORDERS aOrders[32];
1378
1379	int iArg;
1380	const char *pszExecutable = NULL;
1381	char **papszEnvVars = NULL;
1382	unsigned cAllocatedEnvVars;
1383	unsigned cEnvVars;
1384	int fWatcomBrainDamage = 0;
1385	int cVerbosity = 0;
1386	char *pszSavedCwd = NULL;
1387	size_t const cbCwdBuf = GET_PATH_MAX;
1388	PATH_VAR(szCwd);
1389	#ifdef KBUILD_OS_OS2
1390	ULONG ulLibPath;
1391	char *apszSavedLibPaths[LIBPATHSTRICT + 1] = { NULL, NULL, NULL, NULL };
1392	#endif
1393
1394
1395	if (argc <= 1)
1396	return kmk_redirect_usage(pCtx, 1);
1397
1398	/*
1399	* Create default program environment.
1400	*/
1401	#if defined(KMK) && defined(KBUILD_OS_WINDOWS)
1402	if (getcwd_fs(szCwd, cbCwdBuf) != NULL)
1403	#else
1404	if (getcwd(szCwd, cbCwdBuf) != NULL)
1405	#endif
1406	{ /* likely */ }
1407	else
1408	return err(pCtx, 9, "getcwd failed");
1409
1410	/* We start out with a read-only enviornment from kmk or the crt, and will
1411	duplicate it if we make changes to it. */
1412	cAllocatedEnvVars = 0;
1413	papszEnvVars = envp;
1414	cEnvVars = 0;
1415	while (papszEnvVars[cEnvVars] != NULL)
1416	cEnvVars++;
1417
1418	#ifdef USE_POSIX_SPAWN
1419	/*
1420	* Init posix attributes with stdout/err redirections according to pCtx.
1421	*/
1422	rcExit = posix_spawn_file_actions_init(&FileActions);
1423	if (rcExit != 0)
1424	rcExit = errx(pCtx, 9, "posix_spawn_file_actions_init failed: %s", strerror(rcExit));
1425	# if !defined(KMK_BUILTIN_STANDALONE) && !defined(CONFIG_WITH_OUTPUT_IN_MEMORY)
1426	if (pCtx->pOut && rcExit == 0)
1427	{
1428	if (pCtx->pOut->out >= 0)
1429	{
1430	rcExit = posix_spawn_file_actions_adddup2(&FileActions, pCtx->pOut->out, 1);
1431	if (rcExit != 0)
1432	rcExit = errx(pCtx, 2, "posix_spawn_file_actions_addclose(%d, 1) failed: %s", pCtx->pOut->out, strerror(rcExit));
1433	}
1434	if (pCtx->pOut->err >= 0 && rcExit == 0)
1435	{
1436	rcExit = posix_spawn_file_actions_adddup2(&FileActions, pCtx->pOut->err, 2);
1437	if (rcExit != 0)
1438	rcExit = errx(pCtx, 2, "posix_spawn_file_actions_addclose(%d, 1) failed: %s", pCtx->pOut->err, strerror(rcExit));
1439	}
1440	}
1441	# endif
1442	#endif
1443
1444	/*
1445	* Parse arguments.
1446	*/
1447	for (iArg = 1; rcExit == 0 && iArg < argc; iArg++)
1448	{
1449	char *pszArg = argv[iArg];
1450	if (*pszArg == '-')
1451	{
1452	int fd;
1453	char chOpt;
1454	const char *pszValue;
1455
1456	chOpt = *++pszArg;
1457	pszArg++;
1458	if (chOpt == '-')
1459	{
1460	/* '--' indicates where the bits to execute start. Check if we're
1461	relaunching ourselves here and just continue parsing if we are. */
1462	if (*pszArg == '\0')
1463	{
1464	iArg++;
1465	if ( iArg >= argc
1466	\|\| ( strcmp(argv[iArg], "kmk_builtin_redirect") != 0
1467	&& strcmp(argv[iArg], argv[0]) != 0))
1468	break;
1469	continue;
1470	}
1471
1472	if ( strcmp(pszArg, "wcc-brain-damage") == 0
1473	\|\| strcmp(pszArg, "watcom-brain-damage") == 0)
1474	{
1475	fWatcomBrainDamage = 1;
1476	continue;
1477	}
1478
1479	/* convert to short. */
1480	if (strcmp(pszArg, "help") == 0)
1481	chOpt = 'h';
1482	else if (strcmp(pszArg, "version") == 0)
1483	chOpt = 'V';
1484	else if ( strcmp(pszArg, "set") == 0
1485	\|\| strcmp(pszArg, "env") == 0)
1486	chOpt = 'E';
1487	else if (strcmp(pszArg, "append") == 0)
1488	chOpt = 'A';
1489	else if (strcmp(pszArg, "prepend") == 0)
1490	chOpt = 'D';
1491	else if (strcmp(pszArg, "unset") == 0)
1492	chOpt = 'U';
1493	else if ( strcmp(pszArg, "zap-env") == 0
1494	\|\| strcmp(pszArg, "ignore-environment") == 0 /* GNU env compatibility. */ )
1495	chOpt = 'Z';
1496	else if (strcmp(pszArg, "chdir") == 0)
1497	chOpt = 'C';
1498	else if (strcmp(pszArg, "close") == 0)
1499	chOpt = 'c';
1500	else if (strcmp(pszArg, "verbose") == 0)
1501	chOpt = 'v';
1502	else if (strcmp(pszArg, "stdin-pipe") == 0)
1503	chOpt = 'I';
1504	else
1505	{
1506	errx(pCtx, 2, "Unknown option: '%s'", pszArg - 2);
1507	rcExit = kmk_redirect_usage(pCtx, 1);
1508	break;
1509	}
1510	pszArg = "";
1511	}
1512
1513	/*
1514	* Deal with the obligatory help and version switches first to get them out of the way.
1515	*/
1516	if (chOpt == 'h')
1517	{
1518	kmk_redirect_usage(pCtx, 0);
1519	rcExit = -1;
1520	break;
1521	}
1522	if (chOpt == 'V')
1523	{
1524	kbuild_version(argv[0]);
1525	rcExit = -1;
1526	break;
1527	}
1528
1529	/*
1530	* Get option value first, if the option takes one.
1531	*/
1532	if ( chOpt == 'E'
1533	\|\| chOpt == 'A'
1534	\|\| chOpt == 'D'
1535	\|\| chOpt == 'U'
1536	\|\| chOpt == 'C'
1537	\|\| chOpt == 'c'
1538	\|\| chOpt == 'd'
1539	\|\| chOpt == 'e')
1540	{
1541	if (*pszArg != '\0')
1542	pszValue = pszArg + (pszArg == ':' \|\| pszArg == '=');
1543	else if (++iArg < argc)
1544	pszValue = argv[iArg];
1545	else
1546	{
1547	errx(pCtx, 2, "syntax error: Option -%c requires a value!", chOpt);
1548	rcExit = kmk_redirect_usage(pCtx, 1);
1549	break;
1550	}
1551	}
1552	else
1553	pszValue = NULL;
1554
1555	/*
1556	* Environment switch?
1557	*/
1558	if (chOpt == 'E')
1559	{
1560	const char *pchEqual = strchr(pszValue, '=');
1561	#ifdef KBUILD_OS_OS2
1562	if ( strncmp(pszValue, TUPLE("BEGINLIBPATH=")) == 0
1563	\|\| strncmp(pszValue, TUPLE("ENDLIBPATH=")) == 0
1564	\|\| strncmp(pszValue, TUPLE("LIBPATHSTRICT=")) == 0)
1565	{
1566	ULONG ulVar = *pszValue == 'B' ? BEGIN_LIBPATH
1567	: *pszValue == 'E' ? END_LIBPATH
1568	: LIBPATHSTRICT;
1569	APIRET rc;
1570	if (apszSavedLibPaths[ulVar] == NULL)
1571	{
1572	/* The max length is supposed to be 1024 bytes. */
1573	apszSavedLibPaths[ulVar] = calloc(1024, 2);
1574	if (apszSavedLibPaths[ulVar])
1575	{
1576	rc = DosQueryExtLIBPATH(apszSavedLibPaths[ulVar], ulVar);
1577	if (rc)
1578	{
1579	rcExit = errx(pCtx, 9, "DosQueryExtLIBPATH(,%u) failed: %lu", ulVar, rc);
1580	free(apszSavedLibPaths[ulVar]);
1581	apszSavedLibPaths[ulVar] = NULL;
1582	}
1583	}
1584	else
1585	rcExit = errx(pCtx, 9, "out of memory!");
1586	}
1587	if (rcExit == 0)
1588	{
1589	rc = DosSetExtLIBPATH(pchEqual + 1, ulVar);
1590	if (rc)
1591	rcExit = errx(pCtx, 9, "error: DosSetExtLibPath(\"%s\", %.*s (%lu)): %lu",
1592	pchEqual, pchEqual - pszValue, pchEqual + 1, ulVar, rc);
1593	}
1594	continue;
1595	}
1596	#endif /* KBUILD_OS_OS2 */
1597
1598	/* We differ from kSubmit here and use putenv sematics. */
1599	if (pchEqual)
1600	{
1601	if (pchEqual[1] != '\0')
1602	rcExit = kBuiltinOptEnvSet(pCtx, &papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity, pszValue);
1603	else
1604	{
1605	char *pszCopy = strdup(pszValue);
1606	if (pszCopy)
1607	{
1608	pszCopy[pchEqual - pszValue] = '\0';
1609	rcExit = kBuiltinOptEnvUnset(pCtx, &papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity, pszCopy);
1610	free(pszCopy);
1611	}
1612	else
1613	rcExit = errx(pCtx, 1, "out of memory!");
1614	}
1615	continue;
1616	}
1617	/* Simple unset. */
1618	chOpt = 'U';
1619	}
1620
1621	/*
1622	* Append or prepend value to and environment variable.
1623	*/
1624	if (chOpt == 'A' \|\| chOpt == 'D')
1625	{
1626	#ifdef KBUILD_OS_OS2
1627	if ( strcmp(pszValue, "BEGINLIBPATH") == 0
1628	\|\| strcmp(pszValue, "ENDLIBPATH") == 0
1629	\|\| strcmp(pszValue, "LIBPATHSTRICT") == 0)
1630	rcExit = errx(pCtx, 2, "error: '%s' cannot currently be appended or prepended to. Please use -E/--set for now.", pszValue);
1631	else
1632	#endif
1633	if (chOpt == 'A')
1634	rcExit = kBuiltinOptEnvAppend(pCtx, &papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity, pszValue);
1635	else
1636	rcExit = kBuiltinOptEnvPrepend(pCtx, &papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity, pszValue);
1637	continue;
1638	}
1639
1640	/*
1641	* Unset environment variable.
1642	*/
1643	if (chOpt == 'U')
1644	{
1645	#ifdef KBUILD_OS_OS2
1646	if ( strcmp(pszValue, "BEGINLIBPATH") == 0
1647	\|\| strcmp(pszValue, "ENDLIBPATH") == 0
1648	\|\| strcmp(pszValue, "LIBPATHSTRICT") == 0)
1649	rcExit = errx(pCtx, 2, "error: '%s' cannot be unset, only set to an empty value using -E/--set.", pszValue);
1650	else
1651	#endif
1652	rcExit = kBuiltinOptEnvUnset(pCtx, &papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity, pszValue);
1653	continue;
1654	}
1655
1656	/*
1657	* Zap environment switch?
1658	*/
1659	if (chOpt == 'Z') /* (no -i option here, as it's reserved for stdin) */
1660	{
1661	rcExit = kBuiltinOptEnvZap(pCtx, &papszEnvVars, &cEnvVars, &cAllocatedEnvVars, cVerbosity);
1662	continue;
1663	}
1664
1665	/*
1666	* Change directory switch?
1667	*/
1668	if (chOpt == 'C')
1669	{
1670	if (pszSavedCwd == NULL)
1671	pszSavedCwd = strdup(szCwd);
1672	if (pszSavedCwd)
1673	rcExit = kBuiltinOptChDir(pCtx, szCwd, cbCwdBuf, pszValue);
1674	else
1675	rcExit = err(pCtx, 9, "out of memory!");
1676	continue;
1677	}
1678
1679
1680	/*
1681	* Verbose operation switch?
1682	*/
1683	if (chOpt == 'v')
1684	{
1685	cVerbosity++;
1686	continue;
1687	}
1688
1689	/*
1690	* Executable image other than the first argument following '--'.
1691	*/
1692	if (chOpt == 'e')
1693	{
1694	pszExecutable = pszValue;
1695	continue;
1696	}
1697
1698	/*
1699	* Okay, it is some file descriptor operation. Make sure we've got room for it.
1700	*/
1701	if (cOrders + 1 < K_ELEMENTS(aOrders))
1702	{
1703	aOrders[cOrders].fdTarget = -1;
1704	aOrders[cOrders].fdSource = -1;
1705	aOrders[cOrders].fOpen = 0;
1706	aOrders[cOrders].fRemoveOnFailure = 0;
1707	aOrders[cOrders].pszFilename = NULL;
1708	aOrders[cOrders].fdOtherPipeEnd = -1;
1709	#ifndef USE_POSIX_SPAWN
1710	aOrders[cOrders].fdSaved = -1;
1711	#endif
1712	}
1713	else
1714	{
1715	rcExit = errx(pCtx, 2, "error: too many file actions (max: %d)", K_ELEMENTS(aOrders));
1716	break;
1717	}
1718
1719	if (chOpt == 'c')
1720	{
1721	/*
1722	* Close the specified file descriptor (no stderr/out/in aliases).
1723	*/
1724	char *pszTmp;
1725	fd = (int)strtol(pszValue, &pszTmp, 0);
1726	if (pszTmp == pszValue \|\| *pszTmp != '\0')
1727	rcExit = errx(pCtx, 2, "error: failed to convert '%s' to a number", pszValue);
1728	else if (fd < 0)
1729	rcExit = errx(pCtx, 2, "error: negative fd %d (%s)", fd, pszValue);
1730	#ifdef ONLY_TARGET_STANDARD_HANDLES
1731	else if (fd > 2)
1732	rcExit = errx(pCtx, 2, "error: %d is not a standard descriptor number", fd);
1733	#endif
1734	else
1735	{
1736	aOrders[cOrders].enmOrder = kRedirectOrder_Close;
1737	aOrders[cOrders].fdTarget = fd;
1738	cOrders++;
1739	#ifdef USE_POSIX_SPAWN
1740	rcExit = posix_spawn_file_actions_addclose(&FileActions, fd);
1741	if (rcExit != 0)
1742	rcExit = errx(pCtx, 2, "posix_spawn_file_actions_addclose(%d) failed: %s", fd, strerror(rcExit));
1743	#endif
1744	}
1745	}
1746	else if (chOpt == 'd')
1747	{
1748	/*
1749	* Duplicate file handle. Value is fdTarget=fdSource
1750	*/
1751	char *pszEqual;
1752	fd = (int)strtol(pszValue, &pszEqual, 0);
1753	if (pszEqual == pszValue)
1754	rcExit = errx(pCtx, 2, "error: failed to convert target descriptor of '-d %s' to a number", pszValue);
1755	else if (fd < 0)
1756	rcExit = errx(pCtx, 2, "error: negative target descriptor %d ('-d %s')", fd, pszValue);
1757	#ifdef ONLY_TARGET_STANDARD_HANDLES
1758	else if (fd > 2)
1759	rcExit = errx(pCtx, 2, "error: target %d is not a standard descriptor number", fd);
1760	#endif
1761	else if (*pszEqual != '=')
1762	rcExit = errx(pCtx, 2, "syntax error: expected '=' to follow target descriptor: '-d %s'", pszValue);
1763	else
1764	{
1765	char *pszEnd;
1766	int fdSource = (int)strtol(++pszEqual, &pszEnd, 0);
1767	if (pszEnd == pszEqual \|\| *pszEnd != '\0')
1768	rcExit = errx(pCtx, 2, "error: failed to convert source descriptor of '-d %s' to a number", pszValue);
1769	else if (fdSource < 0)
1770	rcExit = errx(pCtx, 2, "error: negative source descriptor %d ('-d %s')", fdSource, pszValue);
1771	else
1772	{
1773	aOrders[cOrders].enmOrder = kRedirectOrder_Dup;
1774	aOrders[cOrders].fdTarget = fd;
1775	aOrders[cOrders].fdSource = fdSource;
1776	cOrders++;
1777	#ifdef USE_POSIX_SPAWN
1778	rcExit = posix_spawn_file_actions_adddup2(&FileActions, fdSource, fd);
1779	if (rcExit != 0)
1780	rcExit = errx(pCtx, 2, "posix_spawn_file_actions_adddup2(%d) failed: %s",
1781	fdSource, fd, strerror(rcExit));
1782	#endif
1783	}
1784	}
1785	}
1786	else if (chOpt == 'I')
1787	{
1788	/*
1789	* Replace stdin with the read end of an anonymous pipe.
1790	*/
1791	int aFds[2] = { -1, -1 };
1792	rcExit = kRedirectCreateStdInPipeWithoutConflict(pCtx, aFds, cOrders, aOrders, 0 /fdTarget/);
1793	if (rcExit == 0)
1794	{
1795	aOrders[cOrders].enmOrder = kRedirectOrder_Dup;
1796	aOrders[cOrders].fdTarget = 0;
1797	aOrders[cOrders].fdSource = aFds[0];
1798	aOrders[cOrders].fdOtherPipeEnd = aFds[1];
1799	cOrders++;
1800	#ifdef USE_POSIX_SPAWN
1801	rcExit = posix_spawn_file_actions_adddup2(&FileActions, aFds[0], 0);
1802	if (rcExit != 0)
1803	rcExit = errx(pCtx, 2, "posix_spawn_file_actions_adddup2(0) failed: %s", strerror(rcExit));
1804	#endif
1805	}
1806	}
1807	else
1808	{
1809	/*
1810	* Open file as a given file descriptor.
1811	*/
1812	int fdOpened;
1813	int fOpen;
1814
1815	/* mode */
1816	switch (chOpt)
1817	{
1818	case 'r':
1819	chOpt = *pszArg++;
1820	if (chOpt == '+')
1821	{
1822	fOpen = O_RDWR;
1823	chOpt = *pszArg++;
1824	}
1825	else
1826	fOpen = O_RDONLY;
1827	break;
1828
1829	case 'w':
1830	chOpt = *pszArg++;
1831	if (chOpt == '+')
1832	{
1833	fOpen = O_RDWR \| O_CREAT \| O_TRUNC;
1834	chOpt = *pszArg++;
1835	}
1836	else
1837	fOpen = O_WRONLY \| O_CREAT \| O_TRUNC;
1838	aOrders[cOrders].fRemoveOnFailure = 1;
1839	break;
1840
1841	case 'a':
1842	chOpt = *pszArg++;
1843	if (chOpt == '+')
1844	{
1845	fOpen = O_RDWR \| O_CREAT \| O_APPEND;
1846	chOpt = *pszArg++;
1847	}
1848	else
1849	fOpen = O_WRONLY \| O_CREAT \| O_APPEND;
1850	break;
1851
1852	case 'i': /* make sure stdin is read-only. */
1853	fOpen = O_RDONLY;
1854	break;
1855
1856	case '+':
1857	rcExit = errx(pCtx, 2, "syntax error: Unexpected '+' in '%s'", argv[iArg]);
1858	continue;
1859
1860	default:
1861	fOpen = O_RDWR \| O_CREAT \| O_TRUNC;
1862	aOrders[cOrders].fRemoveOnFailure = 1;
1863	break;
1864	}
1865
1866	/* binary / text modifiers */
1867	switch (chOpt)
1868	{
1869	case 'b':
1870	chOpt = *pszArg++;
1871	default:
1872	#ifdef O_BINARY
1873	fOpen \|= O_BINARY;
1874	#elif defined(_O_BINARY)
1875	fOpen \|= _O_BINARY;
1876	#endif
1877	break;
1878
1879	case 't':
1880	#ifdef O_TEXT
1881	fOpen \|= O_TEXT;
1882	#elif defined(_O_TEXT)
1883	fOpen \|= _O_TEXT;
1884	#endif
1885	chOpt = *pszArg++;
1886	break;
1887
1888	}
1889
1890	/* convert to file descriptor number */
1891	switch (chOpt)
1892	{
1893	case 'i':
1894	fd = 0;
1895	break;
1896
1897	case 'o':
1898	fd = 1;
1899	break;
1900
1901	case 'e':
1902	fd = 2;
1903	break;
1904
1905	case '0':
1906	if (*pszArg == '\0')
1907	{
1908	fd = 0;
1909	break;
1910	}
1911	/* fall thru */
1912	case '1':
1913	case '2':
1914	case '3':
1915	case '4':
1916	case '5':
1917	case '6':
1918	case '7':
1919	case '8':
1920	case '9':
1921	pszValue = pszArg - 1;
1922	fd = (int)strtol(pszValue, &pszArg, 0);
1923	if (pszArg == pszValue)
1924	rcExit = errx(pCtx, 2, "error: failed to convert '%s' to a number", argv[iArg]);
1925	else if (fd < 0)
1926	rcExit = errx(pCtx, 2, "error: negative fd %d (%s)", fd, argv[iArg]);
1927	#ifdef ONLY_TARGET_STANDARD_HANDLES
1928	else if (fd > 2)
1929	rcExit = errx(pCtx, 2, "error: %d is not a standard descriptor number", fd);
1930	#endif
1931	else
1932	break;
1933	continue;
1934
1935	/*
1936	* Invalid argument.
1937	*/
1938	default:
1939	rcExit = errx(pCtx, 2, "error: failed to convert '%s' ('%s') to a file descriptor", pszArg, argv[iArg]);
1940	continue;
1941	}
1942
1943	/*
1944	* Check for the filename.
1945	*/
1946	if (*pszArg != '\0')
1947	{
1948	if (pszArg != ':' && pszArg != '=')
1949	{
1950	rcExit = errx(pCtx, 2, "syntax error: characters following the file descriptor: '%s' ('%s')",
1951	pszArg, argv[iArg]);
1952	break;
1953	}
1954	pszArg++;
1955	}
1956	else if (++iArg < argc)
1957	pszArg = argv[iArg];
1958	else
1959	{
1960	rcExit = errx(pCtx, 2, "syntax error: missing filename argument.");
1961	break;
1962	}
1963
1964	/*
1965	* Open the file. We could've used posix_spawn_file_actions_addopen here,
1966	* but that means complicated error reporting. So, since we need to do
1967	* this for windows anyway, just do it the same way everywhere.
1968	*/
1969	fdOpened = kRedirectOpenWithoutConflict(pCtx, pszArg, fOpen, 0666, cOrders, aOrders,
1970	aOrders[cOrders].fRemoveOnFailure, fd);
1971	if (fdOpened >= 0)
1972	{
1973	aOrders[cOrders].enmOrder = kRedirectOrder_Open;
1974	aOrders[cOrders].fdTarget = fd;
1975	aOrders[cOrders].fdSource = fdOpened;
1976	aOrders[cOrders].fOpen = fOpen;
1977	aOrders[cOrders].pszFilename = pszArg;
1978	cOrders++;
1979
1980	#ifdef USE_POSIX_SPAWN
1981	if (fdOpened != fd)
1982	{
1983	rcExit = posix_spawn_file_actions_adddup2(&FileActions, fdOpened, fd);
1984	if (rcExit != 0)
1985	rcExit = err(pCtx, 9, "posix_spawn_file_actions_adddup2(,%d [%s], %d) failed: %s",
1986	fdOpened, fd, pszArg, strerror(rcExit));
1987	}
1988	#endif
1989	}
1990	else
1991	rcExit = 9;
1992	}
1993	}
1994	else
1995	{
1996	errx(pCtx, 2, "syntax error: Invalid argument '%s'.", argv[iArg]);
1997	rcExit = kmk_redirect_usage(pCtx, 1);
1998	}
1999	}
2000	if (!pszExecutable)
2001	pszExecutable = argv[iArg];
2002
2003	/*
2004	* Make sure there's something to execute.
2005	*/
2006	if (rcExit == 0 && iArg < argc)
2007	{
2008	/*
2009	* Do the spawning in a separate function (main is far to large as it is by now).
2010	*/
2011	rcExit = kRedirectDoSpawn(pCtx, pszExecutable, argc - iArg, &argv[iArg], fWatcomBrainDamage,
2012	papszEnvVars,
2013	szCwd, pszSavedCwd,
2014	#ifdef USE_POSIX_SPAWN
2015	cOrders, aOrders, &FileActions, cVerbosity,
2016	#else
2017	cOrders, aOrders, cVerbosity,
2018	#endif
2019	#ifdef KMK
2020	pPidSpawned,
2021	#endif
2022	&fChildExitCode);
2023	}
2024	else if (rcExit == 0)
2025	{
2026	errx(pCtx, 2, "syntax error: nothing to execute!");
2027	rcExit = kmk_redirect_usage(pCtx, 1);
2028	}
2029	/* Help and version sets rcExit to -1. Change it to zero. */
2030	else if (rcExit == -1)
2031	rcExit = 0;
2032
2033	/*
2034	* Cleanup.
2035	*/
2036	kBuiltinOptEnvCleanup(&papszEnvVars, cEnvVars, &cAllocatedEnvVars);
2037	if (pszSavedCwd)
2038	free(pszSavedCwd);
2039	kRedirectCleanupFdOrders(cOrders, aOrders, rcExit != 0 && !fChildExitCode);
2040	#ifdef USE_POSIX_SPAWN
2041	posix_spawn_file_actions_destroy(&FileActions);
2042	#endif
2043	#ifdef KBUILD_OS_OS2
2044	for (ulLibPath = 0; ulLibPath < K_ELEMENTS(apszSavedLibPaths); ulLibPath++)
2045	if (apszSavedLibPaths[ulLibPath] != NULL)
2046	{
2047	APIRET rc = DosSetExtLIBPATH(apszSavedLibPaths[ulLibPath], ulLibPath);
2048	if (rc != 0)
2049	warnx(pCtx, "DosSetExtLIBPATH('%s',%u) failed with %u when restoring the original values!",
2050	apszSavedLibPaths[ulLibPath], ulLibPath, rc);
2051	free(apszSavedLibPaths[ulLibPath]);
2052	}
2053	#endif
2054
2055	return rcExit;
2056	}
2057
2058	#ifdef KMK_BUILTIN_STANDALONE
2059	int main(int argc, char argv, char envp)
2060	{
2061	KMKBUILTINCTX Ctx = { "kmk_redirect", NULL };
2062	return kmk_builtin_redirect(argc, argv, envp, &Ctx, NULL, NULL);
2063	}
2064	#endif
2065
2066

Note: See TracBrowser for help on using the repository browser.

source: kBuild/trunk/src/kmk/kmkbuiltin/redirect.c

Download in other formats: