/*
*	name: cpdir
*	version: 1.5e
*	date: 2005/02/19
*	os: plan9 v4
*	usage: cpdir [-mstugvR] [-l file] srcdir dstdir [path ...]
*		srcdir: source directory
*		dstdir: destination directory
*		path: path to copy. file or directory.
*	options:
*		-m:	merge (this option is used if dstdir is already exist)
*		-u: copy owner info.
*		-g: copy groupe info.
*		-v: verbose
*		-R: remove redundant files in destination
*		-s: safe mode in removing files; just renames foo to _foo
*		-t: ignore mtime
*		-l file: path list and pattern list file
*
*	path or pattern list is a file that contains path or pattern per line.
*
*	Note:
*		Not tested enough.
*
*	auther: Kenji Arisawa (Kenar)
*	E-mail: arisawa@aichi-u.ac.jp
*/

#include <u.h>
#include <libc.h>
#include <bio.h>
#include <ctype.h>
#define MAXPATH 4096
#define debug if(Dflag) print

char *mkpath2(char *path1, char *path2);
char *mkpath3(char *path1, char *path2, char *path3);
char *strtrim(char *s);
int growto(Dir **dirbuf, int ndirbuf, long n);
int compar(Dir *a, Dir *b);
void cpdir(char *path, char *uid, char *gid);
int test(char *path);
int empty(char *path);
int dirfinfo(Dir **dirbuf, int fd);
int mkdir(char *dstpath, char *uid, char *gid);
void cpfile(char *path, char *uid, char *gid);
int	copyfile(int sfd, int dfd);
int	cpattr(Dir *sd, Dir *dd);
int rmdir(char *path, char *uid, char *gid);
int rmfile(char *path, char *uid, char *gid);
int	setugid(int fd,char *uid,char *gid);
int	protectedf(char *path, char *uid, char *gid);

char *src, *dst;
int vflag; // verbose
int Rflag; // remove redundant files
int uflag; // user flag
int gflag; // groupe flag
int mflag; // merge flag
int tflag; // ignore mtime
int Dflag; // debug
int safe = 0;
int quit = 0;

enum
{
	NON,
	FIL,
	DIR,
};


typedef struct List List;
struct List{
	char	*data;
	List	*next;
};

List *xlist;

void
usage(void)
{
	fprint(2,"usage: cpdir [-mstugvR] [-l file] srcdir dstdir [path ....]\n");
	exits("usage");
}


void
appendList(List **j, char *d)
{
	List *p, *q;
	q = nil;
	p = *j;
	while(p){
		q = p;
		p = p->next;
	}
	// then p is nil
	p = malloc(sizeof(List));
	if(q)
		q ->next = p;
	else
		*j = p;
	p->data = strdup(d);
	p->next = nil;
}

static int
notefun(void *a, char *msg)
{
	USED(a);
	USED(msg);
	fprint(2,"# %s\n",msg);
	quit = 1;
	noted(NCONT);
	return 0;
}

#ifdef NOTE
*	shell style path matching function
*	I modified to simplify original one
*	and made some modification of the matching rule.
*	now, '/' is a simplly regular charactor except
*	"/*/" is match to "/".
*	ref: /sys/src/cmd/rc/glob.c
*	-Kenar-
*
 * 	Does the string s match the pattern p
 * 	* matches any sequence of characters
 * 	? matches any single character
 * 	[...] matches the enclosed list of characters
 *	~ in the beginning of [...] means compliment
 *	- in [...] means range in ascii order
 *
 *	return value
 *	1: matched
 *	0: not matched
