Return to arff.c CVS log

Up to [Research Unix] / researchv10no / cmd

Annotation of researchv10no/cmd/arff.c, revision 1.1

1.1     ! root        1: static char *sccsid = "@(#)arff.c      4.7 (Berkeley) 81/07/08";
        !             2: #include <sys/types.h>
        !             3: #include <sys/stat.h>
        !             4: #include <time.h>
        !             5: #include <signal.h>
        !             6: #include <stdio.h>
        !             7: #define dbprintf printf
        !             8: struct rt_dat {
        !             9: unsigned short int     rt_yr:5;        /* Year - 1972 */
        !            10: unsigned short int     rt_dy:5;        /* day */
        !            11: unsigned short int     rt_mo:5;        /* month */
        !            12: };
        !            13: struct rt_axent {
        !            14:        char    rt_sent[14];
        !            15: };
        !            16: 
        !            17: struct rt_ent {
        !            18:        char  rt_pad;                   /* unusued */
        !            19:        char  rt_stat;                  /* Type of entry, or end of seg */
        !            20:        unsigned short rt_name[3];      /* Name, 3 words in rad50 form */
        !            21:        short rt_len;                   /* Length of file */
        !            22:        char  rt_chan;                  /* Only used in temporary files */
        !            23:        char  rt_job;                   /* Only used in temporary files */
        !            24:        struct rt_dat rt_date;          /* Creation Date */
        !            25: };
        !            26: #define RT_TEMP 1
        !            27: #define RT_NULL 2
        !            28: #define RT_FILE 4
        !            29: #define RT_ESEG 8
        !            30: #define RT_BLOCK 512
        !            31: #define RT_DIRSIZE 31                  /* max # of directory segments */
        !            32: struct rt_head {
        !            33:        short   rt_numseg;              /* number of segments available */
        !            34:        short   rt_nxtseg;              /* segment no of next log. seg */
        !            35:        short   rt_lstseg;              /* highest seg currenltly open */
        !            36:        unsigned short  rt_entpad;      /* extra words/dir. entry      */
        !            37:        short   rt_stfile;              /* block no where files begin  */
        !            38: };
        !            39: struct rt_dir {
        !            40:        struct rt_head  rt_axhead;
        !            41:        struct rt_ent   rt_ents[72];
        !            42:        char    _dirpad[6];
        !            43: };
        !            44: extern struct rt_dir   rt_dir[RT_DIRSIZE];
        !            45: extern int             rt_entsiz;
        !            46: extern int             floppydes;
        !            47: extern char            *rt_last;
        !            48: typedef struct fldope {
        !            49:        int     startad;
        !            50:        int     count;
        !            51: struct rt_ent  *rtdope;
        !            52: } FLDOPE;
        !            53: #define        FL_BLOCK 128
        !            54: FLDOPE *lookup();
        !            55: #define rt(p) ((struct rt_ent *) p )
        !            56: #define Ain1 03100
        !            57: #define Ain2 050
        !            58: #define flag(c) (flg[(c) - 'a'])
        !            59: 
        !            60: char   *man    =       { "rxtd" };
        !            61: 
        !            62: char zeroes[512];
        !            63: extern char *val;
        !            64: extern char table[256];
        !            65: struct rt_dir  
        !            66:    rt_dir[RT_DIRSIZE] = {{{4,0,1,0,14},{0,RT_NULL,{0,0,0},494,0}, {0,RT_ESEG}}};
        !            67: int            rt_entsiz;
        !            68: int            rt_nleft;
        !            69: struct rt_ent  *rt_curend[RT_DIRSIZE];
        !            70: int            floppydes;
        !            71: int            dirdirty;
        !            72: char           *rt_last;
        !            73: char           *defdev = "/dev/floppy";
        !            74: 
        !            75: char   *opt    =       { "vf" };
        !            76: 
        !            77: int    signum[] = {SIGHUP, SIGINT, SIGQUIT, 0};
        !            78: long   lseek();
        !            79: int    rcmd();
        !            80: int    dcmd();
        !            81: int    xcmd();
        !            82: int    tcmd();
        !            83: int    (*comfun)();
        !            84: char   flg[26];
        !            85: char   **namv;
        !            86: int    namc;
        !            87: int    file;
        !            88: 
        !            89: 
        !            90: main(argc, argv)
        !            91: char *argv[];
        !            92: {
        !            93:        register char *cp;
        !            94: 
        !            95:        /* register i;
        !            96:        for(i=0; signum[i]; i++)
        !            97:                if(signal(signum[i], SIG_IGN) != SIG_IGN)
        !            98:                        signal(signum[i], sigdone); */
        !            99:        if(argc < 2)
        !           100:                usage();
        !           101:        cp = argv[1];
        !           102:        for(cp = argv[1]; *cp; cp++)
        !           103:        switch(*cp) {
        !           104:        case 'm':
        !           105:        case 'v':
        !           106:        case 'u':
        !           107:        case 'w':
        !           108:                flg[*cp - 'a']++;
        !           109:                continue;
        !           110:        case 'c':
        !           111:                {
        !           112: #define SURE   "Are you sure you want to clobber the floppy?\n"
        !           113:                        int tty;
        !           114:                        char response[128];
        !           115:                        tty = open("/dev/tty",2);
        !           116:                        write(tty,SURE,sizeof(SURE));
        !           117:                        read(tty,response,sizeof(response));
        !           118:                        if(*response!='y')
        !           119:                                exit(50);
        !           120:                        flag('c')++;
        !           121:                        close(tty);
        !           122:                }
        !           123:                dirdirty++;
        !           124:                continue;
        !           125: 
        !           126:        case 'r':
        !           127:                setcom(rcmd);
        !           128:                flag('r')++;
        !           129:                continue;
        !           130: 
        !           131:        case 'd':
        !           132:                setcom(dcmd);
        !           133:                flag('d')++;
        !           134:                continue;
        !           135: 
        !           136:        case 'x':
        !           137:                setcom(xcmd);
        !           138:                continue;
        !           139: 
        !           140:        case 't':
        !           141:                setcom(tcmd);
        !           142:                continue;
        !           143: 
        !           144:        case 'f':
        !           145:                defdev = argv[2];
        !           146:                argv++;
        !           147:                argc--;
        !           148:                continue;
        !           149: 
        !           150: 
        !           151:        default:
        !           152:                fprintf(stderr, "arff: bad option `%c'\n", *cp);
        !           153:                exit(1);
        !           154:        }
        !           155:        namv = argv+2;
        !           156:        namc = argc-2;
        !           157:        if(comfun == 0) {
        !           158:                if(flag('u') == 0) {
        !           159:                        fprintf(stderr, "arff: one of [%s] must be specified\n", man);
        !           160:                        exit(1);
        !           161:                }
        !           162:                setcom(rcmd);
        !           163:        }
        !           164:        (*comfun)();
        !           165:        exit(notfound());
        !           166: }
        !           167: 
        !           168: setcom(fun)
        !           169: int (*fun)();
        !           170: {
        !           171: 
        !           172:        if(comfun != 0) {
        !           173:                fprintf(stderr, "arff: only one of [%s] allowed\n", man);
        !           174:                exit(1);
        !           175:        }
        !           176:        comfun = fun;
        !           177: }
        !           178: 
        !           179: usage()
        !           180: {
        !           181: 
        !           182:        fprintf(stderr, "usage: arff [%s][%s] archive files ...\n", opt, man);
        !           183:        exit(1);
        !           184: }
        !           185: 
        !           186: notfound()
        !           187: {
        !           188:        register i, n;
        !           189: 
        !           190:        n = 0;
        !           191:        for(i=0; i<namc; i++)
        !           192:                if(namv[i]) {
        !           193:                        fprintf(stderr, "arff: %s not found\n", namv[i]);
        !           194:                        n++;
        !           195:                }
        !           196:        return(n);
        !           197: }
        !           198: 
        !           199: phserr()
        !           200: {
        !           201: 
        !           202:        fprintf(stderr, "arff: phase error on %s\n", file);
        !           203: }
        !           204: 
        !           205: mesg(c, name)
        !           206: char *name;
        !           207: {
        !           208: 
        !           209:        if(flag('v'))
        !           210:                if(c != 'c' || flag('v') > 1)
        !           211:                        printf("%c - %s\n", c, name);
        !           212: }
        !           213: 
        !           214: tcmd()
        !           215: {
        !           216:        register char *de;
        !           217:        int segnum;
        !           218:        register char *last;
        !           219:        FLDOPE *lookup(), *dope;
        !           220:        int nleft; register i;
        !           221:        register struct rt_ent *rde;
        !           222: 
        !           223:        rt_init();
        !           224:        if(namc==0)
        !           225:            for (segnum=0; segnum >= 0;    /* for all dir. segments */
        !           226:                 segnum = rt_dir[segnum].rt_axhead.rt_nxtseg - 1) {
        !           227:                last = rt_last + segnum*2*RT_BLOCK;
        !           228:                for(de=((char *)&rt_dir[segnum])+10; de <= last; 
        !           229:                    de += rt_entsiz) {
        !           230:                        if(rtls(rt(de))) {
        !           231:                                nleft = (last - de) / rt_entsiz;
        !           232:                                printf("\n%d entries remaining",nleft);
        !           233:                                printf(" in directory segment %d.\n",segnum+1);
        !           234:                                break;
        !           235:                        }
        !           236:                }
        !           237:            }
        !           238:        else
        !           239:                for(i = 0; i < namc; i++) {
        !           240:                        if(dope = lookup(namv[i])) {
        !           241:                                rde = dope->rtdope;
        !           242:                                rtls(rde);
        !           243:                                namv[i] = 0;
        !           244:                        }
        !           245:                }
        !           246: }
        !           247: 
        !           248: rtls(de)
        !           249: register struct rt_ent *de;
        !           250: {
        !           251:        int month,day,year;
        !           252:        char name[12], ext[4];
        !           253: 
        !           254:        if(flag('v'))
        !           255:                switch(de->rt_stat) {
        !           256:                case RT_TEMP:
        !           257:                        printf("Tempfile:\n");
        !           258:                case RT_FILE:
        !           259:                        unrad50(2,de->rt_name,name);
        !           260:                        unrad50(1,&(de->rt_name[2]),ext);
        !           261:                        day = de->rt_date.rt_dy;
        !           262:                        year = de->rt_date.rt_yr + 72;
        !           263:                        month = de->rt_date.rt_mo;
        !           264:                        printf("%6.6s  %3.3s    %02d/%02d/%02d  %d\n",name,
        !           265:                                ext,month,day,year,de->rt_len);
        !           266:                        break;
        !           267: 
        !           268:                case RT_NULL:
        !           269:                        printf("%-25.9s %d\n","<UNUSED>",de->rt_len);
        !           270:                        break;
        !           271: 
        !           272:                case RT_ESEG:
        !           273:                        return(1);
        !           274:                }
        !           275:        else {
        !           276:                switch(de->rt_stat) {
        !           277:                case RT_TEMP:
        !           278:                case RT_FILE:
        !           279:                        sunrad50(name,de->rt_name);
        !           280:                        printf(name);putchar('\n');
        !           281:                        break;
        !           282: 
        !           283:                case RT_ESEG:
        !           284:                        return(1);
        !           285: 
        !           286:                case RT_NULL:
        !           287:                        break;
        !           288:                }
        !           289:        }
        !           290:        return(0);
        !           291: }
        !           292: xcmd()
        !           293: {
        !           294:        register char *de;
        !           295:        int segnum;
        !           296:        register char *last;
        !           297:        char name[12];
        !           298:        register int i;
        !           299: 
        !           300:        rt_init();
        !           301:        if(namc==0)
        !           302:            for (segnum=0; segnum >= 0;    /* for all dir. segments */
        !           303:                 segnum = rt_dir[segnum].rt_axhead.rt_nxtseg - 1) {
        !           304:                last = rt_last + segnum*2*RT_BLOCK;
        !           305:                for(de=((char *)&rt_dir[segnum])+10; de <= last; 
        !           306:                    de += rt_entsiz) {
        !           307:                        sunrad50(name,rt(de)->rt_name);
        !           308:                        rtx(name);
        !           309:                }
        !           310:            }
        !           311:        else
        !           312:                for(i = 0; i < namc; i++)
        !           313:                if(rtx(namv[i])==0) namv[i] = 0;
        !           314: }
        !           315: rtx(name)
        !           316: char *name;
        !           317: {
        !           318:        register FLDOPE *dope;
        !           319:        FLDOPE *lookup();
        !           320:        register startad, count;
        !           321:        int file; char buff[RT_BLOCK];
        !           322: 
        !           323: 
        !           324:        if(dope = lookup(name)) {
        !           325:                mesg('x', name);
        !           326:                file = creat(name, 0666);
        !           327:                if(file < 0) return(1);
        !           328:                count = dope->count;
        !           329:                startad = dope->startad;
        !           330:                for( ; count > 0 ; count -= RT_BLOCK) {
        !           331:                        lread(startad,RT_BLOCK,buff);
        !           332:                        write(file,buff,RT_BLOCK);
        !           333:                        startad += RT_BLOCK;
        !           334:                }
        !           335:                close(file);
        !           336:                return(0);
        !           337:        }
        !           338:        return(1);
        !           339: }
        !           340: rt_init()
        !           341: {
        !           342:        static initized = 0;
        !           343:        register char *de;
        !           344:        register i;
        !           345:        int dirnum;
        !           346:        char *mode;
        !           347:        register char *last;
        !           348:        FILE *temp_floppydes;
        !           349: 
        !           350:        if(initized) return;
        !           351:        initized = 1;
        !           352:        if(flag('c') || flag('d') || flag('r'))
        !           353:                mode = "r+";
        !           354:        else
        !           355:                mode = "r";
        !           356:        if((temp_floppydes = fopen(defdev, mode)) == NULL) {
        !           357:                perror(defdev);
        !           358:                exit(1);
        !           359:        }
        !           360:        floppydes = fileno(temp_floppydes);
        !           361:        if(flag('c')==0) {
        !           362:                lread(6*RT_BLOCK,2*RT_BLOCK,(char *)&rt_dir[0]);
        !           363:                dirnum = rt_dir[0].rt_axhead.rt_numseg;
        !           364:                if (dirnum > RT_DIRSIZE) {
        !           365:                   fprintf(stderr,"arff: too many directory segments\n");
        !           366:                   exit(1);
        !           367:                }
        !           368:                for (i=1; i<dirnum; i++)
        !           369:                   lread((6+2*i)*RT_BLOCK,2*RT_BLOCK,(char *)&rt_dir[i]);
        !           370:        } else
        !           371:                dirnum = 1;
        !           372: 
        !           373:        rt_entsiz = 2*rt_dir[0].rt_axhead.rt_entpad + 14;
        !           374:        rt_entsiz = 14;                 /* assume rt_entpad = 0 ??? */
        !           375:        rt_last = ((char *) &rt_dir[0]) + 10 + 1014/rt_entsiz*rt_entsiz; 
        !           376:        rt_nleft = 0;
        !           377:        
        !           378:        for (i=0; i<dirnum; i++) {
        !           379:            if (rt_dir[i].rt_axhead.rt_nxtseg >= RT_DIRSIZE
        !           380:            ||  rt_dir[i].rt_axhead.rt_lstseg >= RT_DIRSIZE) {
        !           381:                fprintf(stderr, "arff: awful directory linkage\n");
        !           382:                exit(1);
        !           383:            }
        !           384:            last = rt_last + i*2*RT_BLOCK;
        !           385:            for(de=((char *)&rt_dir[i])+10; de <= last; de += rt_entsiz) {
        !           386:                if(rt(de)->rt_stat==RT_ESEG) break;
        !           387:            }
        !           388:            rt_curend[i] = rt(de);
        !           389:            rt_nleft += (last - de) / rt_entsiz;
        !           390:        }
        !           391: }
        !           392: 
        !           393: static FLDOPE result;
        !           394: FLDOPE *
        !           395: lookup(name)
        !           396: char * name;
        !           397: {
        !           398:        unsigned short rname[3];
        !           399:        register char *de;
        !           400:        int segnum;
        !           401:        register char *last;
        !           402:        register index;
        !           403: 
        !           404:        srad50(name,rname);
        !           405: 
        !           406:        /* 
        !           407:         *  Search for name, accumulate blocks in index
        !           408:         */
        !           409:        rt_init();
        !           410:        for (segnum=0; segnum >= 0;    /* for all dir. segments */
        !           411:              segnum = rt_dir[segnum].rt_axhead.rt_nxtseg - 1) {
        !           412:            index = 0;
        !           413:            last = rt_last + segnum*2*RT_BLOCK;
        !           414:            for(de=((char *)&rt_dir[segnum])+10; 
        !           415:                rt(de)->rt_stat != RT_ESEG; de += rt_entsiz) {
        !           416:                switch(rt(de)->rt_stat) {
        !           417:                case RT_FILE:
        !           418:                case RT_TEMP:
        !           419:                if(samename(rname,rt(de)->rt_name))
        !           420:                        goto found;
        !           421:                case RT_NULL:
        !           422:                        index += rt(de)->rt_len;
        !           423:                }
        !           424:            }
        !           425:         }
        !           426:        return((FLDOPE *) 0);
        !           427: found: result.count = rt(de)->rt_len * RT_BLOCK;
        !           428:        result.startad = RT_BLOCK * (rt_dir[segnum].rt_axhead.rt_stfile + index);
        !           429:        result.rtdope = (struct rt_ent *) de;
        !           430:        return(&result);
        !           431: }
        !           432: static
        !           433: samename(a,b)
        !           434: unsigned short a[3],b[3];
        !           435: {
        !           436:        return( a[0]==b[0] && a[1]==b[1] && a[2]==b[2] );
        !           437: }
        !           438: 
        !           439: 
        !           440: rad50(cp,out)
        !           441: register unsigned char *cp;
        !           442: unsigned short *out;
        !           443: {
        !           444:        register index;
        !           445:        register temp;
        !           446: 
        !           447:        for(index = 0;*cp; index++) {
        !           448: 
        !           449:                temp = Ain1 * table[*cp++];
        !           450:                if(*cp!=0) {
        !           451:                        temp += Ain2 * table[*cp++];
        !           452: 
        !           453:                        if(*cp!=0) 
        !           454:                                temp += table[*cp++];
        !           455:                }
        !           456: 
        !           457:                out[index] = temp;
        !           458:        }
        !           459: }
        !           460: #define reduce(x,p,q) \
        !           461:        (x = v[p/q], p %= q);
        !           462: 
        !           463: unrad50(count,in,cp)
        !           464: unsigned short *in;
        !           465: register char *cp;
        !           466: {
        !           467:        register i, temp; register unsigned char *v = (unsigned char *) val;
        !           468:        
        !           469:        for(i = 0; i < count; i++) {
        !           470:                temp = in[i];
        !           471: 
        !           472:                reduce (*cp++,temp,Ain1);
        !           473:                reduce (*cp++,temp,Ain2);
        !           474:                reduce (*cp++,temp,1);
        !           475:        }
        !           476:        *cp=0;
        !           477: }
        !           478: 
        !           479: srad50(name,rname)
        !           480: register char * name;
        !           481: register unsigned short *rname;
        !           482: {
        !           483:        register index; register char *cp;
        !           484:        char file[7],ext[4];
        !           485:        /* 
        !           486:         * Find end of pathname
        !           487:         */
        !           488:        for(cp = name; *cp++; );
        !           489:        while(cp >= name && *--cp != '/');
        !           490:        cp++;
        !           491:        /* 
        !           492:         * Change to rad50
        !           493:         *
        !           494:         */
        !           495:        for(index = 0; *cp; ){
        !           496:                file[index++] = *cp++;
        !           497:                if(*cp=='.') {
        !           498:                        cp++;
        !           499:                        break;
        !           500:                }
        !           501:                if(index>=6) {
        !           502:                        break;
        !           503:                }
        !           504:        }
        !           505:        file[index] = 0;
        !           506:        for(index = 0; *cp; ){
        !           507:                ext[index++] = *cp++;
        !           508:                if(*cp=='.' || index>=3) {
        !           509:                        break;
        !           510:                }
        !           511:        }
        !           512:        ext[index]=0;
        !           513:        rname[0] = 0;
        !           514:        rname[1] = 0;
        !           515:        rname[2] = 0;
        !           516:        rad50((unsigned char *)file,rname);
        !           517:        rad50((unsigned char *)ext,rname+2);
        !           518: }
        !           519: sunrad50(name,rname)
        !           520: unsigned short rname[3];
        !           521: register char *name;
        !           522: {
        !           523:        register char *cp, *cp2;
        !           524:        char ext[4];
        !           525: 
        !           526:        unrad50(2,rname,name);
        !           527:        unrad50(1,rname + 2,ext);
        !           528:        /* Jam name and extension together with a dot
        !           529:           deleting white space */
        !           530:        for(cp = name; *cp++;);--cp;  while(*--cp==' ' && cp>=name);
        !           531:        *++cp = '.';cp++;
        !           532:        for(cp2=ext; *cp2!=' ' && cp2 < ext + 3;) {
        !           533:                *cp++ = *cp2++;
        !           534:        }
        !           535:        *cp=0;
        !           536:        if(cp[-1]=='.') cp[-1] = 0;
        !           537: }
        !           538: 
        !           539: static char *oval = " ABCDEFGHIJKLMNOPQRSTUVWXYZ$.@0123456789";
        !           540: static char *val = " abcdefghijklmnopqrstuvwxyz$.@0123456789";
        !           541: static char table[256] = {
        !           542: 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 
        !           543: 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 
        !           544: 0, 29, 29, 29, 27, 29, 29, 29, 29, 29, 29, 29, 29, 29, 28, 29, 
        !           545: 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 29, 29, 29, 29, 29, 29, 
        !           546: 29, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 
        !           547: 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 29, 29, 29, 29, 29, 
        !           548: 29, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 
        !           549: 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 29, 29, 29, 29, 29, 
        !           550: 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 
        !           551: 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 
        !           552: 0, 29, 29, 29, 27, 29, 29, 29, 29, 29, 29, 29, 29, 29, 28, 29, 
        !           553: 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 29, 29, 29, 29, 29, 29, 
        !           554: 29, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 
        !           555: 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 29, 29, 29, 29, 29, 
        !           556: 29, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 
        !           557: 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 29, 29, 29, 29 };
        !           558:                
        !           559: long
        !           560: trans(logical)
        !           561: register int logical;
        !           562: {
        !           563:        /*  Logical to physical adress translation */
        !           564:        register int sector, bytes, track;
        !           565: 
        !           566:        logical += 26 * 128;
        !           567:        bytes = (logical & 127);
        !           568:        logical >>= 7;
        !           569:        sector = logical % 26;
        !           570:        if(sector >= 13)
        !           571:                sector = sector *2 +1;
        !           572:        else
        !           573:                sector *= 2;
        !           574:        sector += 26 + ((track = (logical / 26)) - 1) * 6;
        !           575:        sector %= 26;
        !           576:        return( (((track *26) + sector) << 7) + bytes);
        !           577: }
        !           578: lread(startad,count,obuff)
        !           579: register startad, count;
        !           580: register char * obuff;
        !           581: {
        !           582:        long trans();
        !           583:        extern floppydes;
        !           584:        int chunk;
        !           585: 
        !           586:        rt_init();
        !           587:        if(flag('m')==0)
        !           588:                chunk = FL_BLOCK;
        !           589:        else
        !           590:                chunk = RT_BLOCK;
        !           591:        for (; count > 0; count -= chunk, obuff += chunk, startad += chunk) {
        !           592:                lseek(floppydes,
        !           593:                    (long) (flag('m') ? startad : trans(startad)), 0);
        !           594:                if (read(floppydes, obuff, chunk) != chunk)
        !           595:                        fprintf(stderr, "arff: read error, block %d\n", startad / RT_BLOCK);
        !           596:        }
        !           597: }
        !           598: 
        !           599: lwrite(startad,count,obuff)
        !           600: register startad, count;
        !           601: register char * obuff;
        !           602: {
        !           603:        long trans();
        !           604:        extern floppydes;
        !           605:        int chunk;
        !           606: 
        !           607:        rt_init();
        !           608:        if(flag('m')==0)
        !           609:                chunk = FL_BLOCK;
        !           610:        else
        !           611:                chunk = RT_BLOCK;
        !           612:        for (; count > 0; count -= chunk, obuff += chunk, startad += chunk) {
        !           613:                lseek(floppydes,
        !           614:                    (long) (flag('m') ? startad : trans(startad)), 0);
        !           615:                if (write(floppydes, obuff, chunk) != chunk)
        !           616:                        fprintf(stderr, "arff: write error, block %d\n", startad / RT_BLOCK);
        !           617:        }
        !           618: }
        !           619: 
        !           620: rcmd()
        !           621: {
        !           622:        register int i;
        !           623: 
        !           624:        rt_init();
        !           625:        if (namc>0)
        !           626:                for(i = 0; i < namc; i++)
        !           627:                        if(rtr(namv[i])==0) namv[i]=0;
        !           628: }
        !           629: 
        !           630: rtr(name)
        !           631: char *name;
        !           632: {
        !           633:        register FLDOPE *dope;
        !           634:        struct stat buf;
        !           635:        FLDOPE *flcreat();
        !           636: 
        !           637:        if(stat(name,&buf)<0) {
        !           638:                perror(name);
        !           639:                return (-1);
        !           640:        }
        !           641:        if ((dope = flcreat(name, buf.st_size, buf.st_mtime)) == NULL)
        !           642:                return (-1);
        !           643:        mesg('r', name);
        !           644:        toflop(name, buf.st_size, dope);
        !           645:        return (0);
        !           646: }
        !           647: 
        !           648: FLDOPE *
        !           649: flcreat(name, size, mtime)
        !           650: char *name;
        !           651: long size;
        !           652: time_t mtime;
        !           653: {
        !           654:        register FLDOPE *dope;
        !           655:        register struct rt_ent *de;
        !           656:        int segnum;
        !           657: 
        !           658:        if ((dope = lookup(name)) != NULL
        !           659:        &&  size <= dope->rtdope->rt_len * RT_BLOCK)
        !           660:                return (dope);
        !           661:        for (segnum=0; segnum != -1; segnum = rt_dir[segnum].rt_axhead.rt_nxtseg - 1) {
        !           662:                for(de = rt_dir[segnum].rt_ents; de->rt_stat != RT_ESEG; de++)
        !           663:                        if (de->rt_stat == RT_NULL
        !           664:                        &&  size <= de->rt_len * RT_BLOCK) {
        !           665:                                if (dope)
        !           666:                                        delete(dope);
        !           667:                                mkent(de, segnum, size, name, mtime);
        !           668:                                goto found;
        !           669:                        }
        !           670:        }
        !           671:        printf("%s: no slot or no space for file\n", name);
        !           672:        return (NULL);
        !           673: found:
        !           674:        if (dope = lookup(name))
        !           675:                return (dope);
        !           676:        fprintf(stderr, "%s: internal error, added then not found\n", name);
        !           677:        return (NULL);
        !           678: }
        !           679: 
        !           680: mkent(de,segnum,size,name,mtime)
        !           681: register struct rt_ent *de;
        !           682: int segnum;
        !           683: long size;
        !           684: char *name;
        !           685: time_t mtime;
        !           686: {
        !           687:        struct tm *localtime(); register struct tm *timp;
        !           688:        register struct rt_ent *workp; int count;
        !           689:        
        !           690:        count = (((size - 1)/RT_BLOCK) + 1);
        !           691:                                                /* Make sure there is room */
        !           692:        if(de->rt_len==count)
        !           693:                goto overwrite;
        !           694:        if(rt_curend[segnum] == (rt_last + (segnum*2*RT_BLOCK))) {
        !           695:                                                /* no entries left on segment */
        !           696:                if(flag('o'))
        !           697:                        goto overwrite;
        !           698:                fprintf(stderr,"Directory segment #%d full on  %s\n",segnum+1,
        !           699:                     defdev);
        !           700:                exit(1);
        !           701:        }       
        !           702:                                        /* copy directory entries up */
        !           703:        for(workp = rt_curend[segnum]+1; workp > de; workp--)
        !           704:                *workp = workp[-1];
        !           705:        de[1].rt_len -= count;
        !           706:        de->rt_len = count;
        !           707:        rt_curend[segnum]++;
        !           708:        rt_nleft--;
        !           709: overwrite:
        !           710:        srad50(name,de->rt_name);
        !           711:        timp = localtime(&mtime);
        !           712:        de->rt_date.rt_dy = timp->tm_mday + 1;
        !           713:        de->rt_date.rt_mo = timp->tm_mon + 1;
        !           714:        de->rt_date.rt_yr = timp->tm_year - 72;
        !           715:        de->rt_stat = RT_FILE;
        !           716:        de->rt_pad = 0;
        !           717:        de->rt_chan = 0;
        !           718:        de->rt_job = 0;
        !           719:        lwrite((6+segnum*2)*RT_BLOCK,2*RT_BLOCK,(char *)&rt_dir[segnum]);
        !           720: }
        !           721: 
        !           722: toflop(name,ocount,dope)
        !           723: char *name;
        !           724: register FLDOPE *dope;
        !           725: long ocount;
        !           726: {
        !           727:        register file, n, startad = dope->startad, count = ocount;
        !           728:        char buff[RT_BLOCK];
        !           729:        
        !           730:        file = open(name,0);
        !           731:        if(file < 0) {
        !           732:                fprintf(stderr, "arff: couldn't open %s\n",name);exit(1);}
        !           733:        for( ; count >= RT_BLOCK; count -= RT_BLOCK) {
        !           734:                read(file,buff,RT_BLOCK);
        !           735:                lwrite(startad,RT_BLOCK,buff);
        !           736:                startad += RT_BLOCK;
        !           737:        }
        !           738:        read(file,buff,count);
        !           739:        close(file);
        !           740:        if(count <= 0) return;
        !           741:        for(n = count; n < RT_BLOCK; n ++) buff[n] = 0;
        !           742:        lwrite(startad,RT_BLOCK,buff);
        !           743:        count = (dope->rtdope->rt_len * RT_BLOCK - ocount) / RT_BLOCK ;
        !           744:        if(count <= 0) return;
        !           745:        for( ; count > 0 ; count--) {
        !           746:                startad += RT_BLOCK;
        !           747:                lwrite(startad,RT_BLOCK,zeroes);
        !           748:        }
        !           749: }
        !           750: dcmd()
        !           751: {
        !           752:        register int i;
        !           753: 
        !           754:        rt_init();
        !           755:        if(namc)
        !           756:                for(i = 0; i < namc; i++)
        !           757:                        if(rtk(namv[i])==0) namv[i]=0;
        !           758:        if(dirdirty)
        !           759:                scrunch();
        !           760:        
        !           761: }
        !           762: rtk(name)
        !           763: char *name;
        !           764: {
        !           765:        FLDOPE *dope;
        !           766:        register struct rt_ent *de;
        !           767:        FLDOPE *lookup();
        !           768: 
        !           769:        if(dope = lookup(name)) {
        !           770:                mesg('d', name);
        !           771:                delete(dope);
        !           772:                return(0);
        !           773:        }
        !           774:        return(1);
        !           775: }
        !           776: 
        !           777: delete(dope)
        !           778: FLDOPE *dope;
        !           779: {
        !           780:        register struct rt_ent *de;
        !           781: 
        !           782:        de = dope->rtdope;
        !           783:        de->rt_stat = RT_NULL;
        !           784:        de->rt_name[0] = 0;
        !           785:        de->rt_name[1] = 0;
        !           786:        de->rt_name[2] = 0;
        !           787:        * ((unsigned short *) & (de->rt_date)) = 0;
        !           788:        dirdirty = 1;
        !           789: }
        !           790: 
        !           791: scrunch() {
        !           792:        register struct rt_ent *de , *workp;
        !           793:        register segnum;
        !           794:        for (segnum=0; segnum != -1;    /* for all dir. segments */
        !           795:             segnum = rt_dir[segnum].rt_axhead.rt_nxtseg - 1) {
        !           796:            dirdirty = 0;
        !           797:            for(de = rt_dir[segnum].rt_ents; de <= rt_curend[segnum]; de++) {
        !           798:                if(de->rt_stat==RT_NULL && de[1].rt_stat==RT_NULL) {
        !           799:                        (de+1)->rt_len += de->rt_len;
        !           800:                        for(workp = de; workp < rt_curend[segnum]; workp++)
        !           801:                                *workp = workp[1];
        !           802:                        de--;
        !           803:                        rt_curend[segnum]--;
        !           804:                        rt_nleft++;
        !           805:                        dirdirty = 1;
        !           806:                }
        !           807:            }
        !           808:            if (dirdirty)
        !           809:            lwrite((6+segnum*2)*RT_BLOCK,2*RT_BLOCK,(char *)&rt_dir[segnum]);
        !           810:        }
        !           811: }

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