VirtualBox

Changeset 2286 in kBuild


Ignore:
Timestamp:
Feb 25, 2009 5:25:38 AM (16 years ago)
Author:
bird
Message:

kash: more hacking.

Location:
trunk/src/kash
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kash/main.c

    r1233 r2286  
    8484STATIC void read_profile(struct shinstance *, const char *);
    8585STATIC char *find_dot_file(struct shinstance *, char *);
    86 int main(int, char **);
     86int main(int, char **, char **);
    8787int shell_main(shinstance *, int, char **);
    8888#ifdef _MSC_VER
    … …  
    101101
    102102int
    103 main(int argc, char **argv)
     103main(int argc, char **argv, char **envp)
    104104{
    105105        shinstance *psh;
    … …  
    126126         * Create the root shell instance.
    127127         */
    128         psh = sh_create_root_shell(NULL, argc, argv);
     128        psh = sh_create_root_shell(NULL, argc, argv, envp);
    129129        if (!psh)
    130130                return 2;

  • trunk/src/kash/shinstance.c

    r2282 r2286  
    3131#include <stdlib.h>
    3232#include <assert.h>
    33 #ifndef _MSC_VER
     33#ifdef _MSC_VER
     34# include <process.h>
     35#else
    3436# include <unistd.h>
    3537# include <pwd.h>
    36 extern char **environ;
    3738#endif
    3839#include "shinstance.h"
    … …  
    5152static shinstance  *g_sh_tail;
    5253/** The number of shells. */
    53 static int         g_num_shells;
     54static int volatile g_num_shells;
    5455/** Per signal state for determining a common denominator.
    5556 * @remarks defaults and unmasked actions aren't counted. */
    … …  
    104105}
    105106
    106 
    107107/**
    108108 * Links the shell instance.
    … …  
    131131}
    132132
    133 
     133#if 0
    134134/**
    135135 * Unlink the shell instance.
    … …  
    159159    shmtx_leave(&g_sh_mtx, &tmp);
    160160}
    161 
     161#endif
     162
     163/**
     164 * Clones an environment vector.
     165 *
     166 * @returns 0 on success, -1 and errno on failure.
     167 * @param   dstp    Where to store the clone.
     168 * @param   src     The vector to be cloned.
     169 */
     170static int sh_env_clone(char ***dstp, char **src)
     171{
     172   char **dst;
     173   size_t items;
     174
     175   /* count first */
     176   items = 0;
     177   while (src[items])
     178       items++;
     179
     180   /* alloc clone array. */
     181   *dstp = dst = malloc(sizeof(*dst) * items + 1);
     182   if (!dst)
     183       return -1;
     184
     185   /* copy the items */
     186   dst[items] = NULL;
     187   while (items-- > 0)
     188   {
     189       dst[items] = strdup(src[items]);
     190       if (!dst[items])
     191       {
     192           /* allocation error, clean up. */
     193           while (dst[++items])
     194               free(dst[items]);
     195           free(dst);
     196           errno = ENOMEM;
     197           return -1;
     198       }
     199   }
     200
     201   return 0;
     202}
    162203
    163204/**
    … …  
    167208 * @param   argc        The argument count.
    168209 * @param   argv        The argument vector.
     210 * @param   envp        The environment vector.
    169211 *
    170212 * @returns pointer to root shell on success, NULL on failure.
    171213 */
    172 shinstance *sh_create_root_shell(shinstance *inherit, int argc, char **argv)
     214shinstance *sh_create_root_shell(shinstance *inherit, int argc, char **argv, char **envp)
    173215{
    174216    shinstance *psh;
    175217    int i;
    176218
     219    /*
     220     * The allocations.
     221     */
    177222    psh = calloc(sizeof(*psh), 1);
    178223    if (psh)
    179224    {
    180         /* the special stuff. */
     225        if (!sh_env_clone(&psh->shenviron, envp))
     226        {
     227            /* the special stuff. */
    181228#ifdef _MSC_VER
    182         psh->pid = _getpid();
    183 #else
    184         psh->pid = getpid();
    185 #endif
    186         /*sh_sigemptyset(&psh->sigrestartset);*/
    187         for (i = 0; i < NSIG; i++)
    188             psh->sigactions[i].sh_handler = SH_SIG_UNK;
    189 
    190         /* memalloc.c */
    191         psh->stacknleft = MINSIZE;
    192         psh->herefd = -1;
    193         psh->stackp = &psh->stackbase;
    194         psh->stacknxt = psh->stackbase.space;
    195 
    196         /* input.c */
    197         psh->plinno = 1;
    198         psh->init_editline = 0;
    199         psh->parsefile = &psh->basepf;
    200 
    201         /* output.c */
    202         psh->output.bufsize = OUTBUFSIZ;
    203         psh->output.fd = 1;
    204         psh->output.psh = psh;
    205         psh->errout.bufsize = 100;
    206         psh->errout.fd = 2;
    207         psh->errout.psh = psh;
    208         psh->memout.fd = MEM_OUT;
    209         psh->memout.psh = psh;
    210         psh->out1 = &psh->output;
    211         psh->out2 = &psh->errout;
    212 
    213         /* jobs.c */
    214         psh->backgndpid = -1;
     229            psh->pid = _getpid();
     230#else
     231            psh->pid = getpid();
     232#endif
     233            /*sh_sigemptyset(&psh->sigrestartset);*/
     234            for (i = 0; i < NSIG; i++)
     235                psh->sigactions[i].sh_handler = SH_SIG_UNK;
     236            if (inherit)
     237                psh->sigmask = psh->sigmask;
     238            else
     239            {
     240#if defined(SH_PURE_STUB_MODE) || defined(_MSC_VER)
     241                sh_sigemptyset(&psh->sigmask);
     242#else
     243                sigprocmask(SIG_SETMASK, NULL, &psh->sigmask);
     244#endif
     245            }
     246
     247            /* memalloc.c */
     248            psh->stacknleft = MINSIZE;
     249            psh->herefd = -1;
     250            psh->stackp = &psh->stackbase;
     251            psh->stacknxt = psh->stackbase.space;
     252
     253            /* input.c */
     254            psh->plinno = 1;
     255            psh->init_editline = 0;
     256            psh->parsefile = &psh->basepf;
     257
     258            /* output.c */
     259            psh->output.bufsize = OUTBUFSIZ;
     260            psh->output.fd = 1;
     261            psh->output.psh = psh;
     262            psh->errout.bufsize = 100;
     263            psh->errout.fd = 2;
     264            psh->errout.psh = psh;
     265            psh->memout.fd = MEM_OUT;
     266            psh->memout.psh = psh;
     267            psh->out1 = &psh->output;
     268            psh->out2 = &psh->errout;
     269
     270            /* jobs.c */
     271            psh->backgndpid = -1;
    215272#if JOBS
    216         psh->curjob = -1;
     273            psh->curjob = -1;
    217274#else
    218275# error asdf
    219276#endif
    220         psh->ttyfd = -1;
    221 
    222         /* link it. */
    223         sh_int_link(psh);
    224 
     277            psh->ttyfd = -1;
     278
     279            /* link it. */
     280            sh_int_link(psh);
     281            return psh;
     282        }
     283
     284        free(psh);
    225285    }
    226     return psh;
    227 }
    228 
     286    return NULL;
     287}
    229288
    230289char *sh_getenv(shinstance *psh, const char *var)
    231290{
    232 #ifdef SH_PURE_STUB_MODE
     291    size_t  len;
     292    int     i = 0;
     293
     294    if (!var)
     295        return NULL;
     296
     297    len = strlen(var);
     298    i = 0;
     299    while (psh->shenviron[i])
     300    {
     301        const char *item = psh->shenviron[i];
     302        if (    !strncmp(item, var, len)
     303            &&  item[len] == '=')
     304            return (char *)item + len + 1;
     305    }
     306
    233307    return NULL;
    234 #elif defined(SH_STUB_MODE)
    235     (void)psh;
    236     return getenv(var);
    237 #else
    238 #endif
    239308}
    240309
    241310char **sh_environ(shinstance *psh)
    242311{
    243 #ifdef SH_PURE_STUB_MODE
    244     static char *s_null[2] = {0,0};
    245     return &s_null[0];
    246 #elif defined(SH_STUB_MODE)
    247     (void)psh;
    248     return environ;
    249 #else
    250 #endif
     312    return psh->shenviron;
    251313}
    252314
    253315const char *sh_gethomedir(shinstance *psh, const char *user)
    254316{
    255 #ifdef SH_PURE_STUB_MODE
    256     return NULL;
    257 #elif defined(SH_STUB_MODE)
    258     (void)psh;
    259 # ifdef _MSC_VER
    260     return NULL;
    261 # else
    262     struct passwd *pwd = getpwnam(user);
    263     return pwd ? pwd->pw_dir : NULL;
    264 # endif
    265 #else
    266 #endif
     317    const char *ret = NULL;
     318
     319#ifdef _MSC_VER
     320    ret = sh_getenv(psh, "HOME");
     321    if (!ret)
     322        ret = sh_getenv(psh, "USERPROFILE");
     323#else
     324    struct passwd *pwd = getpwnam(user); /** @todo use getpwdnam_r */
     325    (void)psh;
     326    ret = pwd ? pwd->pw_dir : NULL;
     327#endif
     328
     329    return ret;
    267330}
    268331
    … …  
    339402}
    340403
     404/**
     405 * Perform the default signal action on the shell.
     406 *
     407 * @param   psh         The shell instance.
     408 * @param   signo       The signal.
     409 */
     410static void sh_sig_do_default(shinstance *psh, int signo)
     411{
     412    /** @todo */
     413}
     414
     415/**
     416 * Deliver a signal to a shell.
     417 *
     418 * @param   psh         The shell instance.
     419 * @param   pshDst      The shell instance to signal.
     420 * @param   signo       The signal.
     421 * @param   locked      Whether we're owning the lock or not.
     422 */
     423static void sh_sig_do_signal(shinstance *psh, shinstance *pshDst, int signo, int locked)
     424{
     425    shsig_t pfn = pshDst->sigactions[signo].sh_handler;
     426    if (pfn == SH_SIG_UNK)
     427    {
     428        sh_int_lazy_init_sigaction(pshDst, signo);
     429        pfn = pshDst->sigactions[signo].sh_handler;
     430    }
     431
     432    if (pfn == SH_SIG_DFL)
     433        sh_sig_do_default(pshDst, signo);
     434    else if (pfn == SH_SIG_IGN)
     435        /* ignore it */;
     436    else
     437    {
     438        assert(pfn != SH_SIG_ERR);
     439        pfn(pshDst, signo);
     440    }
     441    (void)locked;
     442}
    341443
    342444/**
    … …  
    347449static void sh_sig_common_handler(int signo)
    348450{
    349     shmtxtmp tmp;
    350451    shinstance *psh;
    351452
    352453    fprintf(stderr, "sh_sig_common_handler: signo=%d:%s\n", signo, sys_signame[signo]);
    353     shmtx_enter(&g_sh_mtx, &tmp);
    354 
    355 /** @todo signal focus chain or something? Atm there will only be one shell,
    356  *        so it's not really important until we go threaded for real... */
    357     psh = g_sh_tail;
    358     while (psh != NULL)
     454
     455    /*
     456     * No need to take locks if there is only one shell.
     457     * Since this will be the initial case, just avoid the deadlock
     458     * hell for a litte while...
     459     */
     460    if (g_num_shells <= 1)
    359461    {
    360         if (psh->sigactions[signo].sh_handler == SH_SIG_DFL)
    361             /* implement... */;
    362         else if (psh->sigactions[signo].sh_handler != SIG_IGN)
    363             psh->sigactions[signo].sh_handler(psh, signo);
    364 
    365         psh = psh->prev;
     462        psh = g_sh_head;
     463        if (psh)
     464            sh_sig_do_signal(NULL, psh, signo, 0 /* no lock */);
    366465    }
    367 
    368     shmtx_leave(&g_sh_mtx, &tmp);
    369 }
    370 
     466    else
     467    {
     468        shmtxtmp tmp;
     469        shmtx_enter(&g_sh_mtx, &tmp);
     470
     471        /** @todo signal focus chain or something? Atm there will only be one shell,
     472         *        so it's not really important until we go threaded for real... */
     473        psh = g_sh_tail;
     474        while (psh != NULL)
     475        {
     476            sh_sig_do_signal(NULL, psh, signo, 1 /* locked */);
     477            psh = psh->prev;
     478        }
     479
     480        shmtx_leave(&g_sh_mtx, &tmp);
     481    }
     482}
    371483
    372484int sh_sigaction(shinstance *psh, int signo, const struct shsigaction *newp, struct shsigaction *oldp)
    … …  
    516628}
    517629
     630void sh_sigfillset(shsigset_t *setp)
     631{
     632    memset(setp, 0xff, sizeof(*setp));
     633}
     634
    518635void sh_sigaddset(shsigset_t *setp, int signo)
    519636{
    … …  
    545662int sh_sigprocmask(shinstance *psh, int operation, shsigset_t const *newp, shsigset_t *oldp)
    546663{
    547 #ifdef SH_PURE_STUB_MODE
    548     return -1;
    549 #elif defined(SH_STUB_MODE)
    550     (void)psh;
    551 # ifdef _MSC_VER
    552     return -1;
    553 # else
    554     return sigprocmask(operation, newp, oldp);
    555 # endif
    556 #else
    557 #endif
     664    int rc;
     665
     666    if (    operation != SIG_BLOCK
     667        &&  operation != SIG_UNBLOCK
     668        &&  operation != SIG_SETMASK)
     669    {
     670        errno = EINVAL;
     671        return -1;
     672    }
     673
     674#if (defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)) && !defined(_MSC_VER)
     675    rc = sigprocmask(operation, newp, oldp);
     676    if (!rc && newp)
     677        psh->sigmask = *newp;
     678
     679#else
     680    if (oldp)
     681        *oldp = psh->sigmask;
     682    if (newp)
     683    {
     684        /* calc the new mask */
     685        shsigset_t mask = psh->sigmask;
     686        switch (operation)
     687        {
     688            case SIG_BLOCK:
     689                for (rc = 0; rc < NSIG; rc++)
     690                    if (sh_sigismember(newp, rc))
     691                        sh_sigaddset(&mask);
     692                break;
     693            case SIG_UNBLOCK:
     694                for (rc = 0; rc < NSIG; rc++)
     695                    if (sh_sigismember(newp, rc))
     696                        sh_sigdelset(&mask);
     697                break;
     698            case SIG_SETMASK:
     699                mask = *newp;
     700                break;
     701        }
     702
     703# if defined(SH_STUB_MODE) || defined(_MSC_VER)
     704        rc = 0;
     705# else
     706        rc = sigprocmask(operation, &mask, NULL);
     707        if (!rc)
     708# endif
     709            psh->sigmask = mask;
     710    }
     711
     712#endif
     713    return rc;
    558714}
    559715
    560716void sh_abort(shinstance *psh)
    561717{
     718    shsigset_t set;
    562719    TRACE2((psh, "sh_abort\n"));
    563720
    564 #ifdef SH_PURE_STUB_MODE
    565 #elif defined(SH_STUB_MODE)
     721    /* block other async signals */
     722    sh_sigfillset(&set);
     723    sh_sigdelset(&set, SIGABRT);
     724    sh_sigprocmask(psh, SIG_SETMASK, &set, NULL);
     725
     726    sh_sig_do_signal(psh, psh, SIGABRT, 0 /* no lock */);
     727
     728    /** @todo die in a nicer manner. */
     729    *(char *)1 = 3;
     730
     731    TRACE2((psh, "sh_abort returns!\n"));
     732    (void)psh;
    566733    abort();
    567 #else
    568 #endif
    569 
    570     TRACE2((psh, "sh_abort returns!\n"));
    571     (void)psh;
    572734}
    573735
    … …  
    576738    TRACE2((psh, "sh_raise(SIGINT)\n"));
    577739
    578 #ifdef SH_PURE_STUB_MODE
    579 #elif defined(SH_STUB_MODE)
    580     (void)psh;
    581     raise(SIGINT);
    582 #else
    583 #endif
     740    sh_sig_do_signal(psh, psh, SIGINT, 0 /* no lock */);
    584741
    585742    TRACE2((psh, "sh_raise(SIGINT) returns\n"));
    586     (void)psh;
    587743}
    588744
    589745int sh_kill(shinstance *psh, pid_t pid, int signo)
    590746{
     747    shinstance *pshDst;
     748    shmtxtmp tmp;
    591749    int rc;
    592750
     751    /*
     752     * Self or any of the subshells?
     753     */
     754    shmtx_enter(&g_sh_mtx, &tmp);
     755
     756    pshDst = g_sh_tail;
     757    while (pshDst != NULL)
     758    {
     759        if (pshDst->pid == pid)
     760        {
     761            TRACE2((psh, "sh_kill(%d, %d): pshDst=%p\n", pid, signo, pshDst));
     762            sh_sig_do_signal(psh, pshDst, signo, 1 /* locked */);
     763
     764            shmtx_leave(&g_sh_mtx, &tmp);
     765            return 0;
     766        }
     767        pshDst = pshDst->prev;
     768    }
     769
     770    shmtx_leave(&g_sh_mtx, &tmp);
     771
     772    /*
     773     * Some other process, call kill where possible
     774     */
    593775#ifdef SH_PURE_STUB_MODE
    594776    rc = -1;
    595 #elif defined(SH_STUB_MODE)
    596 # ifdef _MSC_VER
     777
     778#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)
     779# ifdef _MSC_VER
     780    errno = ENOSYS;
    597781    rc = -1;
    598782# else
    … …  
    600784    rc = kill(pid, signo);
    601785# endif
     786
    602787#else
    603788#endif
    604789
    605790    TRACE2((psh, "sh_kill(%d, %d) -> %d [%d]\n", pid, signo, rc, errno));
    606     (void)psh;
    607791    return rc;
    608792}
    … …  
    614798#ifdef SH_PURE_STUB_MODE
    615799    rc = -1;
     800
    616801#elif defined(SH_STUB_MODE)
    617802# ifdef _MSC_VER
     803    errno = ENOSYS;
    618804    rc = -1;
    619805# else
    … …  
    621807    rc = killpg(pgid, signo);
    622808# endif
     809
    623810#else
    624811#endif
    … …  
    633820#ifdef SH_PURE_STUB_MODE
    634821    return 0;
    635 #elif defined(SH_STUB_MODE)
    636     (void)psh;
    637 # ifdef _MSC_VER
    638     return 0;
     822
     823#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)
     824    (void)psh;
     825# ifdef _MSC_VER
     826    errno = ENOSYS;
     827    return (clock_t)-1;
    639828# else
    640829    return times(tmsp);
    641830# endif
     831
    642832#else
    643833#endif
    … …  
    664854#ifdef SH_PURE_STUB_MODE
    665855    pid = -1;
    666 #elif defined(SH_STUB_MODE)
    667 # ifdef _MSC_VER
     856
     857#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)
     858# ifdef _MSC_VER
     859#  ifdef SH_FORKED_MODE
     860    /** @todo */
     861    *(char *)1 = 0x1;
     862#  else
    668863    pid = -1;
     864    error = ENOSYS;
     865#  endif
    669866# else
    670867    pid = fork();
    671868# endif
    672 #else
     869
     870#else
     871
    673872#endif
    674873
    … …  
    685884#ifdef SH_PURE_STUB_MODE
    686885    pidret = -1;
    687 #elif defined(SH_STUB_MODE)
     886
     887#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)
    688888# ifdef _MSC_VER
    689889    pidret = -1;
     890    error = ENOSYS;
    690891# else
    691892    pidret = waitpid(pid, statusp, flags);
    692893# endif
     894
    693895#else
    694896#endif
    … …  
    707909#ifdef SH_PURE_STUB_MODE
    708910    return -1;
    709 #elif defined(SH_STUB_MODE)
     911
     912#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)
    710913    _exit(rc);
     914
    711915#else
    712916#endif
    … …  
    724928#endif
    725929
     930    if (!envp)
     931        envp = sh_environ(psh);
     932
    726933#ifdef SH_PURE_STUB_MODE
    727934    rc = -1;
    728 #elif defined(SH_STUB_MODE)
    729 # ifdef _MSC_VER
    730     rc = -1;
     935
     936#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)
     937# ifdef _MSC_VER
     938    rc = _spawnve(_P_WAIT, exe, (char **)argv, (char **)envp);
    731939# else
    732940    rc = execve(exe, (char **)argv, (char **)envp);
    733941# endif
     942
    734943#else
    735944#endif
    … …  
    744953#ifdef SH_PURE_STUB_MODE
    745954    uid_t uid = 0;
    746 #elif defined(SH_STUB_MODE)
     955
     956#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)
    747957# ifdef _MSC_VER
    748958    uid_t uid = 0;
    … …  
    750960    uid_t uid = getuid();
    751961# endif
     962
    752963#else
    753964#endif
    … …  
    762973#ifdef SH_PURE_STUB_MODE
    763974    uid_t euid = 0;
    764 #elif defined(SH_STUB_MODE)
     975
     976#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)
    765977# ifdef _MSC_VER
    766978    uid_t euid = 0;
    … …  
    768980    uid_t euid = geteuid();
    769981# endif
     982
    770983#else
    771984#endif
    … …  
    780993#ifdef SH_PURE_STUB_MODE
    781994    gid_t gid = 0;
    782 #elif defined(SH_STUB_MODE)
     995
     996#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)
    783997# ifdef _MSC_VER
    784998    gid_t gid = 0;
    … …  
    7861000    gid_t gid = getgid();
    7871001# endif
     1002
    7881003#else
    7891004#endif
    … …  
    7981013#ifdef SH_PURE_STUB_MODE
    7991014    gid_t egid = 0;
    800 #elif defined(SH_STUB_MODE)
     1015
     1016#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)
    8011017# ifdef _MSC_VER
    8021018    gid_t egid = 0;
    … …  
    8041020    gid_t egid = getegid();
    8051021# endif
     1022
    8061023#else
    8071024#endif
    … …  
    8181035#ifdef SH_PURE_STUB_MODE
    8191036    pid = 0;
    820 #elif defined(SH_STUB_MODE)
     1037
     1038#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)
    8211039# ifdef _MSC_VER
    8221040    pid = _getpid();
    … …  
    8351053#ifdef SH_PURE_STUB_MODE
    8361054    pid_t pgrp = 0;
    837 #elif defined(SH_STUB_MODE)
     1055
     1056#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)
    8381057# ifdef _MSC_VER
    8391058    pid_t pgrp _getpid();
    … …  
    8411060    pid_t pgrp = getpgrp();
    8421061# endif
     1062
    8431063#else
    8441064#endif
    … …  
    8531073#ifdef SH_PURE_STUB_MODE
    8541074    pid_t pgid = pid;
    855 #elif defined(SH_STUB_MODE)
     1075
     1076#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)
    8561077# ifdef _MSC_VER
    8571078    pid_t pgid = pid;
    … …  
    8591080    pid_t pgid = getpgid(pid);
    8601081# endif
     1082
    8611083#else
    8621084#endif
    … …  
    8711093#ifdef SH_PURE_STUB_MODE
    8721094    int rc = -1;
    873 #elif defined(SH_STUB_MODE)
     1095
     1096#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)
    8741097# ifdef _MSC_VER
    8751098    int rc = -1;
     1099    error = ENOSYS;
    8761100# else
    8771101    int rc = setpgid(pid, pgid);
    8781102# endif
     1103
    8791104#else
    8801105#endif
    … …  
    8911116#ifdef SH_PURE_STUB_MODE
    8921117    pgrp = -1;
    893 #elif defined(SH_STUB_MODE)
     1118
     1119#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)
    8941120# ifdef _MSC_VER
    8951121    pgrp = -1;
     1122    error = ENOSYS;
    8961123# else
    8971124    pgrp = tcgetpgrp(fd);
    8981125# endif
     1126
    8991127#else
    9001128#endif
    … …  
    9121140#ifdef SH_PURE_STUB_MODE
    9131141    rc = -1;
    914 #elif defined(SH_STUB_MODE)
     1142
     1143#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)
    9151144# ifdef _MSC_VER
    9161145    rc = -1;
     1146    error = ENOSYS;
    9171147# else
    9181148    rc = tcsetpgrp(fd, pgrp);
    9191149# endif
     1150
    9201151#else
    9211152#endif
    … …  
    9301161#ifdef SH_PURE_STUB_MODE
    9311162    int rc = -1;
    932 #elif defined(SH_STUB_MODE)
     1163
     1164#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)
    9331165# ifdef _MSC_VER
    9341166    int rc = -1;
     1167    error = ENOSYS;
    9351168# else
    9361169    int rc = getrlimit(resid, limp);
    9371170# endif
    938 #else
     1171
     1172#else
     1173    /* returned the stored limit */
    9391174#endif
    9401175
    … …  
    9491184#ifdef SH_PURE_STUB_MODE
    9501185    int rc = -1;
    951 #elif defined(SH_STUB_MODE)
     1186
     1187#elif defined(SH_STUB_MODE) || defined(SH_FORKED_MODE)
    9521188# ifdef _MSC_VER
    9531189    int rc = -1;
     1190    error = ENOSYS;
    9541191# else
    9551192    int rc = setrlimit(resid, limp);
    9561193# endif
    957 #else
     1194
     1195#else
     1196    /* if max(shell) < limp; then setrlimit; fi
     1197       if success; then store limit for later retrival and maxing. */
     1198
    9581199#endif
    9591200

  • trunk/src/kash/shinstance.h

    r2243 r2286  
    131131    shfdtab             fdtab;          /**< The file descriptor table. */
    132132    shsigaction_t       sigactions[NSIG]; /**< The signal actions registered with this shell instance. */
     133    shsigset_t          sigmask;        /**< Our signal mask. */
     134    char              **shenviron;      /**< The environment vector. */
    133135
    134136    /* alias.c */
    … …  
    327329
    328330
    329 extern shinstance *sh_create_root_shell(shinstance *, int, char **);
     331extern shinstance *sh_create_root_shell(shinstance *, int, char **, char **);
    330332
    331333/* environment & pwd.h */
    … …  
    363365int sh_siginterrupt(shinstance *, int, int);
    364366void sh_sigemptyset(shsigset_t *);
    365 int sh_sigfillset(shsigset_t *);
     367void sh_sigfillset(shsigset_t *);
    366368void sh_sigaddset(shsigset_t *, int);
    367369void sh_sigdelset(shsigset_t *, int);
Note: See TracChangeset for help on using the changeset viewer.

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