#endif
int
match(char *s, char *p)
{
	char *s0;
	int compl, hit, lo, hi, t, c;
	s0 = s;
	for(;*p; s++,p++){
		switch(*p){
		case '*':
			++p;
			if((*p == '/') && (s > s0))
				if(match(s-1, p)) return 1;
			for(;;){
				if(match(s, p)) return 1;
				if(!*s) break;
				s++;
			}
			return 0;
		case '?':
			if(*s == '\0') return 0;
			break;
		case '[':
			if(*s == '\0') return 0;
			c=*s;
			p++;
			compl = (*p == '~');
			if(compl) p++;
			hit=0;
			while(*p!=']'){
				if(*p=='\0') return 0;		/* syntax error */
				lo=*p;
				p++;
				if(*p!='-') hi=lo;
				else{
					p++;
					if(*p=='\0') return 0;	/* syntax error */
					hi=*p;
					p++;
					if(hi<lo){ t=lo; lo=hi; hi=t; }
				}
				if(lo<=c && c<=hi) hit=1;
			}
			if(compl) hit=!hit;
			if(!hit) return 0;
			break;
		default:
			if(*p != *s) return 0;
		}
	}
	return *s=='\0';
}

void *
emalloc(ulong n)
{
	void *p;

	if((p = malloc(n)) == 0)
		sysfatal("out of memory");
	return p;
}

char *
mkpath2(char *path1, char *path2)
{
	char *p;
	p = emalloc(strlen(path1)+strlen(path2)+5);
	sprint(p, "%s/%s", path1, path2);
	p = cleanname(p);
	return p;
}

char *
mkpath3(char *path1, char *path2, char *path3)
{
	char *p;
	p = emalloc(strlen(path1)+strlen(path2)+strlen(path3)+5);
	sprint(p, "%s/%s/%s", path1, path2, path3);
	p = cleanname(p);
	return p;
}

char*
strtrim(char *s)
{
	char *t;
	while(*s && isspace(*s))
		s++;
	t = s + strlen(s) - 1;
	if(s < t){
		while(*t && isspace(*t)) t--;
		t++;
		*t = 0;
	}
	return s;
}

int
xmatch(char *path)
{
	List *p;
	p = xlist;
	while(p){
		if(match(path, p->data))
			return 1;
		p = p->next;
	}
	return 0;
}

void
readxlist(char *file, List **plist)
{
	int fd;
	Biobuf in;
	char *line;
	char *path;
	int n;
	fd = open(file, OREAD);
	if(fd < 0)
		sysfatal("%s not open:%r", file);
	Binit(&in, fd, OREAD);
	while(line = Brdline(&in,'\n')){/* assign = */
		n = Blinelen(&in);
		line[n-1] = 0;
		path = strtrim(line);
		if(path[0] != '!')
			continue;
		path++;
		path = strtrim(path);
		if(*path == 0)
			break;
		appendList(plist, path);
		//print("file... %s\n", path);
	}
	Bterm(&in); // note: Bterm close the file

	if(0) { // DEBUG
		List *p;
		p = *plist;
		while(p){
			print("%s\n", p->data);
			p = p->next;
		}
	}
}



/*	returns:
*	1: protected by uid and gid pair
*	0: not protected
*/
int
protected(Dir *d, char *uid, char *gid)
{
	int r;
	//debug("(%s,%s) (%s,%s)\n", uid,gid,d->uid,d->gid);
	r = (uid && (strcmp(d->uid,uid) != 0))||(gid && (strcmp(d->gid,gid) != 0));
	if(r) werrstr("protected");
	debug("protected: %d\n", r);
	return r;
}

/*	returns:
*	1: guared by uid and gid pair
*	0: not protected
*	-1: none existent
*/
int
protectedf(char *path, char *uid, char *gid)
{
	Dir *d;
	int r;
	d = dirstat(path);
	if(d == nil){
		fprint(2,"# %s not exist: %r\n",path);
		return -1;
	}
	r = (uid && (strcmp(d->uid,uid) != 0))||(gid && (strcmp(d->gid,gid) != 0));
	free(d);
	if(r) werrstr("protected");
	debug("protectedf: %d\n", r);
	return r;
}

void
setugidd(Dir *d,char *uid,char *gid)
{
	if(uid)
		d->uid = uid;
	if(gid)
		d->gid = gid;
}

int
setugid(int fd,char *uid,char *gid)
{	Dir *d;
	int status;
	d = dirfstat(fd);
	setugidd(d, uid,gid);
	status = dirfwstat(fd, d);
	free(d);
	return status;
}

