Return to main.c CVS log

Up to [Research Unix] / researchv10no / ipc / mgrs / dkmgr

Annotation of researchv10no/ipc/mgrs/dkmgr/main.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  *     Generic dialer routine.  Usage:
                      3:  *             dialer mount-pt [unit]
                      4:  */
                      5: #include <stdio.h>
                      6: #include <ipc.h>
                      7: #include <libc.h>
                      8: #include <utsname.h>
                      9: #include "defs.h"
                     10: 
                     11: /* export */
                     12: char *av0;
                     13: int unit='a';          /* a(ny), 0, 2, or b(oth) */
                     14: char *param;
                     15: char *netfiles = "/dev/dk/dk";
                     16: int debug;
                     17: 
                     18: /* cheap foiegn imports */
                     19: extern void dodialout(), dodialin();
                     20: 
                     21: usage(name)
                     22:        char *name;
                     23: {
                     24:        fprintf(stderr, "usage: %s [-m mount-pt] [-n netname] [-u [02ab]] [-t [02]]\n", name);
                     25:        exit(1);
                     26: }
                     27: 
                     28: main(ac, av)
                     29:        int ac;
                     30:        char *av[];
                     31: {
                     32:        char *netname=NULL, *mtpt="dk", *cp;
                     33:        int ai;
                     34:        char xbuf[3];
                     35: 
                     36:        av0 = av[0];
                     37:        chdir("/cs");
                     38: 
                     39:        /* get args */
                     40:        for (ai=1; ai<ac; ai++) {
                     41:                if (av[ai][0] == '-')
                     42:                        for (cp=&av[ai][1]; *cp; cp++) {
                     43:                                switch(*cp) {
                     44:                                case 'm':
                     45:                                        if (ai+1>=ac)
                     46:                                                usage(av[0]);
                     47:                                        mtpt = av[++ai];
                     48:                                        break;
                     49:                                case 'n':
                     50:                                        if (ai+1>=ac)
                     51:                                                usage(av[0]);
                     52:                                        netname = av[++ai];
                     53:                                        break;
                     54:                                case 'N':
                     55:                                        if (ai+1>=ac)
                     56:                                                usage(av[0]);
                     57:                                        netfiles = av[++ai];
                     58:                                        break;
                     59:                                case '0':
                     60:                                case '2':
                     61:                                case 'b':
                     62:                                case 'a':
                     63:                                        unit = *cp;
                     64:                                        break;
                     65:                                case 'd':
                     66:                                        debug = 1;
                     67:                                        break;
                     68:                                case 't':
                     69:                                        if (ai+1>=ac)
                     70:                                                usage(av[0]);
                     71:                                        switch(*av[++ai]) {
                     72:                                        case '0':
                     73:                                                param = "light";
                     74:                                                break;
                     75:                                        case '2':
                     76:                                                param = "heavy";
                     77:                                                break;
                     78:                                        default:
                     79:                                                usage(av[0]);
                     80:                                        }
                     81:                                        break;
                     82:                                case 'u':
                     83:                                        if (ai+1>=ac)
                     84:                                                usage(av[0]);
                     85:                                        switch(*av[++ai]) {
                     86:                                        case 'a':
                     87:                                        case 'b':
                     88:                                        case '0':
                     89:                                        case '2':
                     90:                                                unit = *av[ai];
                     91:                                                break;
                     92:                                        default:
                     93:                                                usage(av[0]);
                     94:                                        }
                     95:                                        break;
                     96:                                default:
                     97:                                        usage(av0);
                     98:                                }
                     99:                        }
                    100:                else
                    101:                        usage(av0);
                    102:        }
                    103:        if (!debug)
                    104:                detach(mtpt);
                    105: 
                    106:        /* get defaults */
                    107:        if (netname==NULL) {
                    108:                struct utsname name;
                    109: 
                    110:                uname(&name);
                    111:                netname = name.nodename;
                    112:        }
                    113: 
                    114:        /* create dialer and listener */
                    115:        switch (fork()) {
                    116:        case -1:
                    117:                perror(av0);
                    118:                exit(1);
                    119:        case 0:
                    120:                for(;;)
                    121:                        dodialout(mtpt);
                    122:        default:
                    123:                if (unit == 'b')
                    124:                        switch(fork()) {
                    125:                        case -1:
                    126:                                perror("dkdialer");
                    127:                                exit(1);
                    128:                        case 0:
                    129:                                if (param==NULL)
                    130:                                        param = "heavy";
                    131:                                unit = '2';
                    132:                                for(;;)
                    133:                                        dodialin(mtpt, netname, param);
                    134:                        default:
                    135:                                if (param==NULL)
                    136:                                        param = "light";
                    137:                                unit = '0';
                    138:                                break;
                    139:                        }
                    140:                if (param==NULL)
                    141:                        param = "heavy";
                    142:                xbuf[0] = ' ';
                    143:                xbuf[1] = unit;
                    144:                xbuf[2] = 0;
                    145:                strcat(av0, xbuf);
                    146:                for(;;)
                    147:                        dodialin(mtpt, netname, param);
                    148:        }
                    149: }

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