Return to main.c CVS log

Up to [Research Unix] / researchv9 / ipc / src / mgrs / dkmgr

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

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