/*
*	safe protection should be out of delete()
*	and also out of rmdir(), rmfile()
*	so that delete(path,nil,nil) works	*/
int
delete(char *path, char *uid, char *gid)
{
	int status;
	if(vflag)
		print("removing %s\n", path);
	status = 0;
	switch(test(path)){
	case NON: // none existent
		break;
	case FIL: // file
		if(protectedf(path,uid,gid))
			status = -1;
		else
			status = remove(path);
		break;
	case DIR: // dir
		if(empty(path))
			status = remove(path);
		else
			status = rmdir(path, uid, gid);
		break;
	default:
		break;
	}
	if(status)
		fprint(2,"# not removed %s: %r\n", path);
	return status;
}


/*
*	rename: rename path/to/foo to path/to/_foo	*/
int
rename(char *path)
{
	Dir null;
	char buf[MAXPATH];
	char *p;
	int status=0;
	debug("rename %s\n", path);
	p = strrchr(path, '/');
	if(p){
		*p = 0;
		snprint(buf, sizeof buf, "%s/_%s", path, p+1);
		*p = '/';
		p = strrchr(buf, '/') + 1;
	}
	else{
		snprint(buf, sizeof buf, "_%s", path);
		p = buf;
	}
	/*	if renamed file (_foo) already exist, we must
	*	unconditionnally delete it	*/
	if(delete(buf,nil,nil) < 0)
		goto L;

	nulldir(&null);
	null.name = p;
	//debug("dirwstat: %s %s\n", path, p);
	if((status = dirwstat(path, &null)) < 0)
		fprint(2, "# dirwstat: %r\n");
L:
	debug("done rename %s %d\n", path, test(path));
	return status;
}

void
dofile(char *path)
{
	Biobuf in;
	char *line;
	int fd;
	int n;
	char *args[3];
	char *uid, *gid;

	fd = open(path, OREAD);
	if(fd<0)
		sysfatal("%s not open\n", path);
	Binit(&in, fd, OREAD);
	while(line = Brdline(&in,'\n')){/* assign = */
		n = Blinelen(&in);
		line[n-1] = 0;
		line = strtrim(line);
		if(*line == '#' || *line == '!')
			continue;
		n = tokenize(line, args, 3);
		if(n <1)
			continue;
		path = args[0];
		// NOTE: cleanname converts null string to "."
		path = cleanname(path);
		uid = gid = nil;
		if(n > 1)
			uid = args[1];
		if(n > 2)
			gid = args[2];
		if(uid && (strcmp(uid,"*")==0))
			uid = nil;
		if(gid && (strcmp(gid,"*")==0))
			gid = nil;
		if(vflag) print("looking %s (%s,%s)\n", path, uid, gid);
		cpdir(path,uid, gid);
	}
	Bterm(&in); // note: Bterm close the file
}


void
main(int argc, char *argv[])
{
	char *file = 0;
	char *path;
	USED(argc);
	ARGBEGIN{
	case 't':	tflag = 1; break;
	case 'l':	file = ARGF(); break;
	case 'v':	vflag = 1; break;
	case 'R':	Rflag = 1; break;
	case 'u':	uflag = 1; break;
	case 'g':	gflag = 1; break;
	case 'm':	mflag = 1; break;
	case 's':	safe = 1; break;
	case 'D':	Dflag = 1; break;
	default: usage();
	}ARGEND
	if(*argv)
		src = cleanname(*argv++);
	if(*argv)
		dst = cleanname(*argv++);
	if(!src || !dst)
		usage();
	if(!mflag && Rflag)
		usage();
	if(file && *argv)
		sysfatal("-l option and %s ... incompatible",*argv);

	/* test src whether it is not empty */
	switch(test(src)){
	case NON:
		sysfatal("%s is non-existent", src);
	case FIL:
		sysfatal( "%s is not a directory", src);
	case DIR:
		if(empty(src))
			sysfatal( "%s is empty", src);
		break;
	default:
		break;
	}

	/* test dst whether it exits */
	switch(test(dst)){
	case NON: /* OK */
		if(mflag)
			sysfatal("%s absent. remove merge option -m",dst);
		break;
	case FIL:
		sysfatal("%s is not a directory", dst);
	default: /*already exist */
		if(mflag)
			break;
		sysfatal("%s already exist. merge option -m is required", dst);
	}

	/* 	confirm that  dst is not in the subtree of src.
	*	if it is, we must abort processing    */
	if((strlen(dst) >= strlen(src)) 
	&& (strncmp(dst,src,strlen(src)) == 0)){
		/* then be careful */
		if(dst[strlen(src)] == '/'){
			fprint(2,"# %s is a subtree of %s\n", dst, src);
			exits("error");
		}
	}

	/*
	*	file is read twice but don't mined.
	*	data in the file can be big. don't put it on memory.
	*	for example, data extracted from plan9.db	*/
	if(file)
		readxlist(file, &xlist);

	if(!mflag) /* create the dir */
		mkdir(dst, nil, nil);

	atnotify(notefun,1);

	/*	and process pathlist	*/
	if(file)
		dofile(file);
	else if(*argv)
		while(*argv){
			path = cleanname(*argv++);
			if(vflag) print("looking %s\n", path);
			cpdir(path, nil, nil);
		}
	else
		cpdir("/", nil, nil);

	/*	needed to avoid err exit in rc script */
	exits(nil);
}

