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

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.