#include <u.h>
#include <libc.h>
#include <bio.h>
#include <flate.h>
#include <mp.h>
#include <libsec.h>
#include "paqfs.h"

enum {
       OffsetSize = 4, /* size of block offset */
};

void paqfs(char *root, char *label);
PaqDir *paqFile(char *name, Dir *dir);
PaqDir *paqDir(char *name, Dir *dir);
PaqDir *paqDirAlloc(Dir *d, ulong offset);
void paqDirFree(PaqDir *pd);
void writeHeader(char *label);
void writeTrailer(ulong root);
ulong writeBlock(uchar *buf, int type);
void usage(void);
void outWrite(void *buf, int n);
int paqDirSize(PaqDir *dir);
void putDir(uchar *p, PaqDir *dir);
void putHeader(uchar *p, PaqHeader *h);
void putBlock(uchar *p, PaqBlock *h);
void putTrailer(uchar *p, PaqTrailer *t);
void putl(uchar *p, ulong v);
void puts(uchar *p, int x);
uchar *putstr(uchar *p, char *s);
void *emallocz(int size);
void warn(char *fmt, ...);

int uflag=0;                    /* uncompressed */
long blocksize = 4*1024;

Biobuf *out;
DigestState *outdg;

void
main(int argc, char *argv[])
{
       char *s, *ss;
       char *outfile = nil;
       char *label = nil;
       char *file;

       ARGBEGIN {
       case 'u':
               uflag=1;
               break;
       case 'o':
               outfile = ARGF();
               break;
       case 'l':
               label = ARGF();
               if(label == nil)
                       usage();
               break;
       case 'b':
               s = ARGF();
               if(s) {
                       blocksize = strtoul(s, &ss, 0);
                       if(s == ss)
                               usage();
                       if(*ss == 'k')
                               blocksize *= 1024;
               }
               if(blocksize < MinBlockSize)
                       sysfatal("blocksize too small: must be at least %d", MinBlockSize);
               if(blocksize > MaxBlockSize)
                       sysfatal("blocksize too large: must be no greater than %d", MaxBlockSize);
               break;
       } ARGEND

       if(outfile == nil) {
               out = emallocz(sizeof(Biobuf));
               Binit(out, 1, OWRITE);
       } else {
               out = Bopen(outfile, OWRITE|OTRUNC);
               if(out == nil)
                       sysfatal("could not create file: %s: %r", outfile);
       }

       deflateinit();

       file = argv[0];
       if(file == nil)
               file = ".";

       if(label == nil) {
               if(strrchr(file, '/'))
                       label = strrchr(file, '/') + 1;
               else
                       label = file;
       }

       paqfs(file, label);

       Bterm(out);

       exits(0);
}

void
usage(void)
{
       fprint(2, "usage: %s [-u] [-b blocksize] -o output [root]\n", argv0);
       exits("usage");
}

void
paqfs(char *root, char *label)
{
       Dir *dir;
       PaqDir *pd;
       ulong offset;
       uchar *buf;

       dir = dirstat(root);
       if(dir == nil)
               sysfatal("could not stat root: %s: %r", root);
       writeHeader(label);
       if(dir->mode & DMDIR)
               pd = paqDir(root, dir);
       else
               pd = paqFile(root, dir);
       buf = emallocz(blocksize);
       putDir(buf, pd);
       offset = writeBlock(buf, DirBlock);
       writeTrailer(offset);
       paqDirFree(pd);
       free(dir);
}


PaqDir *
paqFile(char *name, Dir *dir)
{
       int fd, n, nn, nb;
       vlong tot;
       uchar *block, *pointer;
       ulong offset;

       fd = open(name, OREAD);
       if(fd < 0) {
               warn("could not open file: %s: %r", name);
               return nil;
       }

       block = emallocz(blocksize);
       pointer = emallocz(blocksize);
       nb = 0;
       n = 0;
       tot = 0;
       for(;;) {
               nn = read(fd, block+n, blocksize-n);
               if(nn < 0) {
                       warn("read failed: %s: %r", name);
                       goto Err;
               }
               tot += nn;
               if(nn == 0) {
                       if(n == 0)
                               break;
                       /* pad out last block */
                       memset(block+n, 0, blocksize-n);
                       nn = blocksize - n;
               }
               n += nn;
               if(n < blocksize)
                       continue;
               if(nb >= blocksize/OffsetSize) {
                       warn("file too big for blocksize: %s", name);
                       goto Err;
               }
               offset = writeBlock(block, DataBlock);
               putl(pointer+nb*OffsetSize, offset);
               nb++;
               n = 0;
       }

       offset = writeBlock(pointer, PointerBlock);

       close(fd);
       free(pointer);
       free(block);
       dir->length = tot;
       return paqDirAlloc(dir, offset);
Err:
       close(fd);
       free(pointer);
       free(block);
       return nil;
}

PaqDir *
paqDir(char *name, Dir *dir)
{
       Dir *dirs, *p;
       PaqDir *pd;
       int i, n, nb, fd, ndir;
       uchar *block, *pointer;
       char *nname;
       ulong offset;

       fd = open(name, OREAD);
       if(fd < 0) {
               warn("could not open directory: %s: %r", name);
               return nil;
       }

       ndir = dirreadall(fd, &dirs);
       close(fd);

       if(ndir < 0) {
               warn("could not read directory: %s: %r", name);
               return nil;
       }

       block = emallocz(blocksize);
       pointer = emallocz(blocksize);
       nb = 0;
       n = 0;
       nname = nil;
       pd = nil;

       for(i=0; i<ndir; i++) {
               p = dirs + i;
               free(nname);
               nname = emallocz(strlen(name) + strlen(p->name) + 2);
               sprint(nname, "%s/%s", name, p->name);
               if(p->mode & DMDIR)
                       pd = paqDir(nname, p);
               else
                       pd = paqFile(nname, p);
               if(pd == nil)
                       continue;

               if(n+paqDirSize(pd) >= blocksize) {

                       /* zero fill the block */
                       memset(block+n, 0, blocksize-n);
                       offset = writeBlock(block, DirBlock);
                       n = 0;
                       if(nb >= blocksize/OffsetSize) {
                               warn("directory too big for blocksize: %s", nname);
                               goto Err;
                       }
                       putl(pointer+nb*OffsetSize, offset);
                       nb++;
               }
               if(n+paqDirSize(pd) >= blocksize) {
                       warn("directory entry does not fit in a block: %s", nname);
                       paqDirFree(pd);
                       continue;
               }
               putDir(block+n, pd);
               n += paqDirSize(pd);
               paqDirFree(pd);
               pd = nil;
       }

       if(n > 0) {
               /* zero fill the block */
               memset(block+n, 0, blocksize-n);
               offset = writeBlock(block, DirBlock);
               if(nb >= blocksize/OffsetSize) {
                       warn("directory too big for blocksize: %s", nname);
                       goto Err;
               }
               putl(pointer+nb*OffsetSize, offset);
       }
       offset = writeBlock(pointer, PointerBlock);

       free(nname);
       free(dirs);
       paqDirFree(pd);
       free(block);
       free(pointer);
       return paqDirAlloc(dir, offset);
Err:
       free(nname);
       free(dirs);
       paqDirFree(pd);
       free(block);
       free(pointer);
       return nil;
}

PaqDir *
paqDirAlloc(Dir *dir, ulong offset)
{
       PaqDir *pd;
       static ulong qid = 1;

       pd = emallocz(sizeof(PaqDir));

       pd->name = strdup(dir->name);
       pd->qid = qid++;
       pd->mode = dir->mode & (DMDIR|DMAPPEND|0777);
       pd->mtime = dir->mtime;
       pd->length = dir->length;
       pd->uid = strdup(dir->uid);
       pd->gid = strdup(dir->gid);
       pd->offset = offset;

       return pd;
}

void
paqDirFree(PaqDir *pd)
{
       if(pd == nil)
               return;
       free(pd->name);
       free(pd->uid);
       free(pd->gid);
       free(pd);
}


void
writeHeader(char *label)
{
       PaqHeader hdr;
       uchar buf[HeaderSize];

       memset(&hdr, 0, sizeof(hdr));
       hdr.magic = HeaderMagic;
       hdr.version = Version;
       hdr.blocksize = blocksize;
       hdr.time = time(nil);
       strncpy(hdr.label, label, sizeof(hdr.label));
       hdr.label[sizeof(hdr.label)-1] = 0;
       putHeader(buf, &hdr);
       outWrite(buf, sizeof(buf));
}