void
cpdir(char *path, char *uid, char *gid)
{
	int sfd,dfd;
	int	nsrcdir;
	int	ndstdir;
	Dir *srcdirbuf, *sd, *sd0, *sdend, *ddend;
	Dir *dstdirbuf, *dd, ndd;
	char *newpath;
	char srcpath[MAXPATH];
	char dstpath[MAXPATH];

	if(quit)
		exits("interrupt");

	if(path[0] == '/') path++;
	debug("cpdir %s\n", path);

	if(strcmp(src,"/") == 0)
		snprint(srcpath,sizeof(srcpath),"/%s", path);
	else
		snprint(srcpath,sizeof(srcpath),"%s/%s", src, path);

	if(xmatch(path)){
		/* xmatch protection should be only here	*/
		if(vflag) print("skipping %s\n", path);
		return;
	}

	snprint(dstpath,sizeof(dstpath),"%s/%s", dst, path);

	sfd = open(srcpath,OREAD);
	if(sfd == -1){
		switch(test(srcpath)){
		case NON:
			fprint(2,"# %s not exist\n",srcpath);
			if(Rflag)
				delete(dstpath,uid,gid);
			break;
		default:
			fprint(2,"# %s unreadable, skipped.\n", srcpath);
			break;
		}
		return;
	}
	sd = dirfstat(sfd);
	if(sd == nil){
		fprint(2,"# %s can't dirstat: %r\n", srcpath);
		close(sfd);
		return;
	}

	if((sd->mode & DMDIR) == 0){ /* file */
		dd = dirstat(dstpath);
		if(dd == nil){
			/* we assume dstpath is non-existent */
			free(sd);
			close(sfd);
			cpfile(path, uid, gid);
			return;
		}
		if(tflag || (sd->mtime > dd->mtime)){
			/* we update. protection is in cpfile. */
			free(sd);
			free(dd);
			close(sfd);
			cpfile(path, uid, gid);
			return;
		}
		if((tflag || (sd->mtime == dd->mtime)) && !protected(dd,uid,gid)){
			nulldir(&ndd);
			setugidd(&ndd,uid,gid);
			if(cpattr(sd,&ndd) > 0 && dirwstat(dstpath,&ndd) < 0)
				fprint(2,"# can't wstat %s: %r\n", dstpath);
			//debug("dirfwstat: OK\n");
		}
		free(sd);
		free(dd);
		close(sfd);
		return;
	}

	/*	now srcpath is a directory	*/
	nsrcdir = dirfinfo(&srcdirbuf, sfd);
	close(sfd);
	if(nsrcdir < 0){
		/* something wrong. skip this copy */
		fprint(2,"# %s unreadable: %r\n", srcpath);
		free(sd);
		return;
	}

	dfd = open(dstpath,OREAD);
	//print("open: %s %d\n", dstpath,dfd);
	if(dfd < 0){// try to create a dir
		if(mkdir(dstpath, uid, gid) < 0){
			fprint(2,"# unreadable to create %s: %r\n", dstpath);
			free(sd);
			return;
		}
		dfd = open(dstpath, OREAD);
		if(dfd < 0){
			fprint(2,"# created but not open %s: %r\n", dstpath);
			free(sd);
			return;
		}
	}
	dd = dirfstat(dfd);
	if(dd == nil){ /* something wrong */
		fprint(2,"# dirfstat %s: %r\n", dstpath);
		free(sd);
		return;
	};
	if((dd->mode & DMDIR) == 0){ 
		/*	source is a directory, but destination is a file
		*	time is critical for this case */
		if(!tflag && (sd->mtime < dd->mtime)){
			fprint(2,"# %s untouched\n", path);
			free(sd);free(dd);close(dfd);
			return;
		}
		if(tflag || (sd->mtime > dd->mtime)){ /* we remove */
			free(dd);close(dfd);
			if(safe)
				rename(dstpath);
			else
				delete(dstpath,uid,gid);
			if((dfd = create(dstpath, OREAD|OEXCL, sd->mode)) < 0){
				fprint(2,"# create %s: %r\n", dstpath);
				free(sd);
				return;
			}
		}
	}
	/* now we have sd, dfd
	*	sd will be used later	*/

	sd0 = sd;
	/* end of flag f */

	ndstdir = dirfinfo(&dstdirbuf, dfd);
	if(ndstdir < 0){
		/* skip this copy */
		fprint(2, "# %s unreadable: %r\n", dstpath);
		return;
	}
	sdend = srcdirbuf + nsrcdir;
	ddend = dstdirbuf + ndstdir;
	/* copy them */
	if(0 && vflag)
		print("looking %s\n",path);
	for(sd = srcdirbuf, dd = dstdirbuf; !quit && sd < sdend && dd < ddend;){
		debug("comparing %s %s\n",sd->name, dd->name);
		if(strcmp(sd->name, dd->name) < 0){
			/* we must create destination */
			newpath = mkpath2(path, sd->name);
			if(sd->mode & DMDIR){
				/* create the directory and go on */
				char *p;
				p = mkpath2(dst, newpath);
				//mkdir(p, uid, gid);
				mkdir(p,nil,nil);
				free(p);
			}
			cpdir(newpath, uid, gid);
			free(newpath);
			sd++;
			continue;
		}
		else if(strcmp(sd->name, dd->name) > 0){
			if(Rflag){
				/* remove destination */
				char *p;
				p = mkpath3(dst, path, dd->name);
				delete(p,nil,nil);
				free(p);
			}
			dd++;
			continue;
		}
		else{ /* both names exist, we descend  */
				newpath = mkpath2(path, sd->name);
				cpdir(newpath, uid, gid);
				free(newpath);
		}
		debug("next step\n");
		sd++;
		dd++;
	}

	if(quit)
		exits("interrupted");

	if(sd < sdend){
		char *p;
		for(; !quit && sd < sdend; sd++){
			newpath = mkpath2(path, sd->name);
			p = mkpath3(dst, path, sd->name);
			if(sd->mode & DMDIR){
				/* create the directory and go on */
				mkdir(p, uid, gid);
				cpdir(newpath, uid, gid);
			}
			else
				cpfile(newpath, uid, gid);
			free(newpath);
			free(p);
		}
	}
	else if(Rflag && (dd < ddend)){
		char *p;
		for(; !quit && dd < ddend; dd++){
			p = mkpath3(dst, path, dd->name);
			if(vflag) print("removing %s\n", p);
			if(safe)
				rename(p);
			else if(dd->mode & DMDIR)
				rmdir(p, uid, gid);
			else
				rmfile(p, uid, gid);
			free(p);
		}
	}

	/* free dirbuf */
	free(srcdirbuf);
	free(dstdirbuf);

	/* sync stat to src */
	dd = dirfstat(dfd);
	nulldir(&ndd);
	ndd.uid = dd->uid;
	ndd.gid = dd->gid;
	if(cpattr(sd0,&ndd) > 0 && dirfwstat(dfd, &ndd) < 0)
		fprint(2,"# could not wstat %s: %r\n", dstpath);
	//debug("dirfwstat: OK\n");
	free(dd);

	close(dfd);
	free(sd0);

	if(quit)
		exits("interrupted");
	debug("done cpdir %s\n", path);
}

