#include <u.h>
#include <libc.h>
#include <bio.h>
#include <libsec.h>

#include "iso9660.h"

void
mkdirec(Direc *direc, XDir *d)
{
       memset(direc, 0, sizeof(Direc));
       direc->name = atom(d->name);
       direc->uid = atom(d->uid);
       direc->gid = atom(d->gid);
       direc->uidno = d->uidno;
       direc->gidno = d->gidno;
       direc->mode = d->mode;
       direc->length = d->length;
       direc->mtime = d->mtime;
       direc->atime = d->atime;
       direc->ctime = d->ctime;
       direc->symlink = d->symlink;
}

static int
strecmp(char *a, char *ea, char *b)
{
       int r;

       if((r = strncmp(a, b, ea-a)) != 0)
               return r;

       if(b[ea-a] == '\0')
               return 0;
       return 1;
}

/*
* Binary search a list of directories for the
* entry with name name.
* If no entry is found, return a pointer to
* where a new such entry would go.
*/
static Direc*
dbsearch(char *name, int nname, Direc *d, int n)
{
       int i;

       while(n > 0) {
               i = strecmp(name, name+nname, d[n/2].name);
               if(i < 0)
                       n = n/2;
               else if(i > 0) {
                       d += n/2+1;
                       n -= (n/2+1);
               } else
                       return &d[n/2];
       }
       return d;
}

/*
* Walk to name, starting at d.
*/
Direc*
walkdirec(Direc *d, char *name)
{
       char *p, *nextp, *slashp;
       Direc *nd;

       for(p=name; p && *p; p=nextp) {
               if((slashp = strchr(p, '/')) != nil)
                       nextp = slashp+1;
               else
                       nextp = slashp = p+strlen(p);

               nd = dbsearch(p, slashp-p, d->child, d->nchild);
               if(nd >= d->child+d->nchild || strecmp(p, slashp, nd->name) != 0)
                       return nil;
               d = nd;
       }
       return d;
}

/*
* Add the file ``name'' with attributes d to the
* directory ``root''.  Name may contain multiple
* elements; all but the last must exist already.
*
* The child lists are kept sorted by utfname.
*/
Direc*
adddirec(Direc *root, char *name, XDir *d)
{
       char *p;
       Direc *nd;
       int off;

       if(name[0] == '/')
               name++;
       if((p = strrchr(name, '/')) != nil) {
               *p = '\0';
               root = walkdirec(root, name);
               if(root == nil) {
                       sysfatal("error in proto file: no entry for /%s but /%s/%s\n", name, name, p+1);
                       return nil;
               }
               *p = '/';
               p++;
       } else
               p = name;

       nd = dbsearch(p, strlen(p), root->child, root->nchild);
       off = nd - root->child;
       if(off < root->nchild && strcmp(nd->name, p) == 0) {
               if ((d->mode & DMDIR) == 0)
                       fprint(2, "warning: proto lists %s twice\n", name);
               return nil;
       }

       if(root->nchild%Ndirblock == 0) {
               root->child = erealloc(root->child, (root->nchild+Ndirblock)*sizeof(Direc));
               nd = root->child + off;
       }

       memmove(nd+1, nd, (root->nchild - off)*sizeof(Direc));
       mkdirec(nd, d);
       nd->name = atom(p);
       root->nchild++;
       return nd;
}

/*
* Copy the tree src into dst.
*/
void
copydirec(Direc *dst, Direc *src)
{
       int i, n;

       *dst = *src;

       if((src->mode & DMDIR) == 0)
               return;

       n = (src->nchild + Ndirblock - 1);
       n -= n%Ndirblock;
       dst->child = emalloc(n*sizeof(Direc));

       n = dst->nchild;
       for(i=0; i<n; i++)
               copydirec(&dst->child[i], &src->child[i]);
}

/*
* Turn the Dbadname flag on for any entries
* that have non-conforming names.
*/
static void
_checknames(Direc *d, int (*isbadname)(char*), int isroot)
{
       int i;

       if(!isroot && isbadname(d->name))
               d->flags |= Dbadname;

       if(strcmp(d->name, "_conform.map") == 0)
               d->flags |= Dbadname;

       for(i=0; i<d->nchild; i++)
               _checknames(&d->child[i], isbadname, 0);
}

void
checknames(Direc *d, int (*isbadname)(char*))
{
       _checknames(d, isbadname, 1);
}

/*
* Set the names to conform to 8.3
* by changing them to numbers.
* Plan 9 gets the right names from its
* own directory entry.
*
* We used to write a _conform.map file to translate
* names.  Joliet should take care of most of the
* interoperability with other systems now.
*/
void
convertnames(Direc *d, char* (*cvt)(char*, char*))
{
       int i;
       char new[1024];

       if(d->flags & Dbadname)
               cvt(new, conform(d->name, d->mode & DMDIR));
       else
               cvt(new, d->name);
       d->confname = atom(new);

       for(i=0; i<d->nchild; i++)
               convertnames(&d->child[i], cvt);
}

/*
* Sort a directory with a given comparison function.
* After this is called on a tree, adddirec should not be,
* since the entries may no longer be sorted as adddirec expects.
*/
void
dsort(Direc *d, int (*cmp)(const void*, const void*))
{
       int i, n;

       n = d->nchild;
       qsort(d->child, n, sizeof(d[0]), cmp);

       for(i=0; i<n; i++)
               dsort(&d->child[i], cmp);
}

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.