Subversion Repositories planix.SVN

#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", 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);

}