/*
test: return values
NON	not exist
FIL	file
DIR	directory
*/
int
test(char *path)
{
	ulong m;
	Dir *d;
	d = dirstat(path);
	if(d == nil)
		return NON; // non existent
	m = d->mode;
	free(d);
	if((m & DMDIR) == 0)
		return FIL; // not a directory
	return DIR;
}

int
empty(char *path)
{
	int fd;
	long n;
	Dir *db;
	fd = open(path, OREAD);
	if(fd < 0){
		fprint(2,"# %s not open: %r", path);
		return -1;
	}
	n = dirread(fd, &db);
	close(fd);
	free(db);
	return (n==0)?1:0;
}


/*
*	dirfinfo
*
*	return value
*	case -1: not exit
*	case 0: empty
*	others: the numbers of files/directory
*
*	note:
*		free(dirbuf) if return value is not -1
*
*	ref: /sys/src/cmd/ls.c
*/
int
dirfinfo(Dir **dirbufp, int fd)
{
	Dir *db;
	int n;

	n = dirreadall(fd,&db);
	if(n == -1)
		return -1;

	/* sort by name */
	qsort(db, n, sizeof(Dir), (int (*)(void*, void*))compar);

	*dirbufp = db;
	return n;
}


int
compar(Dir *a, Dir *b)
{
	return strcmp(a->name, b->name);
}

