# 2.11BSD#431 - /usr/src/bin/tp/tp3.c

##### Functions

    bitmap            X
    delete            X
    extract           X
    gettape           X
    maperr            X
    phserr            X
    setmap            X
    taboc             X
    update            X
    update1           X
    usage             X

       1: #ifndef lint
       2: static char sccsid[] = "@(#)tp3.c	4.1 12/18/82";
       3: #endif
       4:
       5: #include "tp.h"
       6:
       7: gettape(how)
       8: int (*how)();
       9: {
      10:     register char *ptr0, *ptr1;
      11:     register struct dent *d;
      12:     int count;
      13:
      14:     do {
      15:         d = &dir[0];
      16:         count = 0;
      17:         do {
      18:             if (d->d_namep == 0)  continue;
      19:             decode(name,d);
      20:             if (rnarg > 2) {
      21:                 ptr0 = name;
      22:                 ptr1 = *parg;
      23:                 while (*ptr1)
      24:                     if (*ptr0++ != *ptr1++)  goto cont;
      25:                 if (*ptr0 && *ptr0 != '/')       goto cont;
      26:             }
      27:             (*how)(d);  /* delete, extract, or taboc */
      28:             ++count;
      29: cont:           continue;
      30:         }  while (++d <= lastd);
      31:         if (count == 0 && rnarg > 2)
      32:             printf("%s  not found\n", *parg);
      33:         ++parg;
      34:     } while (--narg > 2);
      35: }
      36:
      37: delete(dd)
      38: struct dent *dd;
      39: {
      40:     if (verify('d') >= 0)
      41:         clrent(dd);
      42: }
      43:
      44:
      45: update()
      46: {
      47:     register struct dent *d;
      48:     register b, last;
      49:     int first, size;
      50:
      51:
      52:     bitmap();
      53:     d = &dir[0];
      54:     do {
      55:         if(d->d_namep == 0 || (d->d_mode&OK) == 0) continue;
      56:         if (d->d_size == 0)   continue;
      57: /* find a place on the tape for this file */
      58:         size = (d->d_size+BSIZE-1)/BSIZE;
      59:         first = ndentb;
      60: toosmall:   ++first;
      61:         if ((last = first + size) >= tapsiz)    maperr();
      62:         for (b = first; b < last; ++b)
      63:             if (map[(b>>3) & MAPMASK] & (1<<(b&7))) {
      64:                 first = b;
      65:                 goto toosmall;
      66:             };
      67:         d->d_tapea = first;
      68:         setmap(d);
      69:     }  while (++d <= lastd);
      70:     wrdir();
      71:     update1();
      72: }
      73:
      74:
      75: update1()
      76: {
      77:     register struct dent *d, *id;
      78:     register index;
      79:     int f;
      80:
      81:     for (;;) {
      82:         d = &dir[0];
      83:         index = MTSIZ;
      84:         id = 0;
      85:         do {    /* find new dent with lowest tape address */
      86:             if(d->d_namep == 0 || (d->d_mode&OK) == 0) continue;
      87:             if (d->d_tapea < index) {
      88:                 index = d->d_tapea;
      89:                 id = d;
      90:             }
      91:         } while (++d <= lastd);
      92:         if ((d = id) == 0)  return;
      93:         d->d_mode &= ~OK;  /* change from new to old */
      94:         if (d->d_size == 0)  continue;
      95:         decode(name,d);
      96:         wseek(index);
      97:         if ((f = open(name,0)) < 0) {
      98:             printf("Can't open %s\n", name);
      99:             continue;
     100:         }
     101:         for (index = d->d_size/BSIZE; index != 0; --index)  {
     102:             if (read(f,(char *)tapeb,BSIZE) != BSIZE)       phserr();
     103:             twrite();
     104:         }
     105:         if (index = d->d_size % BSIZE) {
     106:             if (read(f,(char *)tapeb,index) != index)  phserr();
     107:             twrite();
     108:         }
     109:         if (read(f,(char *)tapeb,1) != 0)           phserr();
     110:         close(f);
     111:     }
     112: }
     113:
     114: phserr()
     115: {   printf("%s -- Phase error \n", name);  }
     116:
     117:
     118: bitmap()    /* place old files in the map */
     119: {
     120:     register char *m;
     121:     register count;
     122:     register struct dent *d;
     123:
     124:     for(m=map;m<&map[MAPSIZE];) *m++ = 0;
     125:     count = ndirent;
     126:     d = dir;
     127:     do {
     128:         if(d->d_namep != 0 && (d->d_mode&OK) == 0
     129:            && d->d_size != 0) setmap(d);
     130:         d++;
     131:     }  while (--count);
     132: }
     133:
     134: setmap(d)
     135: register struct dent *d;
     136: {
     137:     unsigned c, block;
     138:     char bit;
     139:     int i;
     140:
     141:     c = d->d_size/BSIZE;
     142:     if (d->d_size % BSIZE)  c++;
     143:     block = d->d_tapea;
     144:     if ((c += block) >= tapsiz)     maperr();
     145:     do {
     146:         bit = 1 << (block & 7);
     147:         i = (block>>3) & MAPMASK;
     148:         if (bit & map[i])       maperr();
     149:         map[i] |= bit;
     150:     } while (++block < c);
     151: }
     152:
     153: maperr()
     154: {
     155:     printf("Tape overflow\n");
     156:     done();
     157: }
     158:
     159:
     160: usage()
     161: {
     162:     register reg,count;
     163:     int nused, nentr, nfree;
     164:     static lused;
     165:
     166:     bitmap();
     167:     for(count=0,nentr=0;count<ndirent;count++)
     168:         if(dir[count].d_namep != 0) nentr++;
     169:     nused = nfree = 0;
     170:     reg = ndentb;
     171:     ++reg;      /* address of first non-directory tape block */
     172:     count = tapsiz - reg;
     173:     do {
     174:         if (reg >= tapsiz) {
     175:             printf("Tape overflow\n");
     176:             done();
     177:         }
     178:         if (map[(reg>>3) & MAPMASK] & (1 << (reg&7))) {
     179:             nused++;
     180:             lused = reg;
     181:         } else {
     182:             if (flags & flm)   break;
     183:             nfree++;
     184:         }
     185:         reg++;
     186:     } while (--count);
     187:     printf("%4d entries\n%4d used\n", nentr, nused);
     188:     if ((flags & flm)==0)
     189:         printf("%4d free\n", nfree);
     190:     printf("%4d last\n", lused);
     191: }
     192:
     193:
     194: taboc(dd)
     195: struct dent *dd;
     196: {
     197:     register  mode;
     198:     register *m;
     199:     register char *s;
     200:     int count, *localtime();
     201:     char work[20];
     202:
     203:     if (flags & flv)  {
     204:         mode = dd->d_mode;
     205:         s = &work[19];
     206:         *s = 0;
     207:         for (count = 3; count; --count) {
     208:             if (mode&1) *--s = 'x';
     209:               else      *--s = '-';
     210:             if (mode&2) *--s = 'w';
     211:               else      *--s = '-';
     212:             if (mode&4) *--s = 'r';
     213:               else      *--s = '-';
     214:             mode >>= 3;
     215:         }
     216:         if (mode&4)     s[2] = 's';
     217:         if (mode&2)     s[5] = 's';
     218:         printf("%s%4d%4d%5d%9D ",s,dd->d_uid, dd->d_gid,dd->d_tapea,dd->d_size);
     219:         m = localtime(&dd->d_time);
     220:         printf("%2d/%2d/%2d %2d:%2d ",m[5],m[4]+1,m[3],m[2],m[1]);
     221:     }
     222:     printf("%s\n", name);
     223: }
     224:
     225:
     226: extract(d)
     227: register struct dent *d;
     228: {
     229:     register count, id;
     230:
     231:     if (d->d_size==0)   return;
     232:     if (verify('x') < 0)            return;
     233:     rseek(d->d_tapea);
     234:     unlink(name);
     235:     if ((id = creat(name,d->d_mode)) < 0)
     236:         printf("%s -- create error\n", name);
     237:     count = d->d_size/BSIZE;
     238:     while (count--) {
     239:         tread();
     240:         if (write(id, (char *)tapeb, BSIZE) != BSIZE)   goto ng;
     241:     }
     242:     if (count = d->d_size % BSIZE) {
     243:         tread();
     244:         if (write(id, (char *)tapeb, count) != count) {
     245: ng:         printf("%s -- write error\n", name);
     246:             close(id);
     247:             return;
     248:         }
     249:     }
     250:     close(id);
     251:     chown(name,d->d_uid & 0377, d->d_gid&0377);
     252: }

#### Defined functions

bitmap defined in line 118; used 3 times

- in line 52, 166
- in /usr/src/bin/tp/tp2.c line 105

delete defined in line 37; used 2 times

- in /usr/src/bin/tp/tp1.c line 113-118(2)

extract defined in line 226; used 2 times

- in /usr/src/bin/tp/tp1.c line 146-150(2)

gettape defined in line 7; used 3 times

- in /usr/src/bin/tp/tp1.c line 118, 140, 150

maperr defined in line 153; used 3 times

- in line 61, 144-148(2)

phserr defined in line 114; used 3 times

- in line 102-109(3)

setmap defined in line 134; used 2 times

- in line 68, 129

taboc defined in line 194; used 2 times

- in /usr/src/bin/tp/tp1.c line 134, 140

update defined in line 45; used 1 times

- in /usr/src/bin/tp/tp1.c line 128

update1 defined in line 75; used 1 times

- in line 71

usage defined in line 160; used 1 times

- in /usr/src/bin/tp/tp1.c line 156

#### Defined variables

sccsid defined in line 2; never used

Last modified: 1987-02-08 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1582 |