Return to gettty.c CVS log

Up to [Research Unix] / researchv10no / cmd / ps

Annotation of researchv10no/cmd/ps/gettty.c, revision 1.1

1.1     ! root        1: #include "ps.h"
        !             2: #include <stdio.h>
        !             3: #include <ndir.h>
        !             4: 
        !             5: char *
        !             6: gettty(dev, node)
        !             7: {
        !             8:        register char *nm;
        !             9:        if (dev == NODEV) {     /* cheap hack: assume it's a pipe */
        !            10:                static char buf[8];
        !            11:                sprintf(buf, "p%4.4x", node&0xffff);
        !            12:                return buf;
        !            13:        }
        !            14:        nm = lookdir(node);
        !            15:        if (nm == 0)
        !            16:                return "?";
        !            17:        if (nm[0] == 't' && nm[1] == 't' && nm[2] == 'y')
        !            18:                nm += 3;
        !            19:        return nm;
        !            20: }
        !            21: 
        !            22: initttys()
        !            23: {
        !            24:        char dirname[100];      /* arbitrary size */
        !            25:        List *lp;
        !            26:        FILE *fp;
        !            27: 
        !            28:        if ((fp = fopen("/lib/ttydevs", "r")) == NULL) {
        !            29:                devlist = getdir("/dev", devlist);
        !            30:                return;
        !            31:        }
        !            32:        while (fgets(dirname, sizeof(dirname), fp)) {
        !            33:                dirname[strlen(dirname)-1] = 0;
        !            34:                if ((lp = getdir(dirname, devlist)) != NULL)
        !            35:                        devlist = lp;
        !            36:        }
        !            37:        fclose(fp);
        !            38: }
        !            39: 
        !            40: char *
        !            41: lookdir(node)
        !            42: register node;
        !            43: {
        !            44:        register List *lp;
        !            45:        register Entry *ep;
        !            46:        if (node)
        !            47:                for (lp = devlist; lp; lp = lp->next)
        !            48:                        for (ep = lp->begin; ep; ep = ep->next)
        !            49:                                if (ep->e_val == node)
        !            50:                                        return ep->e_name;
        !            51:        return 0;
        !            52: }
        !            53: 
        !            54: List *
        !            55: getdir(dirname, list)
        !            56: char *dirname;
        !            57: List *list;
        !            58: {
        !            59:        register List *lp;
        !            60:        register Entry *ep;
        !            61:        register DIR *dirp;
        !            62:        register struct direct *dp;
        !            63: 
        !            64:        if((dirp = opendir(dirname)) == 0)
        !            65:                return 0;
        !            66:        if((lp = Malloc(List, 1)) == 0) {
        !            67:                closedir(dirp);
        !            68:                return 0;
        !            69:        }
        !            70:        lp->next = list;
        !            71:        lp->begin = 0;
        !            72:        lp->nentry = 0;
        !            73:        for(dp = readdir(dirp); dp; dp = readdir(dirp)) {
        !            74:                if(dp->d_name[0] == '.') {
        !            75:                        if(dp->d_name[1] == '\0')
        !            76:                                continue;
        !            77:                        if(dp->d_name[1] == '.' && dp->d_name[2] == '\0')
        !            78:                                continue;
        !            79:                }
        !            80:                if((ep = Malloc(Entry, 1)) == 0)
        !            81:                        break;
        !            82:                ep->next = lp->begin;
        !            83:                lp->begin = ep;
        !            84:                lp->nentry++;
        !            85:                ep->e_val = dp->d_ino;
        !            86:                strncpy(ep->e_name, dp->d_name, sizeof(ep->e_name));
        !            87:        }
        !            88:        closedir(dirp);
        !            89:        return lp;
        !            90: }

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