int
mkdir(char *dstpath, char *uid, char *gid)
/*	dstpath: absolute path to the destination
*	we can asume the destination is not present	*/
{
	int fd;
	char *p, *q;
	int m;
	p = dstpath + strlen(dst) + 1;
	if(vflag) print("creating %s\n", dstpath);
	while((q = strchr(p, '/'))){ // assign =
		*q = 0;
		m = test(dstpath);
		if(m == DIR){
			 *q = '/';
			p = q + 1;
			continue;
		}
		if(m == FIL)
			delete(p,uid,gid);
		fd = create(dstpath, OREAD|OEXCL, DMDIR | 0775);
		if(fd < 0){
			fprint(2,"# can't create %s: %r\n", dstpath);
			return -1;
		}
		if(setugid(fd, uid,gid) < 0)
			fprint(2,"# can't wstat %s: %r\n", dstpath);
		close(fd);
		*q = '/';
		p = q + 1;
	}
	fd = create(dstpath, OREAD|OEXCL, DMDIR | 0775);
	if(fd < 0){
		fprint(2,"# can't create %s: %r\n", dstpath);
		return -1;
	}
	if(setugid(fd, uid,gid) < 0)
		fprint(2,"# can't wstat %s: %r\n", dstpath);
	close(fd);
	debug("done mkdir: %s %s\n", uid, gid);
	return 0;
}

int
copyfile(int sfd, int dfd)
{
	char buf[4096];
	int n;
	for(;;){
		n = read(sfd, buf, sizeof buf);
		if(n <= 0) break;
		if(write(dfd, buf, n) != n)
			return -1;
	}
	return 0;
}

int
cpattr(Dir *sd, Dir *dd)
{
	int f = 0;
	debug("cpattr ...\n");
	/* 	&& ++f might be tricky	*/
	if((dd->mode != sd->mode) && ++f)
		dd->mode = sd->mode;
	if((dd->mtime != sd->mtime) && ++f)
		dd->mtime = sd->mtime;
	if(gflag && (strcmp(dd->gid,sd->gid)!=0) && ++f)
		dd->gid = sd->gid;
	if(uflag && (strcmp(dd->uid,sd->uid)!=0) && ++f)
		dd->uid = sd->uid;
	debug("cpattr %d\n", f);
	return f;
}


