Return to args.c CVS log

Up to [Research Unix] / researchv10no / cmd / odist / opkg

Annotation of researchv10no/cmd/odist/opkg/args.c, revision 1.1

1.1     ! root        1: #include "asd.h"
        !             2: #include <libv.h>
        !             3: #include <string.h>
        !             4: 
        !             5: int bflag;                     /* -b make a backup package */
        !             6: int kflag;                     /* -k crypto key (deprecated) */
        !             7: int Kflag;                     /* -K crypto key from file (deprecated) */
        !             8: int nflag;                     /* -n don't actually install files */
        !             9: int vflag;                     /* -v verbose output */
        !            10: char *xstr;                    /* -x command to execute */
        !            11: char *Xstr;                    /* -X file to execute */
        !            12: struct replist *replist;       /* -D substitutions */
        !            13: 
        !            14: int
        !            15: getargs (int argc, char **argv, char *optkey, int (*func)(FILE *, char *))
        !            16: {
        !            17:        register int c;
        !            18:        int rc = 0;
        !            19:        char *keyfile;
        !            20: 
        !            21:        while ((c = getopt (argc, argv, optkey)) != EOF) {
        !            22:                register struct replist *rl;
        !            23:                register char *p, *q;
        !            24: 
        !            25:                switch (c) {
        !            26: 
        !            27:                case 'b':
        !            28:                        bflag++;
        !            29:                        break;
        !            30: 
        !            31:                case 'k':
        !            32:                        kflag++;
        !            33:                        break;
        !            34: 
        !            35:                case 'n':
        !            36:                        nflag++;
        !            37:                        break;
        !            38:                
        !            39:                case 'v':
        !            40:                        vflag++;
        !            41:                        break;
        !            42: 
        !            43:                case 'x':
        !            44:                        if (xstr) {
        !            45:                                fprintf (stderr, "duplicate -x ignored\n");
        !            46:                                rc++;
        !            47:                        } else if (Xstr) {
        !            48:                                fprintf (stderr, "cannot have both -x and -X\n");
        !            49:                                rc++;
        !            50:                        } else
        !            51:                                xstr = optarg;
        !            52:                        break;
        !            53: 
        !            54:                case 'X':
        !            55:                        if (Xstr) {
        !            56:                                fprintf (stderr, "duplicate -X ignored\n");
        !            57:                                rc++;
        !            58:                        } else if (xstr) {
        !            59:                                fprintf (stderr, "cannot have both -x and -X\n");
        !            60:                                rc++;
        !            61:                        } else
        !            62:                                Xstr = copy (transname (optarg));
        !            63:                        break;
        !            64: 
        !            65:                case 'D':
        !            66:                        p = strchr (optarg, '=');
        !            67:                        if (p == NULL) {
        !            68:                                fprintf (stderr, "invalid option %s\n", optarg);
        !            69:                                exit (1);
        !            70:                        }
        !            71:                        rl = new (struct replist);
        !            72: 
        !            73:                        /* copy the pathname to rl->source */
        !            74:                        rl->source = alloc ((unsigned) (p - optarg + 1));
        !            75:                        p = rl->source;
        !            76:                        q = optarg;
        !            77:                        while (*q != '=')
        !            78:                                *p++ = *q++;
        !            79:                        *p = '\0';
        !            80: 
        !            81:                        /* now expand rl->source */
        !            82:                        p = rl->source;
        !            83:                        rl->source = copy (fullname (p));
        !            84:                        free (p);
        !            85: 
        !            86:                        /* expand rl->dest */
        !            87:                        rl->dest = copy (fullname (q + 1));
        !            88: 
        !            89:                        /* link rl into the chain */
        !            90:                        rl->link = replist;
        !            91:                        replist = rl;
        !            92:                        break;
        !            93: 
        !            94:                case 'K':
        !            95:                        Kflag++;
        !            96:                        keyfile = optarg;
        !            97:                        break;
        !            98: 
        !            99:                case '?':
        !           100:                default:
        !           101:                        rc++;
        !           102:                        break;
        !           103:                }
        !           104:        }
        !           105: 
        !           106:        if (rc) {
        !           107:                fprintf (stderr, "%s: bad argument\n", argv[0]);
        !           108:                exit (rc);
        !           109:        }
        !           110: 
        !           111:        if (kflag && Kflag) {
        !           112:                fprintf (stderr, "%s: cannot specify both k and K\n", argv[0]);
        !           113:                exit (1);
        !           114:        }
        !           115: 
        !           116:        /* read key from terminal if requested */
        !           117:        if (kflag) {
        !           118:                register char *p;
        !           119:                p = getpass ("Key:");
        !           120: 
        !           121:                /* a null key is treated as no key at all */
        !           122:                if (p && *p)
        !           123:                        setup (p);
        !           124:                else
        !           125:                        kflag = 0;
        !           126:        }
        !           127:        
        !           128:        /* read key from file if requested */
        !           129:        if (Kflag) {
        !           130:                char key[100];
        !           131:                register FILE *kf;
        !           132:                register char *p;
        !           133: 
        !           134:                /* try to open the file */
        !           135:                kf = fopen (keyfile, "r");
        !           136:                if (kf == NULL) {
        !           137:                        perror (keyfile);
        !           138:                        exit (1);
        !           139:                }
        !           140: 
        !           141:                /* read the first line */
        !           142:                p = fgets (key, sizeof (key), kf);
        !           143: 
        !           144:                fclose (kf);
        !           145: 
        !           146:                /* if EOF, assume no key */
        !           147:                if (p == NULL) {
        !           148:                        Kflag = 0;
        !           149:                } else {
        !           150: 
        !           151:                        /* delete the trailing newline */
        !           152:                        p = key;
        !           153:                        while (*p != '\n' && *p != '\0')
        !           154:                                p++;
        !           155:                        *p = '\0';
        !           156: 
        !           157:                        /* if the key is empty, assume no key */
        !           158:                        if (key[0] == '\0')
        !           159:                                Kflag = 0;
        !           160:                        else
        !           161:                                setup (key);
        !           162:                }
        !           163:        }
        !           164: 
        !           165:        if (func) {
        !           166:                /* process the arguments */
        !           167:                if (optind >= argc)
        !           168:                        rc = (*func) (stdin, "standard input");
        !           169:                else {
        !           170:                        register int i;
        !           171:                        for (i = optind; i < argc; i++) {
        !           172:                                register char *fn = argv[i];
        !           173:                                register FILE *f = fopen (fn, "r");
        !           174:                                if (f) {
        !           175:                                        rc += (*func) (f, argv[i]);
        !           176:                                        fclose (f);
        !           177:                                } else {
        !           178:                                        fprintf (stderr, "%s: can't open %s\n", argv[0], fn);
        !           179:                                        rc++;
        !           180:                                }
        !           181:                        }
        !           182:                }
        !           183:        }
        !           184: 
        !           185:        return rc;
        !           186: }

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