Return to flink.c CVS log

Up to [Research Unix] / researchv10no / cmd / worm

Annotation of researchv10no/cmd/worm/flink.c, revision 1.1.1.1

1.1       root        1: #include       <libc.h>
                      2: #include       "worm.h"
                      3: 
                      4: static Inode *inodebase;
                      5: static char *namebase;
                      6: static long nnames, ninodes;
                      7: static char *expanded;
                      8: static readinodes;
                      9: static ifd;
                     10: 
                     11: static Inode *diskinode();
                     12: 
                     13: static Inode *
                     14: finode(s)
                     15:        char *s;
                     16: {
                     17:        register lo, hi, m;
                     18:        register Inode *i;
                     19: 
                     20:        if(readinodes == 0)
                     21:                return(diskinode(s));
                     22: #define        EXPAND(in)      (i = inodebase+(in), expanded[in]?0:(i->name.n=i->name.o+namebase, expanded[in]=1))
                     23: #define        CMP(str, in)    (EXPAND(in), strcmp(str, i->name.n))
                     24: 
                     25:        if(CMP(s, lo = 0) < 0)
                     26:                return(0);
                     27:        if(CMP(s, (hi = ninodes)-1) > 0)
                     28:                return(0);
                     29:        while(lo < hi-1){
                     30:                m = (lo+hi)/2;
                     31:                if(CMP(s, m) < 0)
                     32:                        hi = m;
                     33:                else
                     34:                        lo = m;
                     35:        }
                     36:        if(CMP(s, lo) == 0)
                     37:                return(inodebase+lo);
                     38:        else
                     39:                return(0);
                     40: }
                     41: 
                     42: static void
                     43: ftraverse(fn)
                     44:        void (*fn)();
                     45: {
                     46:        register Inode *i;
                     47:        register n;
                     48: 
                     49:        if(readinodes == 0){
                     50:                readinodes = 1;
                     51:                lseek(ifd, 8L, 0);
                     52:                read(ifd, (char *)inodebase, (int)ninodes*sizeof(Inode));
                     53:        }
                     54:        for(n = 0; n < ninodes; n++){
                     55:                EXPAND(n);
                     56:                (*fn)(i);
                     57:        }
                     58: }
                     59: 
                     60: fastlink(s, msg, ifn, tfn)
                     61:        Superblock *s;
                     62:        char **msg;
                     63:        Inode *(**ifn)();
                     64:        void (**tfn)();
                     65: {
                     66:        int n;
                     67:        long t;
                     68:        static char buf[256];
                     69: 
                     70:        *msg = 0;
                     71:        *ifn = finode;
                     72:        *tfn = ftraverse;
                     73:        sprint(buf, "/usr/worm/tmp/%s", s->vol_id);
                     74:        if((ifd = open(buf, 0)) < 0)
                     75:                return(0);
                     76:        read(ifd, (char *)&t, 4);
                     77:        if(t != s->ctime)
                     78:                return(0);
                     79:        read(ifd, (char *)&ninodes, 4);
                     80:        inodebase = (Inode *)malloc(n = ninodes*sizeof(Inode));
                     81:        expanded = malloc((int)ninodes);
                     82:        memset(expanded, 0, (int)ninodes);
                     83:        lseek(ifd, (long)n, 1);
                     84:        readinodes = 0;
                     85:        read(ifd, (char *)&nnames, 4);
                     86:        namebase = malloc((int)nnames);
                     87:        read(ifd, namebase, (int)nnames);
                     88:        numinodes = ninodes;
                     89:        numnamechars = nnames;
                     90:        return(1);
                     91: }
                     92: 
                     93: static
                     94: readi(ino, ip)
                     95:        Inode *ip;
                     96: {
                     97:        static myino = -1;
                     98:        static Inode myi;
                     99: 
                    100:        if(ino != myino){
                    101:                myino = ino;
                    102:                lseek(ifd, 8L+myino*sizeof(Inode), 0);
                    103:                read(ifd, (char *)&myi, sizeof myi);
                    104:                myi.name.n = myi.name.o+namebase;
                    105:        }
                    106:        *ip = myi;
                    107: }
                    108: 
                    109: static Inode *
                    110: diskinode(s)
                    111:        char *s;
                    112: {
                    113:        register lo, hi, m;
                    114:        static Inode ii;
                    115:        register Inode *i = &ii;
                    116: 
                    117: #define READ(in)       readi(in, i)
                    118: #undef CMP
                    119: #define        CMP(str, in)    (READ(in), strcmp(str, i->name.n))
                    120: 
                    121:        if(ninodes <= 0)
                    122:                return(0);
                    123:        if(CMP(s, lo = 0) < 0)
                    124:                return(0);
                    125:        if(CMP(s, (hi = ninodes)-1) > 0)
                    126:                return(0);
                    127:        while(lo < hi-1){
                    128:                m = (lo+hi)/2;
                    129:                if(CMP(s, m) < 0)
                    130:                        hi = m;
                    131:                else
                    132:                        lo = m;
                    133:        }
                    134:        if(CMP(s, lo) == 0)
                    135:                return(i);
                    136:        else
                    137:                return(0);
                    138: }

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