void
writeTrailer(ulong root)
{
       PaqTrailer tlr;
       uchar buf[TrailerSize];

       memset(&tlr, 0, sizeof(tlr));
       tlr.magic = TrailerMagic;
       tlr.root = root;
       putTrailer(buf, &tlr);
       outWrite(buf, sizeof(buf));
}

ulong
writeBlock(uchar *b, int type)
{
       uchar *cb, *ob;
       int n;
       PaqBlock bh;
       uchar buf[BlockSize];
       ulong offset;

       offset = Boffset(out);

       bh.magic = BlockMagic;
       bh.size = blocksize;
       bh.type = type;
       bh.encoding = NoEnc;
       bh.adler32 = adler32(0, b, blocksize);
       ob = b;

       if(!uflag) {
               cb = emallocz(blocksize);
               n = deflateblock(cb, blocksize, b, blocksize, 6, 0);
               if(n > 0 && n < blocksize) {
                       bh.encoding = DeflateEnc;
                       bh.size = n;
                       ob = cb;
               }
       }

       putBlock(buf, &bh);
       outWrite(buf, sizeof(buf));
       outWrite(ob, bh.size);

       if(ob != b)
               free(ob);
       return offset;
}


void
outWrite(void *buf, int n)
{
       if(Bwrite(out, buf, n) < n)
               sysfatal("write failed: %r");
       outdg = sha1((uchar*)buf, n, nil, outdg);
}

int
paqDirSize(PaqDir *d)
{
       return MinDirSize + strlen(d->name) + strlen(d->uid) + strlen(d->gid);
}

void
putHeader(uchar *p, PaqHeader *h)
{
       if(h->blocksize < 65536){
               putl(p, h->magic);
               puts(p+4, h->version);
               puts(p+6, h->blocksize);
       }else{
               assert(h->magic == HeaderMagic);
               puts(p, BigHeaderMagic);
               puts(p+2, h->version);
               putl(p+4, h->blocksize);
       }
       putl(p+8, h->time);
       memmove(p+12, h->label, sizeof(h->label));
}

void
putTrailer(uchar *p, PaqTrailer *h)
{
       putl(p, h->magic);
       putl(p+4, h->root);
       outdg = sha1(p, 8, p+8, outdg);
}

void
putBlock(uchar *p, PaqBlock *b)
{
       if(b->size < 65536){
               putl(p, b->magic);
               puts(p+4, b->size);
       }else{
               assert(b->magic == BlockMagic);
               puts(p, BigBlockMagic);
               putl(p+2, b->size);
       }
       p[6] = b->type;
       p[7] = b->encoding;
       putl(p+8, b->adler32);
}

void
putDir(uchar *p, PaqDir *d)
{
       uchar *q;

       puts(p, paqDirSize(d));
       putl(p+2, d->qid);
       putl(p+6, d->mode);
       putl(p+10, d->mtime);
       putl(p+14, d->length);
       putl(p+18, d->offset);
       q = putstr(p+22, d->name);
       q = putstr(q, d->uid);
       q = putstr(q, d->gid);
       assert(q-p == paqDirSize(d));
}

void
putl(uchar *p, ulong v)
{
       p[0] = v>>24;
       p[1] = v>>16;
       p[2] = v>>8;
       p[3] = v;
}

void
puts(uchar *p, int v)
{
       assert(v < (1<<16));
       p[0] = v>>8;
       p[1] = v;
}

uchar *
putstr(uchar *p, char *s)
{
       int n = strlen(s);
       puts(p, n+2);
       memmove(p+2, s, n);
       return p+2+n;
}


void *
emallocz(int size)
{
       void *p;

       p = malloc(size);
       if(p == nil)
               sysfatal("malloc failed");
       memset(p, 0, size);
       return p;
}

void
warn(char *fmt, ...)
{
       char buf[1024];
       va_list arg;

       va_start(arg, fmt);
       vseprint(buf, buf+sizeof(buf), fmt, arg);
       va_end(arg);
       fprint(2, "%s: %s\n", argv0, buf);
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.