Return to label.c CVS log

Up to [Research Unix] / researchv10dc / libc / sys

Annotation of researchv10dc/libc/sys/label.c, revision 1.1

1.1     ! root        1: /* interfaces to "secure unix" system calls, designed to
        !             2:    "work" on systems with or without these calls */
        !             3: 
        !             4: #include <errno.h>
        !             5: #include "label.h"             /* SHOULD BE <sys/label.h> */
        !             6: 
        !             7: extern int errno;
        !             8: #ifndef ENOSYS
        !             9: #define ENOSYS 39
        !            10: #endif
        !            11: 
        !            12: static struct label lbot = {0, L_BITS };
        !            13: static struct label lfloor = { 0, L_BITS };
        !            14: static int labels = 1;
        !            15: 
        !            16: static iflabeled()
        !            17: {
        !            18:        if(errno==100 || errno==ENOSYS)
        !            19:                return labels = errno = 0;
        !            20:        else
        !            21:                return -1;
        !            22: }
        !            23: getflab(name, lp)
        !            24: char *name;
        !            25: struct label *lp;
        !            26: {
        !            27:        register r;
        !            28: 
        !            29:        r = labels? syscall(64+30, name, lp): 0;
        !            30:        if(r == -1)
        !            31:                r = iflabeled();
        !            32:        if(!labels)
        !            33:                *lp = lbot;
        !            34:        return(r);
        !            35: }
        !            36: fgetflab(fd, lp)
        !            37: struct label *lp;
        !            38: {
        !            39:        register r;
        !            40: 
        !            41:        r = labels? syscall(64+31, fd, lp): 0;
        !            42:        if(r == -1)
        !            43:                r = iflabeled();
        !            44:        if(!labels)
        !            45:                *lp = lbot;
        !            46:        return(r);
        !            47: }
        !            48: setflab(name, lp)
        !            49: char *name;
        !            50: struct label *lp;
        !            51: {
        !            52:        register r;
        !            53: 
        !            54:        r = labels? syscall(64+32, name, lp): 0;
        !            55:        if(r == -1)
        !            56:                r = iflabeled();
        !            57:        return(r);
        !            58: }
        !            59: fsetflab(fd, lp)
        !            60: struct label *lp;
        !            61: {
        !            62:        register r;
        !            63: 
        !            64:        r = labels? syscall(64+33, fd, lp): 0;
        !            65:        if(r == -1)
        !            66:                r = iflabeled();
        !            67:        return(r);
        !            68: }
        !            69: flabclr(fd)
        !            70: {
        !            71:        if(getflab("/etc/floor", &lfloor) == -1)
        !            72:                iflabeled();
        !            73:        lfloor.lb_priv = lbot.lb_priv;
        !            74:        fsetflab(fd, &lfloor);
        !            75: }
        !            76: getplab(lp, cp)
        !            77: struct label *lp, *cp;
        !            78: {
        !            79:        register r;
        !            80: 
        !            81:        r = labels? syscall(64+34, lp, cp): 0;
        !            82:        if(r == -1)
        !            83:                r = iflabeled();
        !            84:        if(!labels) {
        !            85:                *lp = lbot;
        !            86:                *cp = lbot;
        !            87:        }
        !            88:        return(r);
        !            89: }
        !            90: setplab(lp, cp)
        !            91: struct label *lp, *cp;
        !            92: {
        !            93:        register r;
        !            94: 
        !            95:        r = labels? syscall(64+35, lp, cp): 0;
        !            96:        if(r == -1)
        !            97:                r = iflabeled();
        !            98:        return(r);
        !            99: }
        !           100: nochk(fd, flag)
        !           101: {
        !           102:        register r;
        !           103: 
        !           104:        r = labels? syscall(64+29, fd, flag): 0;
        !           105:        if(r == -1)
        !           106:                r = iflabeled();
        !           107:        return(r);
        !           108: }
        !           109: #include <sys/types.h>
        !           110: #include <sys/filio.h>
        !           111: 
        !           112: #ifndef FIOGSRC
        !           113: # define       FIOGSRC         (('f'<<8)|106)
        !           114: # define       FIOSSRC         (('f'<<8)|107)
        !           115: #endif
        !           116: 
        !           117: static char buf[100]; /* <sys/stream.h>: sizeof( (struct stdata *)->source) */
        !           118: 
        !           119: setstsrc(fd, name)
        !           120: char *name;
        !           121: {
        !           122:        strncpy(buf, name?name:"", sizeof(buf));
        !           123:        return ioctl(fd, FIOSSRC, buf);
        !           124: }
        !           125: 
        !           126: set2stsrc(fd, s1, s2)
        !           127: char *s1;
        !           128: char *s2;
        !           129: {
        !           130:        strncpy(buf, s1?s1:"", sizeof(buf)-1);
        !           131:        strncat(buf, s2?s2:"", sizeof(buf)-strlen(buf));
        !           132:        return ioctl(fd, FIOSSRC, buf);
        !           133: }
        !           134: 
        !           135: char *
        !           136: getstsrc(fd) 
        !           137: {
        !           138:        if(ioctl(fd, FIOGSRC, buf) == -1)
        !           139:                return 0;
        !           140:        else
        !           141:                return buf;
        !           142: }

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