Return to cp.c CVS log

Up to [CSRG BSD Unix] / 42BSD / bin

Annotation of 42BSD/bin/cp.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char *sccsid = "@(#)cp.c        4.8 83/07/01";
        !             3: #endif
        !             4: 
        !             5: /*
        !             6:  * cp
        !             7:  */
        !             8: #include <stdio.h>
        !             9: #include <sys/param.h>
        !            10: #include <sys/stat.h>
        !            11: #include <sys/dir.h>
        !            12: 
        !            13: #define        BSIZE   8192
        !            14: 
        !            15: int    iflag;
        !            16: int    rflag;
        !            17: char   *rindex(), *sprintf();
        !            18: 
        !            19: main(argc, argv)
        !            20:        int argc;
        !            21:        char **argv;
        !            22: {
        !            23:        struct stat stb;
        !            24:        int rc, i;
        !            25: 
        !            26:        argc--, argv++;
        !            27:        while (argc > 0 && **argv == '-') {
        !            28:                (*argv)++;
        !            29:                while (**argv) switch (*(*argv)++) {
        !            30: 
        !            31:                case 'i':
        !            32:                        iflag++; break;
        !            33: 
        !            34:                case 'r':
        !            35:                        rflag++; break;
        !            36: 
        !            37:                default:
        !            38:                        goto usage;
        !            39:                }
        !            40:                argc--; argv++;
        !            41:        }
        !            42:        if (argc < 2) 
        !            43:                goto usage;
        !            44:        if (argc > 2 || rflag) {
        !            45:                if (stat(argv[argc-1], &stb) < 0)
        !            46:                        goto usage;
        !            47:                if ((stb.st_mode&S_IFMT) != S_IFDIR) 
        !            48:                        goto usage;
        !            49:        }
        !            50:        rc = 0;
        !            51:        for (i = 0; i < argc-1; i++)
        !            52:                rc |= copy(argv[i], argv[argc-1]);
        !            53:        exit(rc);
        !            54: usage:
        !            55:        fprintf(stderr,
        !            56:            "Usage: cp f1 f2; or cp [ -r ] f1 ... fn d2\n");
        !            57:        exit(1);
        !            58: }
        !            59: 
        !            60: copy(from, to)
        !            61:        char *from, *to;
        !            62: {
        !            63:        int fold, fnew, n;
        !            64:        char *last, destname[BSIZE], buf[BSIZE];
        !            65:        struct stat stfrom, stto;
        !            66: 
        !            67:        fold = open(from, 0);
        !            68:        if (fold < 0) {
        !            69:                Perror(from);
        !            70:                return (1);
        !            71:        }
        !            72:        if (fstat(fold, &stfrom) < 0) {
        !            73:                Perror(from);
        !            74:                (void) close(fold);
        !            75:                return (1);
        !            76:        }
        !            77:        if (stat(to, &stto) >= 0 &&
        !            78:           (stto.st_mode&S_IFMT) == S_IFDIR) {
        !            79:                last = rindex(from, '/');
        !            80:                if (last) last++; else last = from;
        !            81:                if (strlen(to) + strlen(last) >= BSIZE - 1) {
        !            82:                        fprintf(stderr, "cp: %s/%s: Name too long", to, last);
        !            83:                        (void) close(fold);
        !            84:                        return(1);
        !            85:                }
        !            86:                (void) sprintf(destname, "%s/%s", to, last);
        !            87:                to = destname;
        !            88:        }
        !            89:        if (rflag && (stfrom.st_mode&S_IFMT) == S_IFDIR) {
        !            90:                (void) close(fold);
        !            91:                if (stat(to, &stto) < 0) {
        !            92:                        if (mkdir(to, (int)stfrom.st_mode) < 0) {
        !            93:                                Perror(to);
        !            94:                                return (1);
        !            95:                        }
        !            96:                } else if ((stto.st_mode&S_IFMT) != S_IFDIR) {
        !            97:                        fprintf(stderr, "cp: %s: Not a directory.\n", to);
        !            98:                        return (1);
        !            99:                }
        !           100:                return (rcopy(from, to));
        !           101:        }
        !           102:        if (stat(to, &stto) >= 0) {
        !           103:                if (stfrom.st_dev == stto.st_dev &&
        !           104:                   stfrom.st_ino == stto.st_ino) {
        !           105:                        fprintf(stderr, "cp: Cannot copy file to itself.\n");
        !           106:                        (void) close(fold);
        !           107:                        return (1);
        !           108:                }
        !           109:                if (iflag) {
        !           110:                        int i, c;
        !           111: 
        !           112:                        fprintf (stderr, "overwrite %s? ", to);
        !           113:                        i = c = getchar();
        !           114:                        while (c != '\n' && c != EOF)
        !           115:                                c = getchar();
        !           116:                        if (i != 'y') {
        !           117:                                (void) close(fold);
        !           118:                                return(1);
        !           119:                        }
        !           120:                }
        !           121:        }
        !           122:        fnew = creat(to, (int)stfrom.st_mode);
        !           123:        if (fnew < 0) {
        !           124:                Perror(to);
        !           125:                (void) close(fold); return(1);
        !           126:        }
        !           127:        for (;;) {
        !           128:                n = read(fold, buf, BSIZE);
        !           129:                if (n == 0)
        !           130:                        break;
        !           131:                if (n < 0) {
        !           132:                        Perror(from);
        !           133:                        (void) close(fold); (void) close(fnew); return (1);
        !           134:                }
        !           135:                if (write(fnew, buf, n) != n) {
        !           136:                        Perror(to);
        !           137:                        (void) close(fold); (void) close(fnew); return (1);
        !           138:                }
        !           139:        }
        !           140:        (void) close(fold); (void) close(fnew); return (0);
        !           141: }
        !           142: 
        !           143: rcopy(from, to)
        !           144:        char *from, *to;
        !           145: {
        !           146:        DIR *fold = opendir(from);
        !           147:        struct direct *dp;
        !           148:        int errs = 0;
        !           149:        char fromname[BUFSIZ];
        !           150: 
        !           151:        if (fold == 0) {
        !           152:                Perror(from);
        !           153:                return (1);
        !           154:        }
        !           155:        for (;;) {
        !           156:                dp = readdir(fold);
        !           157:                if (dp == 0) {
        !           158:                        closedir(fold);
        !           159:                        return (errs);
        !           160:                }
        !           161:                if (dp->d_ino == 0)
        !           162:                        continue;
        !           163:                if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
        !           164:                        continue;
        !           165:                if (strlen(from) + 1 + strlen(dp->d_name) >= BUFSIZ - 1) {
        !           166:                        fprintf(stderr, "cp: %s/%s: Name too long.\n",
        !           167:                            from, dp->d_name);
        !           168:                        errs++;
        !           169:                        continue;
        !           170:                }
        !           171:                (void) sprintf(fromname, "%s/%s", from, dp->d_name);
        !           172:                errs += copy(fromname, to);
        !           173:        }
        !           174: }
        !           175: 
        !           176: Perror(s)
        !           177:        char *s;
        !           178: {
        !           179: 
        !           180:        fprintf(stderr, "cp: ");
        !           181:        perror(s);
        !           182: }

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