Return to 11strip.c CVS log

Up to [Research Unix] / researchv10dc / cmd / PDP11

Annotation of researchv10dc/cmd/PDP11/11strip.c, revision 1.1

1.1     ! root        1: #include "a.out.h"             /*god: using pdp11 a.out fmt */
        !             2: #include <signal.h>
        !             3: #include <sys/types.h>
        !             4: #include <sys/stat.h>
        !             5: 
        !             6: char   *tname;
        !             7: char   *mktemp();
        !             8: struct exec head;
        !             9: int    a_magic[] = {A_MAGIC1, A_MAGIC2, A_MAGIC3, A_MAGIC4, 0};
        !            10: int    status;
        !            11: int    tf;
        !            12: 
        !            13: main(argc, argv)
        !            14: char *argv[];
        !            15: {
        !            16:        register i;
        !            17: 
        !            18:        signal(SIGHUP, SIG_IGN);
        !            19:        signal(SIGINT, SIG_IGN);
        !            20:        signal(SIGQUIT, SIG_IGN);
        !            21:        tname = mktemp("/tmp/sXXXXX");
        !            22:        close(creat(tname, 0600));
        !            23:        tf = open(tname, 2);
        !            24:        if(tf < 0) {
        !            25:                printf("cannot create temp file\n");
        !            26:                exit(2);
        !            27:        }
        !            28:        if (argc == 1) {                /*god: default 11a.out */
        !            29:            argv[1] = A_DOT_OUT;        /*god*/
        !            30:            ++argc;                     /*god*/
        !            31:        }                               /*god*/
        !            32:        for(i=1; i<argc; i++) {
        !            33:                strip(argv[i]);
        !            34: /*god*/                /*if(status > 1)
        !            35:                        break;*/        /*god: no reason to abort*/
        !            36:        }
        !            37:        close(tf);
        !            38:        unlink(tname);
        !            39:        exit(status);
        !            40: }
        !            41: 
        !            42: strip(name)
        !            43: char *name;
        !            44: {
        !            45:        register f;
        !            46:        long size;
        !            47:        int i;
        !            48:        time_t tm[2];
        !            49:        struct stat stbuf;
        !            50: 
        !            51:        tm[0] = 0;
        !            52:        f = open(name, 0);
        !            53:        if(f < 0) {
        !            54:                printf("cannot open %s\n", name);
        !            55:                status = 1;
        !            56:                goto out;
        !            57:        }
        !            58:        fstat(f, &stbuf);
        !            59:        tm[0] = stbuf.st_atime;
        !            60:        tm[1] = stbuf.st_mtime;
        !            61:        read(f, (char *)&head, sizeof(head));
        !            62:        for(i=0;a_magic[i];i++)
        !            63:                if(a_magic[i] == head.a_magic) break;
        !            64:        if(a_magic[i] == 0) {
        !            65:                printf("%s not in 11a.out format\n", name);     /*god*/
        !            66:                status = 1;
        !            67:                goto out;
        !            68:        }
        !            69:        if(head.a_syms == 0 && (head.a_flag&1) != 0) {
        !            70:                printf("%s already stripped\n", name);
        !            71:                goto out;
        !            72:        }
        !            73:        size = (long)head.a_text + head.a_data;
        !            74:        head.a_syms = 0;
        !            75:        head.a_flag |= 1;
        !            76: 
        !            77:        lseek(tf, (long)0, 0);
        !            78:        write(tf, (char *)&head, sizeof(head));
        !            79:        if(copy(name, f, tf, size)) {
        !            80:                status = 1;
        !            81:                goto out;
        !            82:        }
        !            83:        size += sizeof(head);
        !            84:        close(f);
        !            85:        f = creat(name, 0666);
        !            86:        if(f < 0) {
        !            87:                printf("%s cannot recreate\n", name);
        !            88:                status = 1;
        !            89:                goto out;
        !            90:        }
        !            91:        lseek(tf, (long)0, 0);
        !            92:        if(copy(name, tf, f, size))
        !            93:                status = 2;
        !            94: 
        !            95: out:
        !            96:        close(f);
        !            97:        if (tm[0])
        !            98:                utime(name, tm);
        !            99: }
        !           100: 
        !           101: copy(name, fr, to, size)
        !           102: char *name;
        !           103: long size;
        !           104: {
        !           105:        register s, n;
        !           106:        char buf[512];
        !           107: 
        !           108:        while(size != 0) {
        !           109:                s = 512;
        !           110:                if(size < 512)
        !           111:                        s = size;
        !           112:                n = read(fr, buf, s);
        !           113:                if(n != s) {
        !           114:                        printf("%s unexpected eof\n", name);
        !           115:                        return(1);
        !           116:                }
        !           117:                n = write(to, buf, s);
        !           118:                if(n != s) {
        !           119:                        printf("%s unexpected write eof\n", name);
        !           120:                        return(1);
        !           121:                }
        !           122:                size -= s;
        !           123:        }
        !           124:        return(0);
        !           125: }

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