/*	src/path should be a file
*	cpfile check destination for some protections
*		safe protection
*		uid/gid protection
*	and set attribute for the destination	*/
void
cpfile(char *path, char *uid, char *gid)
{
	char srcpath[MAXPATH];
	char dstpath[MAXPATH];
	Dir *sd, *dd, ndd;
	int sfd, dfd;
	int f=0;

	debug("cpfile: %s\n", path);
	if(path[0] == '/') path++;

	if(strcmp(src,"/") == 0)
		snprint(srcpath,sizeof(srcpath),"/%s", path);
	else
		snprint(srcpath,sizeof(srcpath),"%s/%s", src, path);

	snprint(dstpath,sizeof(dstpath),"%s/%s", dst, path);
	/*	examine if the destination is already exist
	*	avoid removing protected files	*/

	dd = dirstat(dstpath);
	if(dd){
		debug("%s %d\n", path, protected(dd,uid,gid));
		if(((dd->mode & DMDIR) == 0) && protected(dd,uid,gid)){
			fprint(2,"# %s untouched\n", path);
			free(dd);
			goto L0;
		}
		if(vflag) print("updating %s\n", dstpath);
		if(safe || (dd->mode & DMDIR)){
			rename(dstpath);
			if(vflag) print("%s renamed\n", dstpath);
		}
		f = 1;
		free(dd);
	}
	/*	here destination is file or none
	*	if file, protection check has been already done	*/

	sfd = open(srcpath, OREAD);
	if(sfd < 0){
		fprint(2,"# open error: %s %r\n", srcpath);
		goto L0;
	}
	sd = dirfstat(sfd);
	if(!sd){ // something wrong
		fprint(2,"# cannot read stat: %s %r\n", srcpath);
		goto L1;
	}
	if(sd->mode & DMDIR){ //illegal usage
		fprint(2,"# bug of this program: %s\n",srcpath);
		goto L2;
	}

	if(vflag && !f)
		print("creating %s\n", dstpath);

	dfd = create(dstpath, OWRITE, 0777);
	if(dfd < 0){
		char *p;
		int status;
		char err[ERRMAX];
		errstr(err,ERRMAX);
		if(strstr(err,"permission")){
			/*	we have not permission to write	*/
			fprint(2,"# %s: %s\n",dstpath,err);
			goto L2;
		}
		/*	then the failure comes from the absence of
		*	intermediate path. we try mkdir */
		p = strrchr(dstpath,'/');
		if(p){
			*p = 0;
			status = mkdir(dstpath,uid,gid);
			*p = '/';
			if(status == 0){
				/* try again */
				dfd = create(dstpath, OWRITE, 0777);
			}
		}
	}
	if(dfd < 0){
		fprint(2,"# unable to create %s: %r\n", dstpath);
		goto L2;
	}

	if(copyfile(sfd,dfd) < 0){
		fprint(2, "# write error: %s: %r\n", dstpath);
		goto L3;
	}

	nulldir(&ndd);
	setugidd(&ndd,uid,gid);
	if(cpattr(sd,&ndd) > 0 && dirfwstat(dfd,&ndd)<0)
		fprint(2, "# can't wstat %s: %r\n", dstpath);
L3:	close(dfd);
L2:	free(sd);
L1:	close(sfd);
L0:	return;
}

int
rmfile(char *path, char *uid, char *gid)
{
	int status;
	debug("rmfile %s\n", path);
	if(protectedf(path,uid,gid))
		status = -1;
	else
	if((status = remove(path)) < 0)
		fprint(2, "# %s not removed: %r", path);
	debug("done rmfile %s %d\n", path, status);
	return status;
}

int
rmdir(char *path, char *uid, char *gid)
{
	char *name;
	int fd;
	Dir *db;
	int status;
	long i,n;

	debug("rmdir %s\n", path);
	fd = open(path, OREAD);
	if(fd == -1){
		fprint(2,"# %s not open: %r\n",path);
		return -1;
	}
	n = dirreadall(fd,&db);
	close(fd);
	if(n == -1)
		return -1;

	for(i=0; i<n; i++){
		name = mkpath2(path, db[i].name);
		if(db[i].mode & DMDIR)
			rmdir(name, uid, gid);
		else
			rmfile(name, uid, gid);
		free(name);
	}

	status = remove(path);
	free(db);
	debug("done rmdir %s\n", path);
	return status;
}