Return to chkpth.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd / uucp

Annotation of 3BSD/cmd/uucp/chkpth.c, revision 1.1

1.1     ! root        1:        /*  chkpth  2.2  5/21/79  13:20:43  */
        !             2: #include "uucp.h"
        !             3: #include <sys/types.h>
        !             4: #include <sys/stat.h>
        !             5: 
        !             6: static char SiD[] = "@(#)chkpth        2.2";
        !             7: 
        !             8: 
        !             9: #define DFLTNAME "default"
        !            10: #define MAXUSERS 20
        !            11: struct userpath {
        !            12:        char *us_lname;
        !            13:        char *us_mname;
        !            14:        char us_callback;
        !            15:        char **us_path;
        !            16: };
        !            17: struct userpath Upt[15];
        !            18: struct userpath *Mchdef = NULL, *Logdef = NULL;
        !            19: int Nbrusers = 0;
        !            20: int Uptfirst = 1;
        !            21: 
        !            22: /*******
        !            23:  *     chkpth(logname, mchname, path)
        !            24:  *     char *path, *logname, *mchname;
        !            25:  *
        !            26:  *     chkpth  -  this routine will check the path table for the
        !            27:  *     machine or log name (non-null parameter) to see if the
        !            28:  *     input path (path)
        !            29:  *     starts with an acceptable prefix.
        !            30:  *
        !            31:  *     return codes:  0  |  FAIL
        !            32:  */
        !            33: 
        !            34: chkpth(logname, mchname, path)
        !            35: char *path, *logname, *mchname;
        !            36: {
        !            37:        struct userpath *u;
        !            38:        extern char *lastpart();
        !            39:        char **p, *s;
        !            40:        char c;
        !            41:        int ret, i;
        !            42: 
        !            43:        if (Uptfirst) {
        !            44:                ret = rdpth(Upt);
        !            45:                ASSERT(ret == 0, "INIT USERFILE %d", Nbrusers);
        !            46:                Uptfirst = 0;
        !            47:        }
        !            48:        for (u = Upt, i = 0; i < Nbrusers; i++, u++) {
        !            49:                if (*logname != '\0' && strcmp(logname, u->us_lname) == SAME)
        !            50:                        break;
        !            51:                if (*mchname != '\0' && strcmp(mchname, u->us_mname) == SAME)
        !            52:                        break;
        !            53: 
        !            54:        }
        !            55:        if (i >= Nbrusers) {
        !            56:                if (*logname == '\0')
        !            57:                        u = Mchdef;
        !            58:                else
        !            59:                        u = Logdef;
        !            60:                if (u == NULL)
        !            61:                        return(FAIL);
        !            62:        }
        !            63:        /* found user name */
        !            64:        p = u->us_path;
        !            65:        /*  check for /../ in path name  */
        !            66:        for (s = path; *s != '\0'; s++) {
        !            67:                if (*s == '/' && prefix("../", (++s)))
        !            68:                        return(FAIL);
        !            69:        }
        !            70: 
        !            71:        for (p = u->us_path; *p != NULL; p++)
        !            72:                if (prefix(*p, path))
        !            73:                        return(0);
        !            74: 
        !            75:        if (prefix(Spool, path)) {
        !            76:                if ((c = *lastpart(path)) == DATAPRE
        !            77:                  || c == XQTPRE)
        !            78:                        return(0);
        !            79:        }
        !            80:        /* path name not valid */
        !            81:        return(FAIL);
        !            82: }
        !            83: 
        !            84: 
        !            85: /***
        !            86:  *     rdpth(u)
        !            87:  *     struct userpath *u;
        !            88:  *
        !            89:  *     rdpth  -  this routine will read the USFILE and
        !            90:  *     construct the userpath structure pointed to by (u);
        !            91:  *
        !            92:  *     return codes:  0  |  FAIL
        !            93:  */
        !            94: 
        !            95: rdpth(u)
        !            96: struct userpath *u;
        !            97: {
        !            98:        char buf[BUFSIZ + 1], *pbuf[BUFSIZ + 1], *pc, **cp;
        !            99:        extern char *calloc(), *index();
        !           100:        FILE *uf;
        !           101: 
        !           102:        if ((uf = fopen(USERFILE, "r")) == NULL) {
        !           103:                /* can not open file */
        !           104:                return(FAIL);
        !           105:        }
        !           106: 
        !           107:        while (fgets(buf, BUFSIZ, uf) != NULL) {
        !           108:                int nargs, i;
        !           109:                if (++Nbrusers > MAXUSERS) {
        !           110:                        fclose(uf);
        !           111:                        return(FAIL);
        !           112:                }
        !           113:                if ((pc = calloc(strlen(buf) + 1, sizeof (char)))
        !           114:                        == NULL) {
        !           115:                        /* can not allocate space */
        !           116:                        fclose(uf);
        !           117:                        return(FAIL);
        !           118:                }
        !           119: 
        !           120:                strcpy(pc, buf);
        !           121:                nargs = getargs(pc, pbuf);
        !           122:                u->us_lname = pbuf[0];
        !           123:                pc = index(u->us_lname, ',');
        !           124:                if (pc != NULL)
        !           125:                        *pc++ = '\0';
        !           126:                else
        !           127:                        pc = u + strlen(u->us_lname);
        !           128:                u->us_mname = pc;
        !           129:                if (*u->us_lname == '\0' && Logdef == NULL)
        !           130:                        Logdef = u;
        !           131:                else if (*u->us_mname == '\0' && Mchdef == NULL)
        !           132:                        Mchdef = u;
        !           133:                i = 1;
        !           134:                if (strcmp(pbuf[1], "c") == SAME) {
        !           135:                        u->us_callback = 1;
        !           136:                        i++;
        !           137:                }
        !           138:                else
        !           139:                        u->us_callback = 0;
        !           140:                if ((cp = u->us_path =
        !           141:                  calloc(nargs - i + 1, sizeof (char *))) == NULL) {
        !           142:                        /*  can not allocate space */
        !           143:                        fclose(uf);
        !           144:                        return(FAIL);
        !           145:                }
        !           146: 
        !           147:                while (i < nargs)
        !           148:                        *cp++ = pbuf[i++];
        !           149:                *cp = NULL;
        !           150:                u++;
        !           151:        }
        !           152: 
        !           153:        fclose(uf);
        !           154:        return(0);
        !           155: }
        !           156: 
        !           157: 
        !           158: /***
        !           159:  *     callback(name)  check for callback
        !           160:  *     char *name;
        !           161:  *
        !           162:  *     return codes:
        !           163:  *             0  -  no call back
        !           164:  *             1  -  call back
        !           165:  */
        !           166: 
        !           167: callback(name)
        !           168: char *name;
        !           169: {
        !           170:        struct userpath *u;
        !           171:        int ret, i;
        !           172: 
        !           173:        if (Uptfirst) {
        !           174:                ret = rdpth(Upt);
        !           175:                ASSERT(ret == 0, "INIT USERFILE %d", Nbrusers);
        !           176:                Uptfirst = 0;
        !           177:        }
        !           178: 
        !           179:        for (u = Upt, i = 0; i < Nbrusers; u++, i++) {
        !           180:                if (strcmp(u->us_lname, name) != SAME)
        !           181:                        continue;
        !           182: 
        !           183:                /* found user name */
        !           184:                return(u->us_callback);
        !           185:        }
        !           186: 
        !           187:        /* userid not found */
        !           188:        return(0);
        !           189: }
        !           190: 
        !           191: 
        !           192: /***
        !           193:  *     chkperm(file, user, mopt)       check write permission of file
        !           194:  *     char *file, *user;
        !           195:  *     char *mopt;             none NULL - create directories
        !           196:  *
        !           197:  *     if mopt != NULL and permissions are ok,
        !           198:  *     a side effect of this routine is to make
        !           199:  *     directories up to the last part of the
        !           200:  *     filename (if they do not exist).
        !           201:  *
        !           202:  *     return 0 | FAIL
        !           203:  */
        !           204: 
        !           205: chkperm(file, user, mopt)
        !           206: char *file, *user, *mopt;
        !           207: {
        !           208:        struct stat s;
        !           209:        int ret;
        !           210:        char dir[MAXFULLNAME];
        !           211:        extern char *lastpart();
        !           212: 
        !           213:        if (stat(file, &s) != -1)
        !           214:                return(0);
        !           215: 
        !           216:        strcpy(dir, file);
        !           217:        *lastpart(dir) = '\0';
        !           218:        if ((ret = stat(dir, &s)) == -1
        !           219:          && mopt == NULL)
        !           220:                return(FAIL);
        !           221: 
        !           222:        if (ret != -1) {
        !           223:                if ((s.st_mode & ANYWRITE) == 0)
        !           224:                        return(FAIL);
        !           225:                else
        !           226:                        return(0);
        !           227:        }
        !           228: 
        !           229:        /*  make directories  */
        !           230:        return(mkdirs(file));
        !           231: }

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