Return to exec_act.c CVS log

Up to [Research Unix] / researchv9 / ipc / src / mgrs / svcmgr

Annotation of researchv9/ipc/src/mgrs/svcmgr/exec_act.c, revision 1.1

1.1     ! root        1: #include "mgr.h"
        !             2: #include <sys/param.h>
        !             3: #include <sys/ioctl.h>
        !             4: #include <pwd.h>
        !             5: #include <ctype.h>
        !             6: #include "defs.h"
        !             7: 
        !             8: /*
        !             9:  *  get parameters from caller
        !            10:  */
        !            11: parms(rp, ap)
        !            12:        Request *rp;
        !            13:        Action *ap;
        !            14: {
        !            15:        char pbuf[ARB];
        !            16:        char *s;
        !            17:        char *rdline();
        !            18:        char *strchr();
        !            19: 
        !            20:        USE(ap);
        !            21:        if ((s = rdline(rp->i->cfd)) == NULL)
        !            22:                return -1;
        !            23:        rp->args = strdup(s);
        !            24:        return 0;
        !            25: }
        !            26: 
        !            27: /*
        !            28:  *  get terminal type(speed, etc) from caller
        !            29:  */
        !            30: term(rp, ap)
        !            31:        Request *rp;
        !            32:        Action *ap;
        !            33: {
        !            34:        char pbuf[ARB];
        !            35:        char *s, *sl;
        !            36:        char *rdline();
        !            37:        char *strchr();
        !            38: 
        !            39:        USE(ap);
        !            40:        if (ap->arg!=NULL && *(ap->arg)!='\0') {
        !            41:                rp->term = strdup(ap->arg);
        !            42:        } else {
        !            43:                if((s = rdline(rp->i->cfd)) == NULL)
        !            44:                        return -1;
        !            45:                if(sl=strchr(s, '/'))
        !            46:                        *sl = '\0';
        !            47:                rp->term = strdup(s);
        !            48:        }
        !            49:        return 0;
        !            50: }
        !            51: 
        !            52: /*
        !            53:  *  action routines that end in execs
        !            54:  */
        !            55: 
        !            56: doconn(rp, ap)
        !            57:        Request *rp;
        !            58:        Action *ap;
        !            59: {
        !            60:        USE(ap);
        !            61:        ioctl(rp->i->cfd, TCPIOHUP, 0);         /* hang-up TCP on FIN */
        !            62:        login(rp, rp->line, (char *)NULL);
        !            63: }
        !            64: 
        !            65: doexec(rp, ap)
        !            66:        Request *rp;
        !            67:        Action *ap;
        !            68: {
        !            69:        USE(ap);
        !            70:        login(rp, rp->line, rp->args);
        !            71: }
        !            72: 
        !            73: docmd(rp, ap)
        !            74:        Request *rp;
        !            75:        Action *ap;
        !            76: {
        !            77:        register char *p;
        !            78:        char buf[ARB];
        !            79: 
        !            80:        for(p=rp->args; *p; p++)
        !            81:                if (strchr("\n&;^|<>(){}`", *p))
        !            82:                        *p = ' ';
        !            83:        strcpy(buf, ap->arg);
        !            84:        strcat(buf, " ");
        !            85:        /*
        !            86:        for(p=rp->args; *p && !isspace(*p); p++)
        !            87:                ;
        !            88:         */
        !            89:        strcat(buf, rp->args);
        !            90:        login(rp, rp->line, buf);
        !            91: }
        !            92: 
        !            93: login(rp, pw, cmd)
        !            94:        Request *rp;
        !            95:        char *pw, *cmd;
        !            96: {
        !            97:        char *args[5];
        !            98:        register char **ap;
        !            99:        register int i;
        !           100:        char **inienv;
        !           101:        char **srcenv(), **termenv();
        !           102: 
        !           103:        ap = args;
        !           104:        *ap++ = "login";
        !           105:        if (pw) {
        !           106:                *ap++ = "-p";
        !           107:                *ap++ = pw;
        !           108:                if (cmd)
        !           109:                        *ap++ = cmd;
        !           110:        }
        !           111:        *ap = NULL;
        !           112:        for (i = 0; i < NSYSFILE; i++)
        !           113:                dup2(rp->i->cfd, i);
        !           114:        for (; i < NOFILE; i++)
        !           115:                close(i);
        !           116:        termenv(rp);
        !           117:        inienv = srcenv(rp);
        !           118:        ioctl(0, TIOCSPGRP, 0);
        !           119:        execve("/etc/login", args, inienv);
        !           120:        execve("/bin/login", args, inienv);
        !           121:        _exit(1);
        !           122: }
        !           123: 
        !           124: char **newep;  /* set up by init */
        !           125: char *newenv[5];
        !           126: 
        !           127: char **
        !           128: srcenv(rp)
        !           129:        Request *rp;
        !           130: {
        !           131:        static char buf[100];
        !           132: 
        !           133:        sprintf(buf, "CSOURCE=%s!%s", rp->i->machine, rp->i->user);
        !           134:        *newep++ = buf;
        !           135:        *newep = NULL;
        !           136:        return (newenv);
        !           137: }
        !           138: 
        !           139: char **
        !           140: termenv(rp)
        !           141:        Request *rp;
        !           142: {
        !           143:        static char buf[100];
        !           144: 
        !           145:        if (rp->term == NULL)
        !           146:                return (newenv);
        !           147:        sprintf(buf, "TERM=%s", rp->term);
        !           148:        *newep++ = buf;
        !           149:        *newep = NULL;
        !           150:        return (newenv);
        !           151: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.