Return to unshar CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / news / misc

Annotation of 43BSD/contrib/news/misc/unshar, revision 1.1

1.1     ! root        1: From [email protected] Sun Oct 28 16:56:42 1984
        !             2: Relay-Version: version B 2.10.2 10/19/84; site seismo.UUCP
        !             3: Posting-Version: version B 2.10.2 9/5/84; site unmvax.UUCP
        !             4: Path: seismo!cmcl2!lanl!unm-cvax!unmvax!lee
        !             5: From: [email protected]
        !             6: Newsgroups: net.sources
        !             7: Subject: Program to un-shar netmaps without using a shell..
        !             8: Message-ID: <[email protected]>
        !             9: Date: 28 Oct 84 21:56:42 GMT
        !            10: Date-Received: 29 Oct 84 11:14:42 GMT
        !            11: Distribution: net
        !            12: Organization: Univ. of New Mexico, Albuquerque
        !            13: Lines: 336
        !            14: 
        !            15: #ifndef        lint
        !            16: char   *Rcsid = "$Header: getmaps.c,v 1.4 84/10/13 18:19:13 lee Exp $";
        !            17: #endif
        !            18: 
        !            19: /*
        !            20:  * getmaps
        !            21:  *
        !            22:  * Get the net maps from USENET as published by Karen and Mark Horton, in
        !            23:  * "shar" format. Because of paranoia the sh is not used but instead a DFA
        !            24:  * recognizing the appropriate commands.
        !            25:  *
        !            26:  * lee Ward            10/13/84
        !            27:  */
        !            28: 
        !            29: #include <stdio.h>
        !            30: #include <ctype.h>
        !            31: #include <sys/types.h>
        !            32: #include <sys/stat.h>
        !            33: #include <sys/dir.h>
        !            34: 
        !            35: char   *mapgrp = "/usr/spool/news/net/news/map";
        !            36: char   *mapdir = "/usr/lee/netmap/maps";
        !            37: char   *seqfil = "/usr/lee/netmap/.seq";
        !            38: char   *logfil = "/usr/lee/netmap/log";
        !            39: 
        !            40: char   *usestr = "[-l logfil] [-g group] [-s seqfile] [-a archiv-dir]";
        !            41: 
        !            42: FILE   *logsd = NULL;
        !            43: 
        !            44: void   domaps(), myabort(), log(), mkmaps(), getwrd(), logtime();
        !            45: 
        !            46: main(argc, argv)
        !            47:        int     argc;
        !            48:        char    *argv[];
        !            49: {
        !            50:        int     x;
        !            51:        FILE    *seqsd;
        !            52:        char    seqbuf[BUFSIZ];
        !            53: 
        !            54:        for (x = 1; x < argc; x++) {
        !            55:                if (*argv[x]++ != '-') {
        !            56:                        fprintf(stderr, "Bad usage\n");
        !            57:                        fprintf(stderr, "Usage: %s %s\n", argv[0], usestr);
        !            58:                        exit(-1);
        !            59:                }
        !            60:                switch (*argv[x]) {
        !            61: 
        !            62:                case 'l':
        !            63:                        logfil = argv[++x];
        !            64:                        break;
        !            65:                case 'g':
        !            66:                        mapgrp = argv[++x];
        !            67:                        break;
        !            68:                case 's':
        !            69:                        seqfil = argv[++x];
        !            70:                        break;
        !            71:                case 'a':
        !            72:                        mapdir = argv[++x];
        !            73:                        break;
        !            74:                default:
        !            75:                        fprintf(stderr, "Bad switch\n");
        !            76:                        fprintf(stderr, "Usage: %s %s\n", argv[0], usestr);
        !            77:                        exit(-1);
        !            78:                }
        !            79:        }
        !            80: 
        !            81:        logsd = fopen(logfil, "a");
        !            82: 
        !            83:        logtime("Start");
        !            84: 
        !            85:        if (chdir(mapdir) != 0)
        !            86:                myabort("Could not change directory to %s", mapdir);
        !            87: 
        !            88:        seqbuf[0] = NULL;
        !            89:        if ((seqsd = fopen(seqfil, "r")) != NULL) {
        !            90:                if ((x = fread(seqbuf, sizeof(char), sizeof(seqbuf),
        !            91:                    seqsd)) != 0)
        !            92:                        seqbuf[x - 1] = NULL;
        !            93:                (void )fclose(seqsd);
        !            94:        }
        !            95:        if ((seqsd = fopen(seqfil, "a")) == NULL)
        !            96:                myabort("Could not open seq file for writing");
        !            97:        (void )fseek(seqsd, 0L, 0);
        !            98: 
        !            99:        domaps(mapgrp, seqbuf, seqsd);
        !           100:        (void )fclose(seqsd);
        !           101: 
        !           102:        logtime("End");
        !           103: }
        !           104: 
        !           105: void
        !           106: domaps(grp, seqbuf, seqsd)
        !           107:        char    *grp, *seqbuf;
        !           108:        FILE    *seqsd;
        !           109: {
        !           110:        char    nbuf[BUFSIZ], *nptr, *tptr;
        !           111:        struct direct **filst;
        !           112:        int     nfils, x;
        !           113:        struct stat stbuf;
        !           114:        extern int scandir(), alphasort();
        !           115:        extern char *strcpy(), *strncat();
        !           116: 
        !           117:        if ((nfils = scandir(grp, &filst, (int (*)())NULL, alphasort)) == -1)
        !           118:                myabort("scandir failed");
        !           119: 
        !           120:        (void )strcpy(nbuf, grp);
        !           121:        nptr = nbuf + strlen(nbuf);
        !           122:        *nptr++ = '/';
        !           123:        *nptr = NULL;
        !           124:        nbuf[BUFSIZ] = NULL;
        !           125: 
        !           126:        for (x = 0; x < nfils; x++) {
        !           127:                if (strcmp(".", filst[x]->d_name) == 0 ||
        !           128:                    strcmp("..", filst[x]->d_name) == 0)
        !           129:                        continue;
        !           130:                tptr = filst[x]->d_name;
        !           131:                while(*tptr && isdigit(*tptr))
        !           132:                        tptr++;
        !           133:                if (*tptr != NULL)
        !           134:                        continue;
        !           135:                *nptr = NULL;
        !           136:                (void )strncat(nptr, filst[x]->d_name,
        !           137:                    BUFSIZ - (nptr - nbuf) - 1);
        !           138:                if (stat(nbuf, &stbuf) != 0) {
        !           139:                        log("Could not stat %s", nbuf);
        !           140:                        continue;
        !           141:                }
        !           142:                if ((stbuf.st_mode & S_IFMT) == S_IFDIR)
        !           143:                        continue;
        !           144:                if (strcmp(seqbuf, filst[x]->d_name) >= 0)
        !           145:                        continue;
        !           146: 
        !           147:                mkmaps(nbuf);
        !           148:                (void )fseek(seqsd, 0L, 0);
        !           149:                (void )fwrite(filst[x]->d_name, sizeof(char),
        !           150:                    strlen(filst[x]->d_name), seqsd);
        !           151:                (void )fputc('\n', seqsd);
        !           152:                (void )fflush(seqsd);
        !           153:        }
        !           154: }
        !           155: 
        !           156: void
        !           157: mkmaps(file)
        !           158:        char    *file;
        !           159: {
        !           160:        char    buf[BUFSIZ], tofil[BUFSIZ], delim[BUFSIZ];
        !           161:        int     state, sizdel;
        !           162:        FILE    *isd, *osd;
        !           163:        extern FILE *fopen();
        !           164: 
        !           165: #define        SEARCH          1
        !           166: #define        INAMAP          2
        !           167: #define        SKIPPING        3
        !           168: 
        !           169:        if ((isd = fopen(file, "r")) == NULL) {
        !           170:                log("Could not open %s. Skipping...", file);
        !           171:                return;
        !           172:        }
        !           173:        log("Unarchive %s", file);
        !           174: 
        !           175:        state = SEARCH;
        !           176:        while (fgets(buf, sizeof(buf) - 1, isd) != NULL) {
        !           177:                buf[sizeof(buf)] = NULL;
        !           178:                if (state == SEARCH) {
        !           179:                        if (gotcat(buf, tofil, BUFSIZ, delim, BUFSIZ)) {
        !           180:                                state = INAMAP;
        !           181:                                sizdel = strlen(delim);
        !           182:                                if ((osd = fopen(tofil, "w")) == NULL) {
        !           183:                                        log("Could not open %s", tofil);
        !           184:                                        state = SKIPPING;
        !           185:                                }
        !           186:                        }
        !           187:                        continue;
        !           188:                }
        !           189:                if (strncmp(buf, delim, sizdel) == 0) {
        !           190:                        state = SEARCH;
        !           191:                        if (osd != NULL)
        !           192:                                (void )fclose(osd);
        !           193:                        continue;
        !           194:                }
        !           195:                if (state == SKIPPING)
        !           196:                        continue;
        !           197:                fputs(buf, osd);
        !           198:        }
        !           199:        if (state != SEARCH)
        !           200:                log("Read/sync error on %s", file);
        !           201:        (void )fclose(isd);
        !           202: 
        !           203: #undef SEARCH
        !           204: #undef INAMAP
        !           205: #undef SKIPPING
        !           206: }
        !           207: 
        !           208: /*
        !           209:  * gotcat
        !           210:  *
        !           211:  * Use a DFA to recognize
        !           212:  *     cat << DELIM > OUT
        !           213:  * or
        !           214:  *     cat > OUT << DELIM
        !           215:  *
        !           216:  */
        !           217: 
        !           218: /* Transition table for the DFA */
        !           219: int    ttbl[9][4] = {
        !           220:                1,-1,-1,-1,
        !           221:                -1,6,2,-1,
        !           222:                -1,-1,-1,3,
        !           223:                -1,4,-1,-1,
        !           224:                -1,-1,-1,5,
        !           225:                -1,-1,-1,-1,
        !           226:                -1,-1,-1,7,
        !           227:                -1,-1,8,-1,
        !           228:                -1,-1,-1,5,
        !           229:        };
        !           230: 
        !           231: gotcat(buf, tofil, tofilln, delim, delimln)
        !           232:        char    *buf,
        !           233:                *tofil,
        !           234:                *delim;
        !           235:        int     tofilln,
        !           236:                delimln;
        !           237: {
        !           238:        int     state;
        !           239:        char    *ptr;
        !           240: 
        !           241:        state = 0;                      /* Start state */
        !           242:        while (state != -1 && state != 5) {
        !           243:                /* Eat up white */
        !           244:                while (*buf != '\n' && (*buf == ' ' || *buf == '\t'))
        !           245:                        buf++;
        !           246:                if (*buf == '>') {
        !           247:                        buf++;
        !           248:                        state = ttbl[state][1];
        !           249:                        continue;
        !           250:                }
        !           251:                if (*buf == '<' && *(buf + 1) == '<') {
        !           252:                        buf += 2;
        !           253:                        state = ttbl[state][2];
        !           254:                        continue;
        !           255:                }
        !           256:                if (*buf == 'c' && *(buf + 1) == 'a' && *(buf + 2) == 't') {
        !           257:                        buf += 3;
        !           258:                        state = ttbl[state][0];
        !           259:                        continue;
        !           260:                }
        !           261:                ptr = buf;
        !           262:                while (*buf != '\n' && *buf != ' ' && *buf != '\t')
        !           263:                        buf++;
        !           264:                if (state == 2 || state == 8)
        !           265:                        getwrd(ptr, buf, delim, delimln);
        !           266:                else if (state == 6 || state == 4)
        !           267:                        getwrd(ptr, buf, tofil, tofilln);
        !           268:                state = ttbl[state][3];
        !           269:        }
        !           270: 
        !           271:        if (state == 5)
        !           272:                return(1);
        !           273:        return(0);
        !           274: }
        !           275: 
        !           276: void
        !           277: getwrd(fc, lc, buf, maxlen)
        !           278:        char    *fc,
        !           279:                *lc,
        !           280:                *buf;
        !           281:        int     maxlen;
        !           282: {
        !           283:        char    *ptr, *t1ptr, *t2ptr;
        !           284: 
        !           285:        maxlen--;
        !           286:        maxlen = lc - fc > maxlen ? maxlen : lc - fc;
        !           287:        ptr = buf;
        !           288:        t1ptr = fc;
        !           289:        while (maxlen-- != 0)
        !           290:                *ptr++ = *t1ptr++;
        !           291:        *ptr = NULL;
        !           292: 
        !           293:        /* Strip quotes */
        !           294:        ptr = buf;
        !           295:        while (*ptr != NULL) {
        !           296:                if (*ptr == '\\' && (*(ptr + 1) == '\'' || *(ptr + 1) == '"'))
        !           297:                        ptr += 2;
        !           298:                else if (*ptr == '\'' || *ptr == '"') {
        !           299:                        t1ptr = ptr;
        !           300:                        t2ptr = ptr + 1;
        !           301:                        while ((*t1ptr++ = *t2ptr++) != NULL)
        !           302:                                ;
        !           303:                } else
        !           304:                        ptr++;
        !           305:        }
        !           306: }
        !           307: /*VARARGS1*/
        !           308: void
        !           309: myabort(s, a, b, c, d, e, f, g, h, i, j, k, l)
        !           310:        char    *s;
        !           311: {
        !           312: 
        !           313:        if (logsd != NULL) {
        !           314:                fputs("ABORT - ", logsd);
        !           315:                fprintf(logsd, s, a, b, c, d, e, f, g, h, i, j, k, l);
        !           316:                (void )fputc('\n', logsd);
        !           317:                logtime("End");
        !           318:        }
        !           319:        exit(-1);
        !           320: }
        !           321: 
        !           322: /*VARARGS1*/
        !           323: void
        !           324: log(s, a, b, c, d, e, f, g, h, i, j, k, l)
        !           325:        char    *s;
        !           326: {
        !           327: 
        !           328:        if (logsd == NULL)
        !           329:                return;
        !           330:        fprintf(logsd, s, a, b, c, d, e, f, g, h, i, j, k, l);
        !           331:        (void )fputc('\n', logsd);
        !           332:        (void )fflush(logsd);
        !           333: }
        !           334: 
        !           335: void
        !           336: logtime(s)
        !           337:        char    *s;
        !           338: {
        !           339:        time_t  clock;
        !           340:        extern char *ctime();
        !           341: 
        !           342:        if (logsd == NULL)
        !           343:                return;
        !           344:        (void )time(&clock);
        !           345:        fprintf(logsd, "%s %s", s, ctime(&clock));
        !           346:        (void )fflush(logsd);
        !           347: }
        !           348: -- 
        !           349:                        --Lee (Ward)
        !           350:                        {ucbvax,convex,gatech,pur-ee}!unmvax!lee
        !           351: 
        !           352: 

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