VirtualBox

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

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

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette