Return to tarf.c CVS log

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

Annotation of researchv10no/cmd/odist/tar/tarf.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include <string.h>
                      3: #include <time.h>
                      4: #include <libv.h>
                      5: #include "tar.h"
                      6: #include "misc.h"
                      7: 
                      8: int tflag;
                      9: 
                     10: int nerr;
                     11: struct sub *pathsublist;
                     12: 
                     13: int
                     14: filter(FILE *ifp, FILE *ofp)
                     15: {
                     16:        struct tarbuf buf;
                     17:        struct tarhdr hdr;
                     18:        char *ptr;
                     19:        int blocks;
                     20:        static char z[2 * TSIZE];
                     21: 
                     22:        if (fread(&buf, sizeof buf, 1, ifp) != 1) {
                     23:                ++nerr;
                     24:                fprintf(stderr, "tarf: premature eof on input\n");
                     25:                return 0;
                     26:        }
                     27:        if (memcmp(&buf, z, TSIZE) == 0) {
                     28:                if (!tflag && fwrite(z, 1, sizeof z, ofp) != sizeof z) {
                     29:                        ++nerr;
                     30:                        fprintf(stderr, "tarf: error writing eof header\n");
                     31:                }
                     32:                return 0;
                     33:        }
                     34:        if (thdrget(&hdr, &buf) != 0) {
                     35:                ++nerr;
                     36:                fprintf(stderr, "tarf: bad input header\n");
                     37:                return 0;
                     38:        }
                     39:        if (!sub(&pathsublist, 1, hdr.name, TNAMEMAX)) {
                     40:                ++nerr;
                     41:                fprintf(stderr, "tarf: can't expand '%s'\n", hdr.name);
                     42:                return 0;
                     43:        }
                     44:        if (hdr.typeflag == LNKTYPE || hdr.typeflag == SYMTYPE)
                     45:                sub(&pathsublist, 1, hdr.linkname, TLINKMAX);
                     46:        blocks = (hdr.size + TSIZE - 1) / TSIZE;
                     47:        if (tflag) {
                     48:                fprintf(ofp, "%s\n", hdr.name);
                     49:                if (hdr.typeflag == REGTYPE)
                     50:                        discard(ifp, blocks * TSIZE);
                     51:        } else {
                     52:                if (thdrput(&buf, &hdr) != 0) {
                     53:                        ++nerr;
                     54:                        fprintf(stderr, "tarf: error building output header\n");
                     55:                        return 0;
                     56:                }
                     57:                if (fwrite(&buf, sizeof buf, 1, ofp) != 1) {
                     58:                        ++nerr;
                     59:                        fprintf(stderr, "tarf: error writing output header\n");
                     60:                        return 0;
                     61:                }
                     62:                if (hdr.typeflag == REGTYPE)
                     63:                        if (fpcopy(ofp, ifp, blocks * TSIZE) != blocks * TSIZE) {
                     64:                                ++nerr;
                     65:                                fprintf(stderr, "tarf: error copying data\n");
                     66:                                return 0;
                     67:                        }
                     68:        }
                     69:        return 1;
                     70: }
                     71: 
                     72: void
                     73: usage(void)
                     74: {
                     75:        fprintf(stderr, "usage: tarf [-t] [-Dold=new ...]\n");
                     76:        exit(1);
                     77: }
                     78: 
                     79: int
                     80: main(int argc, char *argv[])
                     81: {
                     82:        int c;
                     83:        char *nstr;
                     84: 
                     85:        prog = argv[0];
                     86:        while ((c = getopt(argc, argv, "tD:")) != EOF)
                     87:                switch (c) {
                     88:                case 't':
                     89:                        ++tflag;
                     90:                        break;
                     91:                case 'D':
                     92:                        nstr = strchr(optarg, '=');
                     93:                        if (nstr) {
                     94:                                *nstr = '\0';
                     95:                                addsub(&pathsublist, optarg, nstr + 1);
                     96:                        } else
                     97:                                usage();
                     98:                        break;
                     99:                default:
                    100:                        usage();
                    101:                        break;
                    102:                }
                    103:        if (argc > 1 && optind != argc)
                    104:                usage();
                    105:        while (filter(stdin, stdout))
                    106:                ;
                    107:        if (ferror(stdin) || !feof(stdin))
                    108:                return 1;
                    109:        return nerr ? 1 : 0;
                    110: }

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