Annotation of researchv9/cmd/getty.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * getty -- adapt to terminal speed on dialup, and call login
                      3:  */
                      4: 
                      5: #include <sys/ttyio.h>
                      6: #include <signal.h>
                      7: #include <sys/utsname.h>
                      8: 
                      9: #define ERASE  '\b'
                     10: #define KILL   '@'
                     11: 
                     12: #define        CEOT    004
                     13: #define        CKILL   '@'
                     14: #define        CQUIT   034             /* FS, cntl shift L */
                     15: #define        CINTR   0177            /* DEL */
                     16: #define        CSTOP   023             /* Stop output: ctl-s */
                     17: #define        CSTART  021             /* Start output: ctl-q */
                     18: #define        CBRK    0377
                     19: 
                     20: struct sgttyb tmode;
                     21: struct ttydevb tspeed;
                     22: 
                     23: struct tab {
                     24:        char    tname;          /* this table name */
                     25:        char    nname;          /* successor table name */
                     26:        int     iflags;         /* initial flags */
                     27:        int     fflags;         /* final flags */
                     28:        int     ispeed;         /* input speed */
                     29:        int     ospeed;         /* output speed */
                     30:        char    *message;       /* login message */
                     31: } itab[] = {
                     32: 
                     33: /* table '0'-1-2-3 300,1200,150,110 */
                     34: 
                     35:        '0', 1,
                     36:        ANYP+RAW+NL1+CR1, ANYP+XTABS+ECHO+CRMOD+CR2,
                     37:        B300, B300,
                     38:        "login: ",
                     39: 
                     40:        1, 2,
                     41:        ANYP+RAW+NL1+CR1, ANYP+XTABS+ECHO+CRMOD+FF1,
                     42:        B1200, B1200,
                     43:        "login: ",
                     44: 
                     45:        2, 3,
                     46:        ANYP+RAW+NL1+CR1, EVENP+ECHO+FF1+CR2+TAB1+NL1,
                     47:        B150, B150,
                     48:        "login: ",
                     49: 
                     50:        3, '0',
                     51:        ANYP+RAW+NL1+CR1, ANYP+ECHO+CRMOD+XTABS+LCASE+CR1,
                     52:        B110, B110,
                     53:        "login: ",
                     54: 
                     55: /* table '2' -- 9600 */
                     56:        '2', '2',
                     57:        ANYP+RAW+NL1+CR1, ANYP+XTABS+ECHO+CRMOD,
                     58:        B9600, B9600,
                     59:        "login: ",
                     60: 
                     61: /* table '3'-'5' -- 1200,300 */
                     62:        '3', '5',
                     63:        ANYP+RAW+NL1+CR1, ANYP+XTABS+ECHO+CRMOD+FF1,
                     64:        B1200, B1200,
                     65:        "login: ",
                     66: 
                     67: /* table '5'-'3' -- 300,1200 */
                     68:        '5', '3',
                     69:        ANYP+RAW+NL1+CR1, ANYP+ECHO+CR1,
                     70:        B300, B300,
                     71:        "login: ",
                     72: 
                     73: /* table '4' -- Console Decwriter */
                     74:        '4', '4',
                     75:        ANYP+CRMOD+CBREAK, ANYP+ECHO+CRMOD+XTABS,
                     76:        B300, B300,
                     77:        "login: ",
                     78: 
                     79: /* table '6' -- 2400  */
                     80:        '6', '6' ,
                     81:        ANYP+RAW , ANYP+ECHO+CRMOD ,
                     82:        B2400 , B2400 ,
                     83:        "login: ",
                     84:  
                     85: /* table '7' - - 4800 */
                     86:        '7' , '7' ,
                     87:        ANYP+RAW , ANYP+ECHO+CRMOD ,
                     88:        B4800 , B4800 ,
                     89:        "login: " ,
                     90: 
                     91: /* table '8'-10-'9' - - 9600 - 1200 - 300 */
                     92:        '8', 10,
                     93:        ANYP+RAW+NL1+CR1, ANYP+XTABS+ECHO+CRMOD,
                     94:        B9600, B9600,
                     95:        "login: ",
                     96: 
                     97:        10, '9',
                     98:        ANYP+RAW+NL1+CR1, ANYP+XTABS+ECHO+CRMOD+FF1,
                     99:        B1200, B1200,
                    100:        "login: ",
                    101: 
                    102:        '9', '8',
                    103:        ANYP+RAW+NL1+CR1, ANYP+ECHO+CR1,
                    104:        B300, B300,
                    105:        "login: ",
                    106: 
                    107: /* table 'j' -- 19200 */
                    108:        'j', 'j',
                    109:        ANYP+RAW+NL1+CR1, ANYP+XTABS+ECHO+CRMOD,
                    110:        EXTA, EXTA,
                    111:        "login: ",
                    112: 
                    113: /* table 'a'-'b' - - 2400 - 1200 */
                    114:        'a', 'b',
                    115:        ANYP+RAW+NL1+CR1, ANYP+XTABS+ECHO+CRMOD,
                    116:        B2400, B2400,
                    117:        "login: ",
                    118: 
                    119:        'b', 'a',
                    120:        ANYP+RAW+NL1+CR1, ANYP+XTABS+ECHO+CRMOD,
                    121:        B1200, B1200,
                    122:        "login: ",
                    123: };
                    124: 
                    125: 
                    126: #define        NITAB   sizeof itab/sizeof itab[0]
                    127: #define        EOT     04              /* EOT char */
                    128: 
                    129: char   name[16];
                    130: int    crmod;
                    131: int    upper;
                    132: int    lower;
                    133: 
                    134: char partab[] = {
                    135:        0001,0201,0201,0001,0201,0001,0001,0201,
                    136:        0202,0004,0003,0205,0005,0206,0201,0001,
                    137:        0201,0001,0001,0201,0001,0201,0201,0001,
                    138:        0001,0201,0201,0001,0201,0001,0001,0201,
                    139:        0200,0000,0000,0200,0000,0200,0200,0000,
                    140:        0000,0200,0200,0000,0200,0000,0000,0200,
                    141:        0000,0200,0200,0000,0200,0000,0000,0200,
                    142:        0200,0000,0000,0200,0000,0200,0200,0000,
                    143:        0200,0000,0000,0200,0000,0200,0200,0000,
                    144:        0000,0200,0200,0000,0200,0000,0000,0200,
                    145:        0000,0200,0200,0000,0200,0000,0000,0200,
                    146:        0200,0000,0000,0200,0000,0200,0200,0000,
                    147:        0000,0200,0200,0000,0200,0000,0000,0200,
                    148:        0200,0000,0000,0200,0000,0200,0200,0000,
                    149:        0200,0000,0000,0200,0000,0200,0200,0000,
                    150:        0000,0200,0200,0000,0200,0000,0000,0201
                    151: };
                    152: 
                    153: main(argc, argv)
                    154: char **argv;
                    155: {
                    156:        register struct tab *tabp;
                    157:        char tname;
                    158:        struct tchars tc;
                    159:        struct utsname myname;
                    160: 
                    161:        tname = '0';
                    162:        if (argc > 1)
                    163:                tname = argv[1][0];
                    164:        for (;;) {
                    165:                for(tabp = itab; tabp < &itab[NITAB]; tabp++)
                    166:                        if(tabp->tname == tname)
                    167:                                break;
                    168:                if(tabp >= &itab[NITAB])
                    169:                        tabp = itab;
                    170:                tmode.sg_ispeed = tabp->ispeed;
                    171:                tmode.sg_ospeed = tabp->ospeed;
                    172:                tmode.sg_flags = tabp->iflags;
                    173:                tspeed.ispeed = tabp->ispeed;
                    174:                tspeed.ospeed = tabp->ospeed;
                    175:                tspeed.flags = tabp->iflags & ANYP;
                    176:                ioctl(0, TIOCSETP, &tmode);
                    177:                ioctl(0, TIOCSDEV, &tspeed);
                    178:                tc.t_intrc = CINTR;
                    179:                tc.t_quitc = CQUIT;
                    180:                tc.t_stopc = CSTOP;
                    181:                tc.t_startc = CSTART;
                    182:                tc.t_brkc = CBRK;
                    183:                tc.t_eofc = CEOT;
                    184:                ioctl(0, TIOCSETC, &tc);
                    185:                ioctl(0, TIOCNXCL, 0);
                    186:                if (tmode.sg_ospeed > B1200)
                    187:                        puts("\n\r");
                    188:                else
                    189:                        puts("\n\r\r\r\r\r");
                    190:                uname(&myname);
                    191:                puts(myname.nodename);
                    192:                puts("\n\r\r\r");
                    193:                puts(tabp->message);
                    194:                if(getname()) {
                    195:                        if (upper == 0 && lower == 0)
                    196:                                continue;
                    197:                        tmode.sg_erase = ERASE;
                    198:                        tmode.sg_kill = KILL;
                    199:                        tmode.sg_flags = tabp->fflags;
                    200:                        if(crmod)
                    201:                                tmode.sg_flags |= CRMOD;
                    202:                        if(upper)
                    203:                                tmode.sg_flags |= LCASE;
                    204:                        if(lower)
                    205:                                tmode.sg_flags &= ~LCASE;
                    206:                        ioctl(0, TIOCSETP, &tmode);
                    207:                        putchr('\n');
                    208:                        execl("/etc/login", "login", name, 0);
                    209:                        exit(1);
                    210:                }
                    211:                tname = tabp->nname;
                    212:        }
                    213: }
                    214: 
                    215: getname()
                    216: {
                    217:        register char *np;
                    218:        register c;
                    219:        char cs;
                    220: 
                    221:        crmod = 0;
                    222:        upper = 0;
                    223:        lower = 0;
                    224:        np = name;
                    225:        for (;;) {
                    226:                if (read(0, &cs, 1) <= 0)
                    227:                        exit(0);
                    228:                if ((c = cs&0177) == 0)
                    229:                        return(0);
                    230:                if (c==EOT)
                    231:                        exit(1);
                    232:                if (c=='\r' || c=='\n' || np >= &name[16])
                    233:                        break;
                    234:                putchr(cs);
                    235:                if (c>='a' && c <='z')
                    236:                        lower++;
                    237:                else if (c>='A' && c<='Z') {
                    238:                        upper++;
                    239:                        c += 'a'-'A';
                    240:                } else if (c==ERASE) {
                    241:                        if (np > name)
                    242:                                np--;
                    243:                        continue;
                    244:                } else if (c==KILL) {
                    245:                        putchr('\r');
                    246:                        putchr('\n');
                    247:                        np = name;
                    248:                        continue;
                    249:                }
                    250:                *np++ = c;
                    251:        }
                    252:        *np = 0;
                    253:        if (c == '\r')
                    254:                crmod++;
                    255:        return(1);
                    256: }
                    257: 
                    258: puts(as)
                    259: char *as;
                    260: {
                    261:        register char *s;
                    262: 
                    263:        s = as;
                    264:        while (*s)
                    265:                putchr(*s++);
                    266: }
                    267: 
                    268: putchr(cc)
                    269: {
                    270:        char c;
                    271:        c = cc;
                    272:        c |= partab[c&0177] & 0200;
                    273:        write(1, &c, 1);
                    274: }

unix.superglobalmegacorp.com

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