tcpiofs.c - plan9port - [fork] Plan 9 from user space
  HTML git clone git://src.adamsgaard.dk/plan9port
   DIR Log
   DIR Files
   DIR Refs
   DIR README
   DIR LICENSE
       ---
       tcpiofs.c (2491B)
       ---
            1 #include <u.h>
            2 #include <libc.h>
            3 #include <auth.h>
            4 #include <fcall.h>
            5 #include "tapefs.h"
            6 
            7 /*
            8  * File system for cpio tapes (read-only)
            9  */
           10 
           11 #define TBLOCK        512
           12 #define NBLOCK        40        /* maximum blocksize */
           13 #define DBLOCK        20        /* default blocksize */
           14 #define TNAMSIZ        100
           15 
           16 union hblock {
           17         char dummy[TBLOCK];
           18         char tbuf[Maxbuf];
           19         struct header {
           20                 char magic[6];
           21                 char dev[6];
           22                 char ino[6];
           23                 char mode[6];
           24                 char uid[6];
           25                 char gid[6];
           26                 char nlink[6];
           27                 char rdev[6];
           28                 char mtime[11];
           29                 char namesize[6];
           30                 char size[11];
           31         } dbuf;
           32         struct hname {
           33                 struct        header x;
           34                 char        name[1];
           35         } nbuf;
           36 } dblock;
           37 
           38 int        tapefile;
           39 vlong        getoct(char*, int);
           40 
           41 void
           42 populate(char *name)
           43 {
           44         vlong offset;
           45         long isabs, magic, namesize, mode;
           46         Fileinf f;
           47 
           48         tapefile = open(name, OREAD);
           49         if (tapefile<0)
           50                 error("Can't open argument file");
           51         replete = 1;
           52         for (offset = 0;;) {
           53                 seek(tapefile, offset, 0);
           54                 if (read(tapefile, (char *)&dblock.dbuf, TBLOCK)<TBLOCK)
           55                         break;
           56                 magic = getoct(dblock.dbuf.magic, sizeof(dblock.dbuf.magic));
           57                 if (magic != 070707){
           58                         print("%lo\n", magic);
           59                         error("out of phase--get help");
           60                 }
           61                 if (dblock.nbuf.name[0]=='\0' || strcmp(dblock.nbuf.name, "TRAILER!!!")==0)
           62                         break;
           63                 mode = getoct(dblock.dbuf.mode, sizeof(dblock.dbuf.mode));
           64                 f.mode = mode&0777;
           65                 switch(mode & 0170000) {
           66                 case 0040000:
           67                         f.mode |= DMDIR;
           68                         break;
           69                 case 0100000:
           70                         break;
           71                 default:
           72                         f.mode = 0;
           73                         break;
           74                 }
           75                 f.uid = getoct(dblock.dbuf.uid, sizeof(dblock.dbuf.uid));
           76                 f.gid = getoct(dblock.dbuf.gid, sizeof(dblock.dbuf.gid));
           77                 f.size = getoct(dblock.dbuf.size, sizeof(dblock.dbuf.size));
           78                 f.mdate = getoct(dblock.dbuf.mtime, sizeof(dblock.dbuf.mtime));
           79                 namesize = getoct(dblock.dbuf.namesize, sizeof(dblock.dbuf.namesize));
           80                 f.addr = offset+sizeof(struct header)+namesize;
           81                 isabs = dblock.nbuf.name[0]=='/';
           82                 f.name = &dblock.nbuf.name[isabs];
           83                 poppath(f, 1);
           84                 offset += sizeof(struct header)+namesize+f.size;
           85         }
           86 }
           87 
           88 vlong
           89 getoct(char *p, int l)
           90 {
           91         vlong r;
           92 
           93         for (r=0; l>0; p++, l--){
           94                 r <<= 3;
           95                 r += *p-'0';
           96         }
           97         return r;
           98 }
           99 
          100 void
          101 dotrunc(Ram *r)
          102 {
          103         USED(r);
          104 }
          105 
          106 void
          107 docreate(Ram *r)
          108 {
          109         USED(r);
          110 }
          111 
          112 char *
          113 doread(Ram *r, vlong off, long cnt)
          114 {
          115         seek(tapefile, r->addr+off, 0);
          116         if (cnt>sizeof(dblock.tbuf))
          117                 error("read too big");
          118         read(tapefile, dblock.tbuf, cnt);
          119         return dblock.tbuf;
          120 }
          121 
          122 void
          123 popdir(Ram *r)
          124 {
          125         USED(r);
          126 }
          127 
          128 void
          129 dowrite(Ram *r, char *buf, long off, long cnt)
          130 {
          131         USED(r); USED(buf); USED(off); USED(cnt);
          132 }
          133 
          134 int
          135 dopermw(Ram *r)
          136 {
          137         USED(r);
          138         return 0;
          139 }