shinstance.c@ 3409

Last change on this file since 3409 was 3409, checked in by bird, 5 years ago
kash: Generate the signal names at compile time rather than lazily at runtime. This should be more efficient, though may cause trouble if cross building.
Property svn:eol-style set to `LF` Property svn:keywords set to `Id`
File size: 36.1 KB

Line
1	/* $Id: shinstance.c 3409 2020-08-13 09:49:06Z bird $ */
2	/** @file
3	* The shell instance methods.
4	*/
5
6	/*
7	* Copyright (c) 2007-2010 knut st. osmundsen <[email protected]>
8	*
9	*
10	* This file is part of kBuild.
11	*
12	* kBuild is free software; you can redistribute it and/or modify
13	* it under the terms of the GNU General Public License as published by
14	* the Free Software Foundation; either version 2 of the License, or
15	* (at your option) any later version.
16	*
17	* kBuild is distributed in the hope that it will be useful,
18	* but WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20	* GNU General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with kBuild; if not, write to the Free Software
24	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25	*
26	*/
27
28	/*******************************************************************************
29	* Header Files *
30	*******************************************************************************/
31	#include <string.h>
32	#include <stdlib.h>
33	#include <assert.h>
34	#ifdef _MSC_VER
35	# include <process.h>
36	#else
37	# include <unistd.h>
38	# include <pwd.h>
39	#endif
40	#include "shinstance.h"
41
42	#if K_OS == K_OS_WINDOWS
43	# include <Windows.h>
44	extern pid_t shfork_do(shinstance psh); / shforkA-win.asm */
45	#endif
46
47
48	/*******************************************************************************
49	* Global Variables *
50	*******************************************************************************/
51	/** The mutex protecting the the globals and some shell instance members (sigs). */
52	static shmtx g_sh_mtx;
53	/** The root shell instance. */
54	static shinstance *g_sh_root;
55	/** The first shell instance. */
56	static shinstance *g_sh_head;
57	/** The last shell instance. */
58	static shinstance *g_sh_tail;
59	/** The number of shells. */
60	static int volatile g_num_shells;
61	/** Per signal state for determining a common denominator.
62	* @remarks defaults and unmasked actions aren't counted. */
63	struct shsigstate
64	{
65	/** The current signal action. */
66	#ifndef _MSC_VER
67	struct sigaction sa;
68	#else
69	struct
70	{
71	void (*sa_handler)(int);
72	int sa_flags;
73	shsigset_t sa_mask;
74	} sa;
75	#endif
76	/** The number of restarts (siginterrupt / SA_RESTART). */
77	int num_restart;
78	/** The number of ignore handlers. */
79	int num_ignore;
80	/** The number of specific handlers. */
81	int num_specific;
82	/** The number of threads masking it. */
83	int num_masked;
84	} g_sig_state[NSIG];
85
86
87
88	int shmtx_init(shmtx *pmtx)
89	{
90	pmtx->b[0] = 0;
91	return 0;
92	}
93
94	void shmtx_delete(shmtx *pmtx)
95	{
96	pmtx->b[0] = 0;
97	}
98
99	void shmtx_enter(shmtx pmtx, shmtxtmp ptmp)
100	{
101	pmtx->b[0] = 0;
102	ptmp->i = 0;
103	}
104
105	void shmtx_leave(shmtx pmtx, shmtxtmp ptmp)
106	{
107	pmtx->b[0] = 0;
108	ptmp->i = 432;
109	}
110
111	/**
112	* Links the shell instance.
113	*
114	* @param psh The shell.
115	*/
116	static void sh_int_link(shinstance *psh)
117	{
118	shmtxtmp tmp;
119	shmtx_enter(&g_sh_mtx, &tmp);
120
121	if (psh->rootshell)
122	g_sh_root = psh;
123
124	psh->next = NULL;
125	psh->prev = g_sh_tail;
126	if (g_sh_tail)
127	g_sh_tail->next = psh;
128	else
129	g_sh_tail = g_sh_head = psh;
130	g_sh_tail = psh;
131
132	g_num_shells++;
133
134	shmtx_leave(&g_sh_mtx, &tmp);
135	}
136
137	#if 0
138	/**
139	* Unlink the shell instance.
140	*
141	* @param psh The shell.
142	*/
143	static void sh_int_unlink(shinstance *psh)
144	{
145	shmtxtmp tmp;
146	shmtx_enter(&g_sh_mtx, &tmp);
147
148	g_num_shells--;
149
150	if (g_sh_tail == psh)
151	g_sh_tail = psh->prev;
152	else
153	psh->next->prev = psh->prev;
154
155	if (g_sh_head == psh)
156	g_sh_head = psh->next;
157	else
158	psh->prev->next = psh->next;
159
160	if (g_sh_root == psh)
161	g_sh_root = 0;
162
163	shmtx_leave(&g_sh_mtx, &tmp);
164	}
165	#endif
166
167	/**
168	* Destroys the shell instance.
169	*
170	* This will work on partially initialized instances (because I'm lazy).
171	*
172	* @param psh The shell instance to be destroyed.
173	*/
174	static void sh_destroy(shinstance *psh)
175	{
176	memset(psh, 0, sizeof(*psh));
177	sh_free(NULL, psh);
178	}
179
180	/**
181	* Clones a string vector like environ or argv.
182	*
183	* @returns 0 on success, -1 and errno on failure.
184	* @param psh The shell to associate the allocations with.
185	* @param dstp Where to store the clone.
186	* @param src The vector to be cloned.
187	*/
188	static int sh_clone_string_vector(shinstance psh, char dstp, char src)
189	{
190	char **dst;
191	size_t items;
192
193	/* count first */
194	items = 0;
195	while (src[items])
196	items++;
197
198	/* alloc clone array. */
199	dstp = dst = sh_malloc(psh, sizeof(dst) * (items + 1));
200	if (!dst)
201	return -1;
202
203	/* copy the items */
204	dst[items] = NULL;
205	while (items-- > 0)
206	{
207	dst[items] = sh_strdup(psh, src[items]);
208	if (!dst[items])
209	{
210	/* allocation error, clean up. */
211	while (dst[++items])
212	sh_free(psh, dst[items]);
213	sh_free(psh, dst);
214	errno = ENOMEM;
215	return -1;
216	}
217	}
218
219	return 0;
220	}
221
222	/**
223	* Creates a root shell instance.
224	*
225	* @param inherit The shell to inherit from. If NULL inherit from environment and such.
226	* @param argc The argument count.
227	* @param argv The argument vector.
228	* @param envp The environment vector.
229	*
230	* @returns pointer to root shell on success, NULL on failure.
231	*/
232	shinstance sh_create_root_shell(shinstance inherit, int argc, char argv, char envp)
233	{
234	shinstance *psh;
235	int i;
236
237	/*
238	* The allocations.
239	*/
240	psh = sh_calloc(NULL, sizeof(*psh), 1);
241	if (psh)
242	{
243	/* Init it enought for sh_destroy() to not get upset */
244	/* ... */
245
246	/* Call the basic initializers. */
247	if ( !sh_clone_string_vector(psh, &psh->shenviron, envp)
248	&& !sh_clone_string_vector(psh, &psh->argptr, argv)
249	&& !shfile_init(&psh->fdtab, inherit ? &inherit->fdtab : NULL))
250	{
251	/* the special stuff. */
252	#ifdef _MSC_VER
253	psh->pid = _getpid();
254	#else
255	psh->pid = getpid();
256	#endif
257	/sh_sigemptyset(&psh->sigrestartset);/
258	for (i = 0; i < NSIG; i++)
259	psh->sigactions[i].sh_handler = SH_SIG_UNK;
260	if (inherit)
261	psh->sigmask = psh->sigmask;
262	else
263	{
264	#if defined(_MSC_VER)
265	sh_sigemptyset(&psh->sigmask);
266	#else
267	sigprocmask(SIG_SETMASK, NULL, &psh->sigmask);
268	#endif
269	}
270
271	/* memalloc.c */
272	psh->stacknleft = MINSIZE;
273	psh->herefd = -1;
274	psh->stackp = &psh->stackbase;
275	psh->stacknxt = psh->stackbase.space;
276
277	/* input.c */
278	psh->plinno = 1;
279	psh->init_editline = 0;
280	psh->parsefile = &psh->basepf;
281
282	/* output.c */
283	psh->output.bufsize = OUTBUFSIZ;
284	psh->output.fd = 1;
285	psh->output.psh = psh;
286	psh->errout.bufsize = 100;
287	psh->errout.fd = 2;
288	psh->errout.psh = psh;
289	psh->memout.fd = MEM_OUT;
290	psh->memout.psh = psh;
291	psh->out1 = &psh->output;
292	psh->out2 = &psh->errout;
293
294	/* jobs.c */
295	psh->backgndpid = -1;
296	#if JOBS
297	psh->curjob = -1;
298	#else
299	# error asdf
300	#endif
301	psh->ttyfd = -1;
302
303	/* show.c */
304	psh->tracefd = -1;
305
306	/* link it. */
307	sh_int_link(psh);
308	return psh;
309	}
310
311	sh_destroy(psh);
312	}
313	return NULL;
314	}
315
316	/** getenv() */
317	char sh_getenv(shinstance psh, const char *var)
318	{
319	size_t len;
320	int i = 0;
321
322	if (!var)
323	return NULL;
324
325	len = strlen(var);
326	i = 0;
327	while (psh->shenviron[i])
328	{
329	const char *item = psh->shenviron[i];
330	if ( !strncmp(item, var, len)
331	&& item[len] == '=')
332	return (char *)item + len + 1;
333	}
334
335	return NULL;
336	}
337
338	char *sh_environ(shinstance psh)
339	{
340	return psh->shenviron;
341	}
342
343	const char sh_gethomedir(shinstance psh, const char *user)
344	{
345	const char *ret = NULL;
346
347	#ifdef _MSC_VER
348	ret = sh_getenv(psh, "HOME");
349	if (!ret)
350	ret = sh_getenv(psh, "USERPROFILE");
351	#else
352	struct passwd pwd = getpwnam(user); /* @todo use getpwdnam_r */
353	(void)psh;
354	ret = pwd ? pwd->pw_dir : NULL;
355	#endif
356
357	return ret;
358	}
359
360	/**
361	* Lazy initialization of a signal state, globally.
362	*
363	* @param psh The shell doing the lazy work.
364	* @param signo The signal (valid).
365	*/
366	static void sh_int_lazy_init_sigaction(shinstance *psh, int signo)
367	{
368	if (psh->sigactions[signo].sh_handler == SH_SIG_UNK)
369	{
370	shmtxtmp tmp;
371	shmtx_enter(&g_sh_mtx, &tmp);
372
373	if (psh->sigactions[signo].sh_handler == SH_SIG_UNK)
374	{
375	shsigaction_t shold;
376	shinstance *cur;
377	#ifndef _MSC_VER
378	struct sigaction old;
379	if (!sigaction(signo, NULL, &old))
380	{
381	/* convert */
382	shold.sh_flags = old.sa_flags;
383	shold.sh_mask = old.sa_mask;
384	if (old.sa_handler == SIG_DFL)
385	shold.sh_handler = SH_SIG_DFL;
386	else
387	{
388	assert(old.sa_handler == SIG_IGN);
389	shold.sh_handler = SH_SIG_IGN;
390	}
391	}
392	else
393	#endif
394	{
395	/* fake */
396	#ifndef _MSC_VER
397	assert(0);
398	old.sa_handler = SIG_DFL;
399	old.sa_flags = 0;
400	sigemptyset(&shold.sh_mask);
401	sigaddset(&shold.sh_mask, signo);
402	#endif
403	shold.sh_flags = 0;
404	sh_sigemptyset(&shold.sh_mask);
405	sh_sigaddset(&shold.sh_mask, signo);
406	shold.sh_handler = SH_SIG_DFL;
407	}
408
409	/* update globals */
410	#ifndef _MSC_VER
411	g_sig_state[signo].sa = old;
412	#else
413	g_sig_state[signo].sa.sa_handler = SIG_DFL;
414	g_sig_state[signo].sa.sa_flags = 0;
415	g_sig_state[signo].sa.sa_mask = shold.sh_mask;
416	#endif
417	TRACE2((psh, "sh_int_lazy_init_sigaction: signo=%d:%s sa_handler=%p sa_flags=%#x\n",
418	signo, sys_signame[signo], g_sig_state[signo].sa.sa_handler, g_sig_state[signo].sa.sa_flags));
419
420	/* update all shells */
421	for (cur = g_sh_head; cur; cur = cur->next)
422	{
423	assert(cur->sigactions[signo].sh_handler == SH_SIG_UNK);
424	cur->sigactions[signo] = shold;
425	}
426	}
427
428	shmtx_leave(&g_sh_mtx, &tmp);
429	}
430	}
431
432	/**
433	* Perform the default signal action on the shell.
434	*
435	* @param psh The shell instance.
436	* @param signo The signal.
437	*/
438	static void sh_sig_do_default(shinstance *psh, int signo)
439	{
440	/** @todo */
441	}
442
443	/**
444	* Deliver a signal to a shell.
445	*
446	* @param psh The shell instance.
447	* @param pshDst The shell instance to signal.
448	* @param signo The signal.
449	* @param locked Whether we're owning the lock or not.
450	*/
451	static void sh_sig_do_signal(shinstance psh, shinstance pshDst, int signo, int locked)
452	{
453	shsig_t pfn = pshDst->sigactions[signo].sh_handler;
454	if (pfn == SH_SIG_UNK)
455	{
456	sh_int_lazy_init_sigaction(pshDst, signo);
457	pfn = pshDst->sigactions[signo].sh_handler;
458	}
459
460	if (pfn == SH_SIG_DFL)
461	sh_sig_do_default(pshDst, signo);
462	else if (pfn == SH_SIG_IGN)
463	/* ignore it */;
464	else
465	{
466	assert(pfn != SH_SIG_ERR);
467	pfn(pshDst, signo);
468	}
469	(void)locked;
470	}
471
472	/**
473	* Handler for external signals.
474	*
475	* @param signo The signal.
476	*/
477	static void sh_sig_common_handler(int signo)
478	{
479	shinstance *psh;
480
481	/* fprintf(stderr, "sh_sig_common_handler: signo=%d:%s\n", signo, sys_signame[signo]); */
482
483	/*
484	* No need to take locks if there is only one shell.
485	* Since this will be the initial case, just avoid the deadlock
486	* hell for a litte while...
487	*/
488	if (g_num_shells <= 1)
489	{
490	psh = g_sh_head;
491	if (psh)
492	sh_sig_do_signal(NULL, psh, signo, 0 /* no lock */);
493	}
494	else
495	{
496	shmtxtmp tmp;
497	shmtx_enter(&g_sh_mtx, &tmp);
498
499	/** @todo signal focus chain or something? Atm there will only be one shell,
500	* so it's not really important until we go threaded for real... */
501	psh = g_sh_tail;
502	while (psh != NULL)
503	{
504	sh_sig_do_signal(NULL, psh, signo, 1 /* locked */);
505	psh = psh->prev;
506	}
507
508	shmtx_leave(&g_sh_mtx, &tmp);
509	}
510	}
511
512	int sh_sigaction(shinstance psh, int signo, const struct shsigaction newp, struct shsigaction *oldp)
513	{
514	if (newp)
515	TRACE2((psh, "sh_sigaction: signo=%d:%s newp=%p:{.sh_handler=%p, .sh_flags=%#x} oldp=%p\n",
516	signo, sys_signame[signo], newp, newp->sh_handler, newp->sh_flags, oldp));
517	else
518	TRACE2((psh, "sh_sigaction: signo=%d:%s newp=NULL oldp=%p\n", signo, sys_signame[signo], oldp));
519
520	/*
521	* Input validation.
522	*/
523	if (signo >= NSIG \|\| signo <= 0)
524	{
525	errno = EINVAL;
526	return -1;
527	}
528
529	/*
530	* Make sure our data is correct.
531	*/
532	sh_int_lazy_init_sigaction(psh, signo);
533
534	/*
535	* Get the old one if requested.
536	*/
537	if (oldp)
538	*oldp = psh->sigactions[signo];
539
540	/*
541	* Set the new one if it has changed.
542	*
543	* This will be attempted coordinated with the other signal handlers so
544	* that we can arrive at a common denominator.
545	*/
546	if ( newp
547	&& memcmp(&psh->sigactions[signo], newp, sizeof(*newp)))
548	{
549	shmtxtmp tmp;
550	shmtx_enter(&g_sh_mtx, &tmp);
551
552	/* Undo the accounting for the current entry. */
553	if (psh->sigactions[signo].sh_handler == SH_SIG_IGN)
554	g_sig_state[signo].num_ignore--;
555	else if (psh->sigactions[signo].sh_handler != SH_SIG_DFL)
556	g_sig_state[signo].num_specific--;
557	if (psh->sigactions[signo].sh_flags & SA_RESTART)
558	g_sig_state[signo].num_restart--;
559
560	/* Set the new entry. */
561	psh->sigactions[signo] = *newp;
562
563	/* Add the bits for the new action entry. */
564	if (psh->sigactions[signo].sh_handler == SH_SIG_IGN)
565	g_sig_state[signo].num_ignore++;
566	else if (psh->sigactions[signo].sh_handler != SH_SIG_DFL)
567	g_sig_state[signo].num_specific++;
568	if (psh->sigactions[signo].sh_flags & SA_RESTART)
569	g_sig_state[signo].num_restart++;
570
571	/*
572	* Calc new common action.
573	*
574	* This is quit a bit ASSUMPTIVE about the limited use. We will not
575	* bother synching the mask, and we pretend to care about SA_RESTART.
576	* The only thing we really actually care about is the sh_handler.
577	*
578	* On second though, it's possible we should just tie this to the root
579	* shell since it only really applies to external signal ...
580	*/
581	if ( g_sig_state[signo].num_specific
582	\|\| g_sig_state[signo].num_ignore != g_num_shells)
583	g_sig_state[signo].sa.sa_handler = sh_sig_common_handler;
584	else if (g_sig_state[signo].num_ignore)
585	g_sig_state[signo].sa.sa_handler = SIG_IGN;
586	else
587	g_sig_state[signo].sa.sa_handler = SIG_DFL;
588	g_sig_state[signo].sa.sa_flags = psh->sigactions[signo].sh_flags & SA_RESTART;
589
590	TRACE2((psh, "sh_sigaction: setting signo=%d:%s to {.sa_handler=%p, .sa_flags=%#x}\n",
591	signo, sys_signame[signo], g_sig_state[signo].sa.sa_handler, g_sig_state[signo].sa.sa_flags));
592	#ifdef _MSC_VER
593	if (signal(signo, g_sig_state[signo].sa.sa_handler) == SIG_ERR)
594	{
595	TRACE2((psh, "sh_sigaction: SIG_ERR, errno=%d signo=%d\n", errno, signo));
596	if ( signo != SIGHUP /* whatever */
597	&& signo != SIGQUIT
598	&& signo != SIGPIPE
599	&& signo != SIGTTIN
600	&& signo != SIGTSTP
601	&& signo != SIGTTOU
602	&& signo != SIGCONT)
603	assert(0);
604	}
605	#else
606	if (sigaction(signo, &g_sig_state[signo].sa, NULL))
607	assert(0);
608	#endif
609
610	shmtx_leave(&g_sh_mtx, &tmp);
611	}
612
613	return 0;
614	}
615
616	shsig_t sh_signal(shinstance *psh, int signo, shsig_t handler)
617	{
618	shsigaction_t sa;
619	shsig_t ret;
620
621	/*
622	* Implementation using sh_sigaction.
623	*/
624	if (sh_sigaction(psh, signo, NULL, &sa))
625	return SH_SIG_ERR;
626
627	ret = sa.sh_handler;
628	sa.sh_flags &= SA_RESTART;
629	sa.sh_handler = handler;
630	sh_sigemptyset(&sa.sh_mask);
631	sh_sigaddset(&sa.sh_mask, signo); /* ?? */
632	if (sh_sigaction(psh, signo, &sa, NULL))
633	return SH_SIG_ERR;
634
635	return ret;
636	}
637
638	int sh_siginterrupt(shinstance *psh, int signo, int interrupt)
639	{
640	shsigaction_t sa;
641	int oldflags = 0;
642
643	/*
644	* Implementation using sh_sigaction.
645	*/
646	if (sh_sigaction(psh, signo, NULL, &sa))
647	return -1;
648	oldflags = sa.sh_flags;
649	if (interrupt)
650	sa.sh_flags &= ~SA_RESTART;
651	else
652	sa.sh_flags \|= ~SA_RESTART;
653	if (!((oldflags ^ sa.sh_flags) & SA_RESTART))
654	return 0; /* unchanged. */
655
656	return sh_sigaction(psh, signo, &sa, NULL);
657	}
658
659	void sh_sigemptyset(shsigset_t *setp)
660	{
661	memset(setp, 0, sizeof(*setp));
662	}
663
664	void sh_sigfillset(shsigset_t *setp)
665	{
666	memset(setp, 0xff, sizeof(*setp));
667	}
668
669	void sh_sigaddset(shsigset_t *setp, int signo)
670	{
671	#ifdef _MSC_VER
672	*setp \|= 1U << signo;
673	#else
674	sigaddset(setp, signo);
675	#endif
676	}
677
678	void sh_sigdelset(shsigset_t *setp, int signo)
679	{
680	#ifdef _MSC_VER
681	*setp &= ~(1U << signo);
682	#else
683	sigdelset(setp, signo);
684	#endif
685	}
686
687	int sh_sigismember(shsigset_t const *setp, int signo)
688	{
689	#ifdef _MSC_VER
690	return !!(*setp & (1U << signo));
691	#else
692	return !!sigismember(setp, signo);
693	#endif
694	}
695
696	int sh_sigprocmask(shinstance psh, int operation, shsigset_t const newp, shsigset_t *oldp)
697	{
698	int rc;
699
700	if ( operation != SIG_BLOCK
701	&& operation != SIG_UNBLOCK
702	&& operation != SIG_SETMASK)
703	{
704	errno = EINVAL;
705	return -1;
706	}
707
708	#if defined(SH_FORKED_MODE) && !defined(_MSC_VER)
709	rc = sigprocmask(operation, newp, oldp);
710	if (!rc && newp)
711	psh->sigmask = *newp;
712
713	#else
714	if (oldp)
715	*oldp = psh->sigmask;
716	if (newp)
717	{
718	/* calc the new mask */
719	shsigset_t mask = psh->sigmask;
720	switch (operation)
721	{
722	case SIG_BLOCK:
723	for (rc = 0; rc < NSIG; rc++)
724	if (sh_sigismember(newp, rc))
725	sh_sigaddset(&mask, rc);
726	break;
727	case SIG_UNBLOCK:
728	for (rc = 0; rc < NSIG; rc++)
729	if (sh_sigismember(newp, rc))
730	sh_sigdelset(&mask, rc);
731	break;
732	case SIG_SETMASK:
733	mask = *newp;
734	break;
735	}
736
737	# if defined(_MSC_VER)
738	rc = 0;
739	# else
740	rc = sigprocmask(operation, &mask, NULL);
741	if (!rc)
742	# endif
743	psh->sigmask = mask;
744	}
745
746	#endif
747	return rc;
748	}
749
750	SH_NORETURN_1 void sh_abort(shinstance *psh)
751	{
752	shsigset_t set;
753	TRACE2((psh, "sh_abort\n"));
754
755	/* block other async signals */
756	sh_sigfillset(&set);
757	sh_sigdelset(&set, SIGABRT);
758	sh_sigprocmask(psh, SIG_SETMASK, &set, NULL);
759
760	sh_sig_do_signal(psh, psh, SIGABRT, 0 /* no lock */);
761
762	/** @todo die in a nicer manner. */
763	(char )1 = 3;
764
765	TRACE2((psh, "sh_abort returns!\n"));
766	(void)psh;
767	abort();
768	}
769
770	void sh_raise_sigint(shinstance *psh)
771	{
772	TRACE2((psh, "sh_raise(SIGINT)\n"));
773
774	sh_sig_do_signal(psh, psh, SIGINT, 0 /* no lock */);
775
776	TRACE2((psh, "sh_raise(SIGINT) returns\n"));
777	}
778
779	int sh_kill(shinstance *psh, pid_t pid, int signo)
780	{
781	shinstance *pshDst;
782	shmtxtmp tmp;
783	int rc;
784
785	/*
786	* Self or any of the subshells?
787	*/
788	shmtx_enter(&g_sh_mtx, &tmp);
789
790	pshDst = g_sh_tail;
791	while (pshDst != NULL)
792	{
793	if (pshDst->pid == pid)
794	{
795	TRACE2((psh, "sh_kill(%d, %d): pshDst=%p\n", pid, signo, pshDst));
796	sh_sig_do_signal(psh, pshDst, signo, 1 /* locked */);
797
798	shmtx_leave(&g_sh_mtx, &tmp);
799	return 0;
800	}
801	pshDst = pshDst->prev;
802	}
803
804	shmtx_leave(&g_sh_mtx, &tmp);
805
806	/*
807	* Some other process, call kill where possible
808	*/
809	#if defined(SH_FORKED_MODE)
810	# ifdef _MSC_VER
811	errno = ENOSYS;
812	rc = -1;
813	# else
814	/* fprintf(stderr, "kill(%d, %d)\n", pid, signo);*/
815	rc = kill(pid, signo);
816	# endif
817
818	#else
819	#endif
820
821	TRACE2((psh, "sh_kill(%d, %d) -> %d [%d]\n", pid, signo, rc, errno));
822	return rc;
823	}
824
825	int sh_killpg(shinstance *psh, pid_t pgid, int signo)
826	{
827	int rc;
828
829	#if defined(SH_FORKED_MODE)
830	# ifdef _MSC_VER
831	errno = ENOSYS;
832	rc = -1;
833	# else
834	//fprintf(stderr, "killpg(%d, %d)\n", pgid, signo);
835	rc = killpg(pgid, signo);
836	# endif
837
838	#else
839	#endif
840
841	TRACE2((psh, "sh_killpg(%d, %d) -> %d [%d]\n", pgid, signo, rc, errno));
842	(void)psh;
843	return rc;
844	}
845
846	clock_t sh_times(shinstance psh, shtms tmsp)
847	{
848	#if defined(SH_FORKED_MODE)
849	(void)psh;
850	# ifdef _MSC_VER
851	errno = ENOSYS;
852	return (clock_t)-1;
853	# else
854	return times(tmsp);
855	# endif
856
857	#else
858	#endif
859	}
860
861	int sh_sysconf_clk_tck(void)
862	{
863	#ifdef _MSC_VER
864	return CLK_TCK;
865	#else
866	return sysconf(_SC_CLK_TCK);
867	#endif
868	}
869
870	/**
871	* Adds a child to the shell
872	*
873	* @returns 0 on success, on failure -1 and errno set to ENOMEM.
874	*
875	* @param psh The shell instance.
876	* @param pid The child pid.
877	* @param hChild Windows child handle.
878	*/
879	int sh_add_child(shinstance psh, pid_t pid, void hChild)
880	{
881	/* get a free table entry. */
882	int i = psh->num_children++;
883	if (!(i % 32))
884	{
885	void ptr = sh_realloc(psh, psh->children, sizeof(psh->children) * (i + 32));
886	if (!ptr)
887	{
888	psh->num_children--;
889	errno = ENOMEM;
890	return -1;
891	}
892	psh->children = ptr;
893	}
894
895	/* add it */
896	psh->children[i].pid = pid;
897	#if K_OS == K_OS_WINDOWS
898	psh->children[i].hChild = hChild;
899	#endif
900	(void)hChild;
901	return 0;
902	}
903
904	pid_t sh_fork(shinstance *psh)
905	{
906	pid_t pid;
907	TRACE2((psh, "sh_fork\n"));
908
909	#if K_OS == K_OS_WINDOWS //&& defined(SH_FORKED_MODE)
910	pid = shfork_do(psh);
911
912	#elif defined(SH_FORKED_MODE)
913	# ifdef _MSC_VER
914	pid = -1;
915	errno = ENOSYS;
916	# else
917	pid = fork();
918	# endif
919
920	#else
921
922	#endif
923
924	/* child: update the pid and zap the children array */
925	if (!pid)
926	{
927	# ifdef _MSC_VER
928	psh->pid = _getpid();
929	# else
930	psh->pid = getpid();
931	# endif
932	psh->num_children = 0;
933	}
934
935	TRACE2((psh, "sh_fork -> %d [%d]\n", pid, errno));
936	(void)psh;
937	return pid;
938	}
939
940	/** waitpid() */
941	pid_t sh_waitpid(shinstance psh, pid_t pid, int statusp, int flags)
942	{
943	pid_t pidret;
944	#if K_OS == K_OS_WINDOWS //&& defined(SH_FORKED_MODE)
945	DWORD dwRet;
946	HANDLE hChild = INVALID_HANDLE_VALUE;
947	int i;
948
949	*statusp = 0;
950	pidret = -1;
951	if (pid != -1)
952	{
953	/*
954	* A specific child, try look it up in the child process table
955	* and wait for it.
956	*/
957	for (i = 0; i < psh->num_children; i++)
958	if (psh->children[i].pid == pid)
959	break;
960	if (i < psh->num_children)
961	{
962	dwRet = WaitForSingleObject(psh->children[i].hChild,
963	flags & WNOHANG ? 0 : INFINITE);
964	if (dwRet == WAIT_OBJECT_0)
965	hChild = psh->children[i].hChild;
966	else if (dwRet == WAIT_TIMEOUT)
967	{
968	i = -1; /* don't try close anything */
969	pidret = 0;
970	}
971	else
972	errno = ECHILD;
973	}
974	else
975	errno = ECHILD;
976	}
977	else if (psh->num_children <= MAXIMUM_WAIT_OBJECTS)
978	{
979	HANDLE ahChildren[MAXIMUM_WAIT_OBJECTS];
980	for (i = 0; i < psh->num_children; i++)
981	ahChildren[i] = psh->children[i].hChild;
982	dwRet = WaitForMultipleObjects(psh->num_children, &ahChildren[0],
983	FALSE,
984	flags & WNOHANG ? 0 : INFINITE);
985	i = dwRet - WAIT_OBJECT_0;
986	if ((unsigned)i < (unsigned)psh->num_children)
987	{
988	hChild = psh->children[i].hChild;
989	}
990	else if (dwRet == WAIT_TIMEOUT)
991	{
992	i = -1; /* don't try close anything */
993	pidret = 0;
994	}
995	else
996	{
997	i = -1; /* don't try close anything */
998	errno = EINVAL;
999	}
1000	}
1001	else
1002	{
1003	fprintf(stderr, "panic! too many children!\n");
1004	i = -1;
1005	(char )1 = '\0'; /** @todo implement this! */
1006	}
1007
1008	/*
1009	* Close the handle, and if we succeeded collect the exit code first.
1010	*/
1011	if ( i >= 0
1012	&& i < psh->num_children)
1013	{
1014	if (hChild != INVALID_HANDLE_VALUE)
1015	{
1016	DWORD dwExitCode = 127;
1017	if (GetExitCodeProcess(hChild, &dwExitCode))
1018	{
1019	pidret = psh->children[i].pid;
1020	if (dwExitCode && !W_EXITCODE(dwExitCode, 0))
1021	dwExitCode \|= 16;
1022	*statusp = W_EXITCODE(dwExitCode, 0);
1023	}
1024	else
1025	errno = EINVAL;
1026	}
1027
1028	/* remove and close */
1029	hChild = psh->children[i].hChild;
1030	psh->num_children--;
1031	if (i < psh->num_children)
1032	psh->children[i] = psh->children[psh->num_children];
1033	i = CloseHandle(hChild); assert(i);
1034	}
1035
1036	#elif defined(SH_FORKED_MODE)
1037	*statusp = 0;
1038	# ifdef _MSC_VER
1039	pidret = -1;
1040	errno = ENOSYS;
1041	# else
1042	pidret = waitpid(pid, statusp, flags);
1043	# endif
1044
1045	#else
1046	#endif
1047
1048	TRACE2((psh, "waitpid(%d, %p, %#x) -> %d [%d] *statusp=%#x (rc=%d)\n", pid, statusp, flags,
1049	pidret, errno, statusp, WEXITSTATUS(statusp)));
1050	(void)psh;
1051	return pidret;
1052	}
1053
1054	SH_NORETURN_1 void sh__exit(shinstance *psh, int rc)
1055	{
1056	TRACE2((psh, "sh__exit(%d)\n", rc));
1057	(void)psh;
1058
1059	#if defined(SH_FORKED_MODE)
1060	_exit(rc);
1061
1062	#else
1063	#endif
1064	}
1065
1066	int sh_execve(shinstance psh, const char exe, const char * const argv, const char const *envp)
1067	{
1068	int rc;
1069
1070	#ifdef DEBUG
1071	/* log it all */
1072	TRACE2((psh, "sh_execve(%p:{%s}, %p, %p}\n", exe, exe, argv, envp));
1073	for (rc = 0; argv[rc]; rc++)
1074	TRACE2((psh, " argv[%d]=%p:{%s}\n", rc, argv[rc], argv[rc]));
1075	#endif
1076
1077	if (!envp)
1078	envp = (const char * const *)sh_environ(psh);
1079
1080	#if defined(SH_FORKED_MODE) && K_OS != K_OS_WINDOWS
1081	# ifdef _MSC_VER
1082	errno = 0;
1083	{
1084	intptr_t rc2 = _spawnve(_P_WAIT, exe, (char )argv, (char )envp);
1085	if (rc2 != -1)
1086	{
1087	TRACE2((psh, "sh_execve: child exited, rc=%d. (errno=%d)\n", rc, errno));
1088	rc = (int)rc2;
1089	if (!rc && rc2)
1090	rc = 16;
1091	exit(rc);
1092	}
1093	}
1094	rc = -1;
1095
1096	# else
1097	rc = shfile_exec_unix(&psh->fdtab);
1098	if (!rc)
1099	rc = execve(exe, (char )argv, (char )envp);
1100	# endif
1101
1102	#else
1103	# if K_OS == K_OS_WINDOWS
1104	{
1105	/*
1106	* This ain't quite straight forward on Windows...
1107	*/
1108	PROCESS_INFORMATION ProcInfo;
1109	STARTUPINFO StrtInfo;
1110	intptr_t hndls[3];
1111	char *cwd = shfile_getcwd(&psh->fdtab, NULL, 0);
1112	char *cmdline;
1113	size_t cmdline_size;
1114	char *envblock;
1115	size_t env_size;
1116	char *p;
1117	int i;
1118
1119	/* Create the environment block. */
1120	if (!envp)
1121	envp = sh_environ(psh);
1122	env_size = 2;
1123	for (i = 0; envp[i]; i++)
1124	env_size += strlen(envp[i]) + 1;
1125	envblock = p = sh_malloc(psh, env_size);
1126	for (i = 0; envp[i]; i++)
1127	{
1128	size_t len = strlen(envp[i]) + 1;
1129	memcpy(p, envp[i], len);
1130	p += len;
1131	}
1132	*p = '\0';
1133
1134	/* Figure the size of the command line. Double quotes makes this
1135	tedious and we overestimate to simplify. */
1136	cmdline_size = 2;
1137	for (i = 0; argv[i]; i++)
1138	{
1139	const char *arg = argv[i];
1140	cmdline_size += strlen(arg) + 3;
1141	arg = strchr(arg, '"');
1142	if (arg)
1143	{
1144	do
1145	cmdline_size++;
1146	while ((arg = strchr(arg + 1, '"')) != NULL);
1147	arg = argv[i] - 1;
1148	while ((arg = strchr(arg + 1, '\\')) != NULL);
1149	cmdline_size++;
1150	}
1151	}
1152
1153	/* Create the command line. */
1154	cmdline = p = sh_malloc(psh, cmdline_size);
1155	for (i = 0; argv[i]; i++)
1156	{
1157	const char *arg = argv[i];
1158	const char *cur = arg;
1159	size_t len = strlen(arg);
1160	int quoted = 0;
1161	char ch;
1162	while ((ch = *cur++) != '\0')
1163	if (ch <= 0x20 \|\| strchr("&><\|%", ch) != NULL)
1164	{
1165	quoted = 1;
1166	break;
1167	}
1168
1169	if (i != 0)
1170	*(p++) = ' ';
1171	if (quoted)
1172	*(p++) = '"';
1173	if (memchr(arg, '"', len) == NULL)
1174	{
1175	memcpy(p, arg, len);
1176	p += len;
1177	}
1178	else
1179	{ /* MS CRT style: double quotes must be escaped; backslashes
1180	must be escaped if followed by double quotes. */
1181	while ((ch = *arg++) != '\0')
1182	if (ch != '\\' && ch != '"')
1183	*p++ = ch;
1184	else if (ch == '"')
1185	{
1186	*p++ = '\\';
1187	*p++ = '"';
1188	}
1189	else
1190	{
1191	unsigned slashes = 1;
1192	*p++ = '\\';
1193	while (*arg == '\\')
1194	{
1195	*p++ = '\\';
1196	slashes++;
1197	arg++;
1198	}
1199	if (*arg == '"')
1200	{
1201	while (slashes-- > 0)
1202	*p++ = '\\';
1203	*p++ = '\\';
1204	*p++ = '"';
1205	arg++;
1206	}
1207	}
1208	}
1209	if (quoted)
1210	*(p++) = '"';
1211	}
1212	p[0] = p[1] = '\0';
1213
1214	/* Init the info structure */
1215	memset(&StrtInfo, '\0', sizeof(StrtInfo));
1216	StrtInfo.cb = sizeof(StrtInfo);
1217
1218	/* File handles. */
1219	StrtInfo.dwFlags \|= STARTF_USESTDHANDLES;
1220	StrtInfo.lpReserved2 = shfile_exec_win(&psh->fdtab, 1 /* prepare */, &StrtInfo.cbReserved2, hndls);
1221	StrtInfo.hStdInput = (HANDLE)hndls[0];
1222	StrtInfo.hStdOutput = (HANDLE)hndls[1];
1223	StrtInfo.hStdError = (HANDLE)hndls[2];
1224
1225	/* Get going... */
1226	if (CreateProcess(exe,
1227	cmdline,
1228	NULL, /* pProcessAttributes */
1229	NULL, /* pThreadAttributes */
1230	TRUE, /* bInheritHandles */
1231	0, /* dwCreationFlags */
1232	envblock,
1233	cwd,
1234	&StrtInfo,
1235	&ProcInfo))
1236	{
1237	DWORD dwErr;
1238	DWORD dwExitCode;
1239
1240	CloseHandle(ProcInfo.hThread);
1241	dwErr = WaitForSingleObject(ProcInfo.hProcess, INFINITE);
1242	assert(dwErr == WAIT_OBJECT_0);
1243
1244	if (GetExitCodeProcess(ProcInfo.hProcess, &dwExitCode))
1245	{
1246	CloseHandle(ProcInfo.hProcess);
1247	_exit(dwExitCode);
1248	}
1249	errno = EINVAL;
1250	}
1251	else
1252	{
1253	DWORD dwErr = GetLastError();
1254	switch (dwErr)
1255	{
1256	case ERROR_FILE_NOT_FOUND: errno = ENOENT; break;
1257	case ERROR_PATH_NOT_FOUND: errno = ENOENT; break;
1258	case ERROR_BAD_EXE_FORMAT: errno = ENOEXEC; break;
1259	case ERROR_INVALID_EXE_SIGNATURE: errno = ENOEXEC; break;
1260	default:
1261	errno = EINVAL;
1262	break;
1263	}
1264	TRACE2((psh, "sh_execve: dwErr=%d -> errno=%d\n", dwErr, errno));
1265	}
1266
1267	shfile_exec_win(&psh->fdtab, 0 /* done */, NULL, NULL);
1268	}
1269	rc = -1;
1270
1271	# else
1272	errno = ENOSYS;
1273	rc = -1;
1274	# endif
1275	#endif
1276
1277	TRACE2((psh, "sh_execve -> %d [%d]\n", rc, errno));
1278	(void)psh;
1279	return (int)rc;
1280	}
1281
1282	uid_t sh_getuid(shinstance *psh)
1283	{
1284	#if defined(SH_FORKED_MODE)
1285	# ifdef _MSC_VER
1286	uid_t uid = 0;
1287	# else
1288	uid_t uid = getuid();
1289	# endif
1290
1291	#else
1292	#endif
1293
1294	TRACE2((psh, "sh_getuid() -> %d [%d]\n", uid, errno));
1295	(void)psh;
1296	return uid;
1297	}
1298
1299	uid_t sh_geteuid(shinstance *psh)
1300	{
1301	#if defined(SH_FORKED_MODE)
1302	# ifdef _MSC_VER
1303	uid_t euid = 0;
1304	# else
1305	uid_t euid = geteuid();
1306	# endif
1307
1308	#else
1309	#endif
1310
1311	TRACE2((psh, "sh_geteuid() -> %d [%d]\n", euid, errno));
1312	(void)psh;
1313	return euid;
1314	}
1315
1316	gid_t sh_getgid(shinstance *psh)
1317	{
1318	#if defined(SH_FORKED_MODE)
1319	# ifdef _MSC_VER
1320	gid_t gid = 0;
1321	# else
1322	gid_t gid = getgid();
1323	# endif
1324
1325	#else
1326	#endif
1327
1328	TRACE2((psh, "sh_getgid() -> %d [%d]\n", gid, errno));
1329	(void)psh;
1330	return gid;
1331	}
1332
1333	gid_t sh_getegid(shinstance *psh)
1334	{
1335	#if defined(SH_FORKED_MODE)
1336	# ifdef _MSC_VER
1337	gid_t egid = 0;
1338	# else
1339	gid_t egid = getegid();
1340	# endif
1341
1342	#else
1343	#endif
1344
1345	TRACE2((psh, "sh_getegid() -> %d [%d]\n", egid, errno));
1346	(void)psh;
1347	return egid;
1348	}
1349
1350	pid_t sh_getpid(shinstance *psh)
1351	{
1352	pid_t pid;
1353
1354	#if defined(SH_FORKED_MODE)
1355	# ifdef _MSC_VER
1356	pid = _getpid();
1357	# else
1358	pid = getpid();
1359	# endif
1360	#else
1361	#endif
1362
1363	(void)psh;
1364	return pid;
1365	}
1366
1367	pid_t sh_getpgrp(shinstance *psh)
1368	{
1369	#if defined(SH_FORKED_MODE)
1370	# ifdef _MSC_VER
1371	pid_t pgrp = _getpid();
1372	# else
1373	pid_t pgrp = getpgrp();
1374	# endif
1375
1376	#else
1377	#endif
1378
1379	TRACE2((psh, "sh_getpgrp() -> %d [%d]\n", pgrp, errno));
1380	(void)psh;
1381	return pgrp;
1382	}
1383
1384	pid_t sh_getpgid(shinstance *psh, pid_t pid)
1385	{
1386	#if defined(SH_FORKED_MODE)
1387	# ifdef _MSC_VER
1388	pid_t pgid = pid;
1389	# else
1390	pid_t pgid = getpgid(pid);
1391	# endif
1392
1393	#else
1394	#endif
1395
1396	TRACE2((psh, "sh_getpgid(%d) -> %d [%d]\n", pid, pgid, errno));
1397	(void)psh;
1398	return pgid;
1399	}
1400
1401	int sh_setpgid(shinstance *psh, pid_t pid, pid_t pgid)
1402	{
1403	#if defined(SH_FORKED_MODE)
1404	# ifdef _MSC_VER
1405	int rc = -1;
1406	errno = ENOSYS;
1407	# else
1408	int rc = setpgid(pid, pgid);
1409	# endif
1410
1411	#else
1412	#endif
1413
1414	TRACE2((psh, "sh_setpgid(%d, %d) -> %d [%d]\n", pid, pgid, rc, errno));
1415	(void)psh;
1416	return rc;
1417	}
1418
1419	pid_t sh_tcgetpgrp(shinstance *psh, int fd)
1420	{
1421	pid_t pgrp;
1422
1423	#if defined(SH_FORKED_MODE)
1424	# ifdef _MSC_VER
1425	pgrp = -1;
1426	errno = ENOSYS;
1427	# else
1428	pgrp = tcgetpgrp(fd);
1429	# endif
1430
1431	#else
1432	#endif
1433
1434	TRACE2((psh, "sh_tcgetpgrp(%d) -> %d [%d]\n", fd, pgrp, errno));
1435	(void)psh;
1436	return pgrp;
1437	}
1438
1439	int sh_tcsetpgrp(shinstance *psh, int fd, pid_t pgrp)
1440	{
1441	int rc;
1442	TRACE2((psh, "sh_tcsetpgrp(%d, %d)\n", fd, pgrp));
1443
1444	#if defined(SH_FORKED_MODE)
1445	# ifdef _MSC_VER
1446	rc = -1;
1447	errno = ENOSYS;
1448	# else
1449	rc = tcsetpgrp(fd, pgrp);
1450	# endif
1451
1452	#else
1453	#endif
1454
1455	TRACE2((psh, "sh_tcsetpgrp(%d, %d) -> %d [%d]\n", fd, pgrp, rc, errno));
1456	(void)psh;
1457	return rc;
1458	}
1459
1460	int sh_getrlimit(shinstance psh, int resid, shrlimit limp)
1461	{
1462	#if defined(SH_FORKED_MODE)
1463	# ifdef _MSC_VER
1464	int rc = -1;
1465	errno = ENOSYS;
1466	# else
1467	int rc = getrlimit(resid, limp);
1468	# endif
1469
1470	#else
1471	/* returned the stored limit */
1472	#endif
1473
1474	TRACE2((psh, "sh_getrlimit(%d, %p) -> %d [%d] {%ld,%ld}\n",
1475	resid, limp, rc, errno, (long)limp->rlim_cur, (long)limp->rlim_max));
1476	(void)psh;
1477	return rc;
1478	}
1479
1480	int sh_setrlimit(shinstance psh, int resid, const shrlimit limp)
1481	{
1482	#if defined(SH_FORKED_MODE)
1483	# ifdef _MSC_VER
1484	int rc = -1;
1485	errno = ENOSYS;
1486	# else
1487	int rc = setrlimit(resid, limp);
1488	# endif
1489
1490	#else
1491	/* if max(shell) < limp; then setrlimit; fi
1492	if success; then store limit for later retrival and maxing. */
1493
1494	#endif
1495
1496	TRACE2((psh, "sh_setrlimit(%d, %p:{%ld,%ld}) -> %d [%d]\n",
1497	resid, limp, (long)limp->rlim_cur, (long)limp->rlim_max, rc, errno));
1498	(void)psh;
1499	return rc;
1500	}
1501
1502
1503	/* Wrapper for strerror that makes sure it doesn't return NULL and causes the
1504	caller or fprintf routines to crash. */
1505	const char sh_strerror(shinstance psh, int error)
1506	{
1507	char *err = strerror(error);
1508	if (!err)
1509	return "strerror return NULL!";
1510	(void)psh;
1511	return err;
1512	}
1513

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

source: kBuild/trunk/src/kash/shinstance.c@ 3409

Download in other formats: