source: trunk/src/kash/shinstance.c@ 2294

Last change on this file since 2294 was 2294, checked in by bird, 16 years ago

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