#include <u.h>
#include <libc.h>
#include <auth.h>
#include "dat.h"
#include "fns.h"

enum {
	NEGOTIATE_USER_SECURITY = 1,
	NEGOTIATE_ENCRYPT_PASSWORDS = 2,
};

static Chalstate *smbcs;
static int sessionkey;
static int sessionuid;
static int negotiated;

void
smbnegotiate(Req *r, uchar *h, uchar *p, uchar *e)
{
	uchar *d, *de, *c, *ce, dom[256];
	int i, x, mode;
	char *s;

	if(!unpack(h, p, e, "#0b{*2}#1w[]", &d, &de)){
err:
		r->respond(r, STATUS_INVALID_SMB);
		return;
	}
	i = 0;
	x = -1;
	while(unpack(h, d, de, "_f.", smbstrunpack8, &s, &d)){
		if(debug)
			fprint(2, "[%d] %s\n", i, s);
		if(x < 0 && !cistrcmp(s, "NT LM 0.12"))
			x = i;
		free(s);
		i++;
	}
	if(x < 0)
		x = i-1;
	if(x < 0)
		x = 0;
	sessionkey = rand();
	c = ce = nil;
	mode = 0;
	if(needauth){
		if(smbcs != nil)
			auth_freechal(smbcs);
		if(smbcs = auth_challenge("proto=ntlm role=server")){
			c = (uchar*)smbcs->chal;
			ce = c + smbcs->nchal;
			mode = NEGOTIATE_USER_SECURITY | NEGOTIATE_ENCRYPT_PASSWORDS;
		} else
			logit("auth_challenge: %r");
	}

	/*
	 * <89> Section 2.2.4.52.2:  Windows NT servers always send the DomainName
	 *	field in Unicode characters and never add a padding byte for alignment.
	 *	Windows clients ignore the DomainName field in the server response.
	 */
	d = dom;
	de = dom + smbstrpack16(d, d, d + sizeof(dom), domain);
	if(!pack(r->rh, r->rp, r->re, "#0b{*2wbwwllllvw#2b}#1w{[][]}.",
		x, mode, 50, 1, BUFFERSIZE, 0x10000, sessionkey,
		CAP_UNICODE | CAP_LARGEFILES | 
		CAP_NT_FIND | CAP_NT_SMBS | CAP_NT_STATUS,
		tofiletime(time(0)), -tzoff/60, c, ce, d, de, &r->rp))
		goto err;
	negotiated = 1;
	r->respond(r, 0);
}

enum {
	SMB_SETUP_GUEST = 1,
	SMB_SETUP_USE_LANMAN_KEY = 2,
};

void
smbsessionsetupandx(Req *r, uchar *h, uchar *p, uchar *e)
{
	uchar *lm, *lme, *nt, *nte, *xp;
	char *user, *dom, *os, *lanman;
	int xcmd, cap, bs, sk;
	AuthInfo *ai;

	user = dom = os = lanman = nil;
	if(!unpack(h, p, e, "#0b{*2b_@4ww____l#2w#3w____l}#1w{[][]ffff}{?.}",
		&xcmd, &bs, &sk, &cap, &lm, &lme, &nt, &nte,
		r->o->strunpack, &user, r->o->strunpack, &dom,
		r->o->strunpack, &os, r->o->strunpack, &lanman, &xp)){
		r->respond(r, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if(debug)
		fprint(2, "bs=%x cap=%x user=%s dom=%s os=%s lanman=%s\n",
			bs, cap, user, dom, os, lanman);
	if(sk != sessionkey)
		logit("ignoring bad session key");
	while(!remoteuser){
		if(needauth){
			MSchapreply *mcr;

			if(smbcs == nil || strlen(user) == 0)
				break;
			smbcs->user = user;
			smbcs->dom = dom;
			smbcs->nresp = (nte - nt)+sizeof(*mcr)-sizeof(mcr->NTresp);
			if(smbcs->nresp < sizeof(*mcr))
				smbcs->nresp = sizeof(*mcr);
			mcr = mallocz(smbcs->nresp, 1);
			if((lme - lm) <= sizeof(mcr->LMresp))
				memmove(mcr->LMresp, lm, lme - lm);
			if((nte - nt) > 0)
				memmove(mcr->NTresp, nt, nte - nt);
			smbcs->resp = mcr;
			ai = auth_response(smbcs);
			if(ai == nil){
				logit("auth_response: %r");
				free(mcr);
				break;	/* allow retry with the same challenge */
			}
			if(auth_chuid(ai, nil) < 0)
				logit("auth_chuid: %r");
			auth_freeAI(ai);
			auth_freechal(smbcs);
			smbcs = nil;
			free(mcr);
		}
		remoteuser = getuser();
		logit("auth successfull");
		break;
	}
	sessionuid = (namehash(getuser()) & 0x7FFF) | 1;
	r->uid = sessionuid;
	if(bs >= 1024 || bs <= BUFFERSIZE)
		remotebuffersize = bs;
	if(!pack(r->rh, r->rp, r->re, "#0b{*2b_@2ww}#1w{fff}{.}",
		xcmd, remoteuser ? 0 : SMB_SETUP_GUEST,
		r->o->strpack, osname, r->o->strpack, progname,
		r->o->strpack, domain, &r->rp))
		r->respond(r, STATUS_INVALID_SMB);
	else
		smbcmd(r, xcmd, h, xp, e);
out:
	free(user);
	free(dom);
	free(lanman);
	free(os);
}

void
smblogoffandx(Req *r, uchar *h, uchar *p, uchar *e)
{
	int xcmd;
	uchar *xp;

	if(!unpack(h, p, e, "#0b{*2b_}#1w{}{?.}", &xcmd, &xp)){
unsup:
		r->respond(r, STATUS_NOT_SUPPORTED);
		return;
	}
	logit("logoff");
	if(remoteuser && needauth)
		goto unsup;
	logoff();
	remoteuser = nil;
	r->tid = 0xFFFF;
	r->uid = 0;
	if(!pack(r->rh, r->rp, r->re, "#0b{*2b_}#1w{}{.}", xcmd, &r->rp))
		r->respond(r, STATUS_INVALID_SMB);
	else
		smbcmd(r, xcmd, h, xp, e);
}

enum {
	SMB_SUPPORT_SEARCH_BITS = 1,
};

void
smbtreeconnectandx(Req *r, uchar *h, uchar *p, uchar *e)
{
	int err, xcmd, flags;
	char *path, *service;
	uchar *pw, *pwe, *xp;
	Tree *t;

	path = service = nil;
	if(!unpack(h, p, e, "#0b{*2b_@3ww#2w}#1w{[]ff}{?.}",
		&xcmd, &flags, &pw, &pwe, r->o->strunpack, &path,
		smbstrunpack8, &service, &xp)){
		r->respond(r, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if(r->flags & 1){
		disconnecttree(r->tid);
		r->tid = 0xFFFF;
	}
	if((t = connecttree(service, path, &err)) == nil){
		r->respond(r, err);
		goto out;
	}
	if(!pack(r->rh, r->rp, r->re, "#0b{*2b_@2ww}#1w{ff}{.}",
		xcmd, SMB_SUPPORT_SEARCH_BITS, 
		smbstrpack8, t->share->service,
		r->o->strpack, t->share->fsname, &r->rp)){
		disconnecttree(t->tid);
		r->respond(r, STATUS_INVALID_SMB);
	} else {
		r->tid = t->tid;
		smbcmd(r, xcmd, h, xp, e);
	}
out:
	free(service);
	free(path);
}

enum {
	READ_WRITE_LOCK = 0x00,
	SHARED_LOCK = 0x01,
	OPLOCK_RELEASE = 0x02,
	CHANGE_LOCKTYPE = 0x04,
	CANCEL_LOCK = 0x08,
	LARGE_FILES = 0x10,
};

void
smblockingandx(Req *r, uchar *h, uchar *p, uchar *e)
{
	int i, err, xcmd, fid, tol, timeout, nunlock, nlock, pid;
	unsigned int loff, hoff, llen, hlen;
	uchar *d, *de, *xp;
	vlong off, len;
	File *f;

	f = nil;
	if(!unpack(h, p, e, "#0b{*2b_@2wwb_lww}#1w[]{?.}",
		&xcmd, &fid, &tol, &timeout, &nunlock, &nlock, &d, &de, &xp)){
unsup:
		r->respond(r, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if((f = getfile(r->tid, fid, nil, &err)) == nil){
		r->respond(r, err);
		goto out;
	}
	if(debug)
		fprint(2, "tol %x\ntimeout %d\nunnlock %d\nnlock %d\n", tol, timeout, nunlock, nlock);
	if(tol & (SHARED_LOCK | CHANGE_LOCKTYPE))
		goto unsup;
	for(i=0; i<nunlock+nlock; i++){
		if(tol & LARGE_FILES){
			if(!unpack(d, d, de, "w__llll[]", &pid, &hoff, &loff, &hlen, &llen, &d, nil))
				goto unsup;
		} else {
			if(!unpack(d, d, de, "wll[]", &pid, &loff, &llen, &d, nil))
				goto unsup;
			hoff = hlen = 0;
		}
		off = (vlong)hoff<<32 | loff;
		len = (vlong)hlen<<32 | llen;
		if(debug)
			fprint(2, "%s %x %llux %llux\n", (i < nunlock) ? "unlock" : "lock", pid, off, len);
	}
	if(!pack(r->rh, r->rp, r->re, "#0b{*2b_@2w}#1w{}{.}", xcmd, &r->rp))
		r->respond(r, STATUS_INVALID_SMB);
	else
		smbcmd(r, xcmd, h, xp, e);
out:
	putfile(f);
}

enum {
	REQ_ATTRIB = 0x01,
	REQ_OPLOCK = 0x02,
	REQ_OPLOCK_BATCH = 0x04,
};

void
smbopenandx(Req *r, uchar *h, uchar *p, uchar *e)
{
	int err, nfid, xcmd, flags, amode, omode, fattr, act, csize, ctime;
	char *name, *path;
	uchar *xp;
	Tree *t;
	File *f;
	Dir *d;

	static int amode2dacc[] = {
		[0x00] GENERIC_READ,
		[0x01] GENERIC_WRITE,
		[0x02] GENERIC_READ | GENERIC_WRITE,
		[0x03] GENERIC_EXECUTE,
	}, amode2sacc[] = {
		[0x00] FILE_SHARE_COMPAT, /* compat */
		[0x01] FILE_SHARE_NONE, /* exclusive use */
		[0x02] FILE_SHARE_READ, /* deny write */
		[0x03] FILE_SHARE_WRITE, /* deny read */
		[0x04] FILE_SHARE_READ | FILE_SHARE_WRITE, /* shared read/write */
		[0x05] -1,
		[0x06] -1,
		[0x07] -1,
	}, omode2cdisp[] = {
		[0x00] -1,
		[0x01] FILE_OPEN,
		[0x02] FILE_OVERWRITE,
		[0x03] -1,
		[0x10] FILE_CREATE,
		[0x11] FILE_OPEN_IF,
		[0x12] FILE_OVERWRITE_IF,
		[0x13] -1,
	};

	f = nil;
	d = nil;
	name = path = nil;
	if(!unpack(h, p, e, "#0b{*2b_@2www__wlwl________}#1w{f}{?.}",
		&xcmd, &flags, &amode, &fattr, &ctime, &omode,
		&csize, r->o->nameunpack, &name, &xp)){
		r->respond(r, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if((path = getpath(r->tid, name, &t, &err)) == nil)
		goto errout;
	if((f = createfile(path, r->namecmp,
		amode2dacc[amode & 3],  amode2sacc[(amode>>4) & 7],  omode2cdisp[omode & 0x13],
		FILE_NON_DIRECTORY_FILE, (ulong)csize, fattr, 
		&act, (flags & REQ_ATTRIB) ? &d : nil, &err)) == nil){
errout:
		r->respond(r, err);
		goto out;
	}
	nfid = newfid(t, f);
	amode = -1;
	if(f->dacc & READMASK)
		amode += 1;
	if(f->dacc & WRITEMASK)
		amode += 2;
	if(!pack(r->rh, r->rp, r->re, "#0b{*2b_@2wwwllww__w______}#1w{}{.}",
		xcmd, nfid,
		!d ? 0 : dosfileattr(d),
		!d ? 0 : d->mtime+tzoff,
		!d ? 0 : filesize32(d->length),
		!d ? 0 : amode, 
		!d ? 0 : f->rtype,
		!d ? 0 : act, &r->rp)){
		delfid(t, nfid);
		r->respond(r, STATUS_INVALID_SMB);
	} else
		smbcmd(r, xcmd, h, xp, e);
out:
	free(name);
	free(path);
	putfile(f);
	free(d);
}

enum {
	NT_CREATE_REQUEST_OPLOCK = 0x02,
	NT_CREATE_REQUEST_OPBATCH = 0x04,
	NT_CREATE_OPEN_TARGET_DIR = 0x08,
};

void
smbntcreatendx(Req *r, uchar *h, uchar *p, uchar *e)
{
	int err, nfid, xcmd, flags, rootfid, fattr, dacc, sacc, cdisp, copt, act;
	char *name, *path;
	vlong csize;
	uchar *xp;
	Tree *t;
	File *f;
	Dir *d;

	f = nil;
	d = nil;
	name = path = nil;
	if(!unpack(h, p, e, "#0b{*2b_@2w___lllvllll_____}#1w{f}{?.}",
		&xcmd, &flags, &rootfid, &dacc, &csize, &fattr, &sacc, &cdisp, &copt,
		r->o->nameunpack, &name, &xp)){
		r->respond(r, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if(rootfid){
		if((f = getfile(r->tid, rootfid, &t, &err)) == nil)
			goto errout;
		path = conspath(f->path, name);
		putfile(f);
	} else if((path = getpath(r->tid, name, &t, &err)) == nil)
		goto errout;
	if((f = createfile(path, r->namecmp, dacc, sacc, cdisp, copt, csize, fattr, &act, &d, &err)) == nil){
errout:
		r->respond(r, err);
		goto out;
	}
	nfid = newfid(t, f);
	if(!pack(r->rh, r->rp, r->re, "#0b{*2b_@2wbwlvvvvlvvw__b}#1w{}{.}",
		xcmd, 0, nfid, act, tofiletime(d->mtime), tofiletime(d->atime),
		tofiletime(d->mtime), tofiletime(d->mtime), extfileattr(d),
		allocsize(d->length, t->share->blocksize), 
		d->length, f->rtype, (d->qid.type & QTDIR) != 0, &r->rp)){
		delfid(t, nfid);
		r->respond(r, STATUS_INVALID_SMB);
	} else
		smbcmd(r, xcmd, h, xp, e);
out:
	free(name);
	free(path);
	putfile(f);
	free(d);
}

void
smbreadandx(Req *r, uchar *h, uchar *p, uchar *e)
{
	int n, xcmd, fid, mincount, maxcount;
	unsigned int loff, hoff;
	uchar *rb, *rp, *re, *xp;
	vlong off;
	File *f;

	f = nil;
	hoff = 0;
	if((unpack(h, p, e, "#0b{*2b_@2wwlww______l}#1w{}{?.}",
		&xcmd, &fid, &loff, &mincount, &maxcount, &hoff, &xp) == 0) &&
	   (unpack(h, p, e, "#0b{*2b_@2wwlww______}#1w{}{?.}",
		&xcmd, &fid, &loff, &mincount, &maxcount, &xp) == 0)){
		r->respond(r, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if((f = getfile(r->tid, fid, nil, &n)) == nil){
		r->respond(r, n);
		goto out;
	}
	if((f->fd < 0) || (f->dacc & READMASK) == 0){
		r->respond(r, STATUS_ACCESS_DENIED);
		goto out;
	}
	/* dont really pack, just to get the pointer to the response data */
	if(!pack(r->rh, r->rp, r->re, "#0b{*2________________________}#1w{%2.}", &rb)){
badsmb:
		r->respond(r, STATUS_INVALID_SMB);
		goto out;
	}
	re = rb + mincount;
	if(re > r->re)
		goto badsmb;
	if(maxcount > mincount){
		re = rb + maxcount;
		if(re > r->re)
			re = r->re;
	}
	n = 0;
	rp = rb;
	off = (vlong)hoff<<32 | loff;
	while(rp < re){
		if((n = pread(f->fd, rp, re - rp, off)) <= 0)
			break;
		off += n;
		rp += n;
	}
	if(n < 0){
		r->respond(r, smbmkerror());
		goto out;
	}
	if(!pack(r->rh, r->rp, r->re, "#0b{*2b_@3www__#2w@2w__________}#1w{%2[]}{.}",
		xcmd, 0xFFFF, 0x0000, rb, rp, &r->rp))
		goto badsmb;
	smbcmd(r, xcmd, h, xp, e);
out:
	putfile(f);
}

void
smbwriteandx(Req *r, uchar *h, uchar *p, uchar *e)
{
	int n, xcmd, fid, bufoff, buflen;
	unsigned int loff, hoff;
	uchar *d, *de, *xp;
	File *f;

	f = nil;
	hoff = 0;
	if((unpack(h, p, e, "#0b{*2b_@2wwl__________wwl}#1w{}{?.}",
		&xcmd, &fid, &loff, &buflen, &bufoff, &hoff, &xp) == 0) &&
	   (unpack(h, p, e, "#0b{*2b_@2wwl__________ww}#1w{}{?.}",
		&xcmd, &fid, &loff, &buflen, &bufoff, &xp) == 0)){
		r->respond(r, STATUS_NOT_SUPPORTED);
		goto out;
	}
	d = h + bufoff;
	de = d + buflen;
	if(d < h || de > e){
badsmb:
		r->respond(r, STATUS_INVALID_SMB);
		goto out;
	}
	if((f = getfile(r->tid, fid, nil, &n)) == nil){
		r->respond(r, n);
		goto out;
	}
	if((f->fd < 0) || (f->dacc & WRITEMASK) == 0){
		r->respond(r, STATUS_ACCESS_DENIED);
		goto out;
	}
	if((n = pwrite(f->fd, d, de - d, (vlong)hoff<<32 | loff)) < 0){
		r->respond(r, smbmkerror());
		goto out;
	}
	if(!pack(r->rh, r->rp, r->re, "#0b{*2b_@2www____}#1w{}{.}", xcmd, n, 0xFFFF, &r->rp))
		goto badsmb;
	smbcmd(r, xcmd, h, xp, e);
out:
	putfile(f);
}

void
smbwrite(Req *r, uchar *h, uchar *p, uchar *e)
{
	int n, fid, count, bf;
	unsigned int off;
	uchar *d, *de;
	File *f;

	f = nil;
	if(!unpack(h, p, e, "#0b{*2wwl__}#1w{b#2w[]}", &fid, &count, &off, &bf, &d, &de)){
unsup:
		r->respond(r, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if(bf != 0x1)
		goto unsup;
	if((f = getfile(r->tid, fid, nil, &n)) == nil){
		r->respond(r, n);
		goto out;
	}
	if((f->fd < 0) || (f->dacc & WRITEMASK) == 0){
		r->respond(r, STATUS_ACCESS_DENIED);
		goto out;
	}
	if(count != (de - d)){
		r->respond(r, STATUS_INVALID_SMB);
		goto out;
	}
	if((n = pwrite(f->fd, d, count, off)) < 0){
		r->respond(r, smbmkerror());
		goto out;
	}
	if(!pack(r->rh, r->rp, r->re, "#0b{*2w}#1w{}.", n, &r->rp))
		r->respond(r, STATUS_INVALID_SMB);
	else
		r->respond(r, 0);
out:
	putfile(f);
}

void
smbcloseflush(Req *r, uchar *h, uchar *p, uchar *e)
{
	int err, fid;
	Tree *t;
	Find *s;
	File *f;

	f = nil;
	s = nil;
	if(!unpack(h, p, e, "#0b{*2w}#1w{}", &fid)){
		r->respond(r, STATUS_NOT_SUPPORTED);
		goto out;
	}
	switch(r->cmd){
	case 0x05: /* SMB_COM_FLUSH */
		if(fid == 0xFFFF){
			if(gettree(r->tid) == nil){
				r->respond(r, STATUS_SMB_BAD_TID);
				goto out;
			}
			break;
		}
		/* no break */
	case 0x04: /* SMB_COM_CLOSE */
		if((f = getfile(r->tid, fid, &t, &err)) == nil){
			r->respond(r, err);
			goto out;
		}
		if(r->cmd == 0x04) 
			delfid(t, fid);
		break;
	case 0x34: /* SMB_COM_FIND_CLOSE2 */
		if((s = getfind(r->tid, fid, &t, &err)) == nil){
			r->respond(r, err);
			goto out;
		}
		delsid(t, fid);
		break;
	}
	if(!pack(r->rh, r->rp, r->re, "#0b{*2}#1w{}.", &r->rp))
		r->respond(r, STATUS_INVALID_SMB);
	else
		r->respond(r, 0);
out:
	putfile(f);
	putfind(s);
}

void
smbcreatedirectory(Req *r, uchar *h, uchar *p, uchar *e)
{
	char *name, *path;
	int err, fd;

	name = path = nil;
	if(!unpack(h, p, e, "#0b{*2}#1w{_f}", r->o->nameunpack, &name)){
		r->respond(r, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if((path = getpath(r->tid, name, nil, &err)) == nil){
		r->respond(r, err);
		goto out;
	}
	if(access(path, AEXIST) == 0){
		r->respond(r, STATUS_OBJECT_NAME_COLLISION);
		goto out;
	}
	if((fd = create(path, OREAD, DMDIR | 0777)) < 0){
		r->respond(r, smbmkerror());
		goto out;
	}
	close(fd);
	if(!pack(r->rh, r->rp, r->re, "#0b{*2}#1w{}.", &r->rp))
		r->respond(r, STATUS_INVALID_SMB);
	else
		r->respond(r, 0);
out:
	free(name);
	free(path);
}

void
smbrename(Req *r, uchar *h, uchar *p, uchar *e)
{
	char *name1, *name2, *path1, *path2, *x, *y;
	int err, sattr;
	Dir *d, nd;

	d = nil;
	name1 = name2 = path1 = path2 = nil;
	if(!unpack(h, p, e, "#0b{*2w}#1w{_f_f}", &sattr,
		r->o->nameunpack, &name1, r->o->nameunpack, &name2)){
		r->respond(r, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if((path1 = getpath(r->tid, name1, nil, &err)) == nil){
		r->respond(r, err);
		goto out;
	}
	if((path2 = getpath(r->tid, name2, nil, &err)) == nil){
		r->respond(r, err);
		goto out;
	}
	if((d = xdirstat(&path1, r->namecmp)) == nil){
		r->respond(r, smbmkerror());
		goto out;
	}
	if(!matchattr(d, sattr)){
		r->respond(r, STATUS_NO_SUCH_FILE);
		goto out;
	}

	if(x = strrchr(path1, '/')){
		*x = 0;
	} else {
badpath:
		r->respond(r, STATUS_OBJECT_PATH_SYNTAX_BAD);
		goto out;
	}
	if(y = strrchr(path2, '/'))
		*y++ = 0;
	else
		goto badpath;
	if(r->namecmp(path1, path2)){
		r->respond(r, STATUS_NOT_SAME_DEVICE);
		goto out;
	}
	*x = '/';
	nulldir(&nd);
	nd.name = y;
	if(dirwstat(path1, &nd) < 0){
		r->respond(r, smbmkerror());
		goto out;
	}
	if(!pack(r->rh, r->rp, r->re, "#0b{*2}#1w{}.", &r->rp))
		r->respond(r, STATUS_INVALID_SMB);
	else
		r->respond(r, 0);
	xdirflush(path1, r->namecmp);
out:
	free(name1);
	free(name2);
	free(path1);
	free(path2);
	free(d);
}

void
smbdelete(Req *r, uchar *h, uchar *p, uchar *e)
{
	char *name, *path, *tmp;
	int n, err, i, sattr;
	Find *f;
	Dir *d;

	f = nil;
	name = path = nil;
	if(!unpack(h, p, e, "#0b{*2w}#1w{_f}", &sattr, r->o->nameunpack, &name)){
		r->respond(r, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if((path = getpath(r->tid, name, nil, &err)) == nil){
errout:
		r->respond(r, err);
		goto out;
	}
	if((f = openfind(path, r->namecmp, sattr, 0, &err)) == nil)
		goto errout;
	n = 0;
	while((i = readfind(f, f->index, &d)) >= 0){
		tmp = conspath(f->base, d->name);
		if(remove(tmp) < 0){
			err = smbmkerror();
			free(tmp);
			goto errout;
		}
		free(tmp);
		f->index = i+1;
		n++;
	}
	if(n == 0){
		err = STATUS_NO_SUCH_FILE;
		goto errout;
	}
	if(!pack(r->rh, r->rp, r->re, "#0b{*2}#1w{}.", &r->rp))
		r->respond(r, STATUS_INVALID_SMB);
	else
		r->respond(r, 0);
out:
	free(name);
	free(path);
	putfind(f);
}

void
smbdeletedirectory(Req *r, uchar *h, uchar *p, uchar *e)
{
	char *name, *path;
	Dir *d;
	int err;

	name = path = nil;
	if(!unpack(h, p, e, "#0b{*2}#1w{_f}", r->o->nameunpack, &name)){
		r->respond(r, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if((path = getpath(r->tid, name, nil, &err)) == nil){
		r->respond(r, err);
		goto out;
	}
	if(remove(path) < 0){
		err = smbmkerror();
		if((d = xdirstat(&path, r->namecmp)) == nil){
			r->respond(r, err);
			goto out;
		}
		free(d);
		if(remove(path) < 0){
			r->respond(r, smbmkerror());
			goto out;
		}
	}
	if(!pack(r->rh, r->rp, r->re, "#0b{*2}#1w{}.", &r->rp))
		r->respond(r, STATUS_INVALID_SMB);
	else
		r->respond(r, 0);
out:
	free(name);
	free(path);
}

void
smbecho(Req *r, uchar *h, uchar *p, uchar *e)
{
	uchar *t, *d, *de;
	int i, n;

	if(!unpack(h, p, e, "#0b{*2w}#1w[]", &n, &d, &de)){
		r->respond(r, STATUS_NOT_SUPPORTED);
		return;
	}
	if((r->tid != 0xFFFF) && (gettree(r->tid) == nil)){
		r->respond(r, STATUS_SMB_BAD_TID);
		return;
	}
	t = r->rp;
	for(i=0; i < n; i++){
		if(!pack(r->rh, r->rp, r->re, "#0b{*2w}#1w[].", i, d, de, &r->rp)){
			r->respond(r, STATUS_INVALID_SMB);
			break;
		}
		r->respond(r, 0);
		r->rp = t;
	}
}

void
smbdisconnecttree(Req *r, uchar *h, uchar *p, uchar *e)
{
	int err;

	if(!unpack(h, p, e, "#0b{*2}#1w{}")){
		r->respond(r, STATUS_NOT_SUPPORTED);
		return;
	}
	if(err = disconnecttree(r->tid)){
		r->respond(r, err);
		return;
	}
	if(!pack(r->rh, r->rp, r->re, "#0b{*2}#1w{}.", &r->rp))
		r->respond(r, STATUS_INVALID_SMB);
	else
		r->respond(r, 0);
}

void
smbqueryinformation(Req *r, uchar *h, uchar *p, uchar *e)
{
	char *name, *path;
	int err, mtime;
	Dir *d;

	d = nil;
	name = path = nil;
	if(!unpack(h, p, e, "#0b{*2}#1w{_f}", r->o->nameunpack, &name)){
		r->respond(r, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if((path = getpath(r->tid, name, nil, &err)) == nil){
		r->respond(r, err);
		goto out;
	}
	if((d = xdirstat(&path, r->namecmp)) == nil){
		r->respond(r, smbmkerror());
		goto out;
	}
	mtime = d->mtime + tzoff;
	if(!pack(r->rh, r->rp, r->re, "#0b{*2wll__________}#1w{}.",
		dosfileattr(d), mtime, filesize32(d->length), &r->rp))
		r->respond(r, STATUS_INVALID_SMB);
	else
		r->respond(r, 0);
out:
	free(name);
	free(path);
	free(d);
}

void
smbsetinformation(Req *r, uchar *h, uchar *p, uchar *e)
{
	char *name, *path;
	int err, attr, mtime;
	Dir *d, nd;

	d = nil;
	name = path = nil;
	if(!unpack(h, p, e, "#0b{*2wl__________}#1w{_f}", &attr, &mtime, r->o->nameunpack, &name)){
		r->respond(r, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if((path = getpath(r->tid, name, nil, &err)) == nil){
		r->respond(r, err);
		goto out;
	}
	if((d = xdirstat(&path, r->namecmp)) == nil){
		r->respond(r, smbmkerror());
		goto out;
	}
	nulldir(&nd);
	if(mtime)
		nd.mtime = mtime-tzoff;
	nd.mode = d->mode;
	if(attr & ATTR_READONLY){
		if(nd.mode & 0222)
			nd.mode &= ~0222;
	}else{
		if((nd.mode & 0222) == 0)
			nd.mode |= 0222;
	}
	if(attr & ATTR_ARCHIVE)
		nd.mode &= ~DMTMP;
	else
		nd.mode |= DMTMP;
	if(nd.mode == d->mode)
		nd.mode = ~0;
	if(dirwstat(path, &nd) < 0){
		r->respond(r, smbmkerror());
		goto out;
	}
	if(!pack(r->rh, r->rp, r->re, "#0b{*2}#1w{}.", &r->rp))
		r->respond(r, STATUS_INVALID_SMB);
	else
		r->respond(r, 0);
	xdirflush(path, r->namecmp);
out:
	free(name);
	free(path);
	free(d);
}

void
smbcheckdirectory(Req *r, uchar *h, uchar *p, uchar *e)
{
	char *name, *path;
	int err;
	Dir *d;

	d = nil;
	name = path = nil;
	if(!unpack(h, p, e, "#0b{*2}#1w{_f}", r->o->nameunpack, &name)){
		r->respond(r, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if((path = getpath(r->tid, name, nil, &err)) == nil){
		r->respond(r, err);
		goto out;
	}
	if((d = xdirstat(&path, r->namecmp)) == nil){
		r->respond(r, smbmkerror());
		goto out;
	}
	if((d->qid.type & QTDIR) == 0){
		r->respond(r, STATUS_OBJECT_PATH_NOT_FOUND);
		goto out;
	}
	if(!pack(r->rh, r->rp, r->re, "#0b{*2}#1w{}.", &r->rp))
		r->respond(r, STATUS_INVALID_SMB);
	else
		r->respond(r, 0);
out:
	free(name);
	free(path);
	free(d);
}

void
smbqueryinformation2(Req *r, uchar *h, uchar *p, uchar *e)
{
	int err, fid, adate, atime, mdate, mtime;
	Tree *t;
	File *f;
	Dir *d;

	f = nil;
	t = nil;
	d = nil;
	if(!unpack(h, p, e, "#0b{*2w}#1w{}", &fid)){
		r->respond(r, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if((f = getfile(r->tid, fid, &t, &err)) == nil){
		r->respond(r, err);
		goto out;
	}
	if((d = statfile(f)) == nil){
		r->respond(r, smbmkerror());
		goto out;
	}
	todatetime(d->atime+tzoff, &adate, &atime);
	todatetime(d->mtime+tzoff, &mdate, &mtime);
	if(!pack(r->rh, r->rp, r->re, "#0b{*2wwwwwwllw}#1w{}.",
		mdate, mtime, adate, atime, mdate, mtime,
		filesize32(d->length), filesize32(allocsize(d->length, t->share->blocksize)),
		dosfileattr(d), &r->rp))
		r->respond(r, STATUS_INVALID_SMB);
	else
		r->respond(r, 0);
out:
	putfile(f);
	free(d);
}

void
smbqueryinformationdisk(Req *r, uchar *h, uchar *p, uchar *e)
{
	Tree *t;
	Share *s;

	if(!unpack(h, p, e, "#0b{*2}#1w{}")){
		r->respond(r, STATUS_NOT_SUPPORTED);
		return;
	}
	if((t = gettree(r->tid)) == nil){
		r->respond(r, STATUS_SMB_BAD_TID);
		return;
	}
	s = t->share;
	if(!pack(r->rh, r->rp, r->re, "#0b{*2wwww__}#1w{}.",
		(int)(allocsize(s->allocsize + s->freesize, s->blocksize) / s->blocksize),
		s->blocksize / s->sectorsize, s->sectorsize,
		(int)(allocsize(s->freesize, s->blocksize) / s->blocksize), &r->rp))
		r->respond(r, STATUS_INVALID_SMB);
	else
		r->respond(r, 0);
}

static int
fpackdir(Req *r, Dir *d, Tree *t, int i, int level, uchar *b, uchar *p, uchar *e, uchar **prevoff, uchar **nameoff)
{
	vlong atime, mtime, alen, dlen;
	uchar shortname[2*12];
	uchar *namep;
	Share *share;
	int n;

	share = t->share;
	dlen = d->length;
	alen = allocsize(dlen, share->blocksize);
	atime = tofiletime(d->atime);
	mtime = tofiletime(d->mtime);
	memset(shortname, 0, sizeof(shortname));

	switch(level){
	case 0x0101:	/* SMB_FIND_FILE_DIRECTORY_INFO */
		n = pack(b, p, e, "llvvvvvvl#0l{.f}%4",
			0, i, mtime, atime, mtime, mtime, dlen, alen, extfileattr(d),
			&namep, r->o->untermnamepack, d->name);
		break;

	case 0x0102:	/* SMB_FIND_FILE_FULL_DIRECTORY_INFO */
		n = pack(b, p, e, "llvvvvvvl#0ll{.f}%4",
			0, i, mtime, atime, mtime, mtime, dlen, alen, extfileattr(d), 0,
			&namep, r->o->untermnamepack, d->name);
		break;

	case 0x0103:	/* SMB_FIND_FILE_NAMES_INFO */
		n = pack(b, p, e, "ll#0l{.f}%4",
			0, i, &namep, r->o->untermnamepack, d->name);
		break;

	case 0x0104:	/* SMB_FIND_FILE_BOTH_DIRECTORY_INFO */
		n = pack(b, p, e, "llvvvvvvl#1l#2lb_[]{.f}{}____%4",
			0, i, mtime, atime, mtime, mtime, dlen, alen, extfileattr(d),
			0, shortname, shortname+sizeof(shortname),
			&namep, r->o->untermnamepack, d->name);
		break;

	default:
		logit("[%.4x] unknown FIND infolevel", level);
		return -1;
	}
	if(n <= 0)
		return 0;
	if(nameoff)
		*nameoff = namep;
	if(prevoff && *prevoff)
		pack(b, *prevoff, e, "l", (int)(p - *prevoff));
	if(prevoff)
		*prevoff = p;
	return n;
}

static int
qpackdir(Req *, Dir *d, Tree *t, File *f, int level, uchar *b, uchar *p, uchar *e)
{
	vlong atime, mtime, dlen, alen;
	int link, delete, isdir;
	Share *share;

	if(debug)
		fprint(2, "QYERY level %.4x\n", level);

	share = t->share;
	dlen = d->length;
	alen = allocsize(dlen, share->blocksize);
	atime = tofiletime(d->atime);
	mtime = tofiletime(d->mtime);
	isdir = (d->qid.type & QTDIR) != 0;
	delete = f && deletedfile(f);
	link = !delete;

	switch(level){
	case 0x0101:	/* SMB_QUERY_FILE_BASIC_INFO */
		return pack(b, p, e, "vvvvl____", mtime, atime, mtime, mtime, extfileattr(d));

	case 0x0102:	/* SMB_QUERY_FILE_STANDARD_INFO */
		return pack(b, p, e, "vvlbb", alen, dlen, link, delete, isdir);

	case 0x0103:	/* SMB_QUERY_FILE_EA_INFO */
		return pack(b, p, e, "l", 0);

	case 0x0107:	/* SMB_QUERY_FILE_ALL_INFO */
		return pack(b, p, e, "vvvvl____vvlbb__#1l#0l{f}{}", 
			mtime, atime, mtime, mtime, extfileattr(d), alen, dlen, link,  delete, isdir,
			smbuntermnamepack16, d->name);

	case 0x0109:	/* SMB_QUERY_FILE_STREAM_INFO */
		if(isdir)
			return 0;
		return pack(b, p, e, "l#0lvv{f}", 0, dlen, alen, smbuntermstrpack16, "::$DATA");

	default:
		logit("[%.4x] unknown QUERY infolevel", level);
		return -1;
	}
}

void
trans2querypathinformation(Trans *t)
{
	char *name, *path;
	Tree *tree;
	int n, level;
	Dir *d;

	d = nil;
	path = name = nil;
	if(!unpack(t->in.param.b, t->in.param.p, t->in.param.e, "w____f",
		&level, t->o->nameunpack, &name)){
		t->respond(t, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if((path = getpath(t->r->tid, name, &tree, &n)) == nil){
		t->respond(t, n);
		goto out;
	}
	if((d = xdirstat(&path, t->namecmp)) == nil){
		t->respond(t, smbmkerror());
		goto out;
	}
	pack(t->out.param.b, t->out.param.p, t->out.param.e, "__.", &t->out.param.p);
	if((n = qpackdir(t->r, d, tree, nil, level, t->out.data.b, t->out.data.p, t->out.data.e)) < 0)
		t->respond(t, STATUS_OS2_INVALID_LEVEL);
	else {
		t->out.data.p += n;
		t->respond(t, 0);
	}
out:
	free(name);
	free(path);
	free(d);
}

void
trans2queryfileinformation(Trans *t)
{
	int n, fid, level;
	Tree *tree;
	File *f;
	Dir *d;

	f = nil;
	d = nil;
	if(!unpack(t->in.param.b, t->in.param.p, t->in.param.e, "ww", &fid, &level)){
		t->respond(t, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if((f = getfile(t->r->tid, fid, &tree, &n)) == nil){
		t->respond(t, n);
		goto out;
	}
	if((d = statfile(f)) == nil){
		t->respond(t, smbmkerror());
		goto out;
	}
	pack(t->out.param.b, t->out.param.p, t->out.param.e, "__.", &t->out.param.p);
	if((n = qpackdir(t->r, d, tree, f, level, t->out.data.b, t->out.data.p, t->out.data.e)) < 0)
		t->respond(t, STATUS_OS2_INVALID_LEVEL);
	else {
		t->out.data.p += n;
		t->respond(t, 0);
	}
out:
	putfile(f);
	free(d);
}

static int
setfilepathinformation(Req *r, Dir *d, File *f, char *path, int level, uchar *b, uchar *p, uchar *e)
{
	int attr, adt, atm, mdt, mtm, delete;
	vlong len, atime, mtime;
	Dir nd;

	nulldir(&nd);
	if(debug)
		fprint(2, "SET level %.4x\n", level);
	switch(level){
	case 0x0001:	/* SMB_INFO_STANDARD */
		if(!unpack(b, p, e, "____wwww__________", &adt, &atm, &mdt, &mtm))
			goto unsup;
		nd.atime = fromdatetime(adt, atm)-tzoff;
		nd.mtime = fromdatetime(mdt, mtm)-tzoff;
		break;

	case 0x0101:	/* SMB_SET_FILE_BASIC_INFO */
		if(f == nil || !unpack(b, p, e, "________vv________l____", &atime, &mtime, &attr))
			goto unsup;
		if(atime && atime != -1LL)
			nd.atime = fromfiletime(atime);
		if(mtime && mtime != -1LL)
			nd.mtime = fromfiletime(mtime);
		if(attr){
			if(attr & ATTR_READONLY){
				if(d->mode & 0222)
					nd.mode = d->mode & ~0222;
			} else {
				if((d->mode & 0222) == 0)
					nd.mode = d->mode | 0222;
			}
		}
		break;

	case 0x0102:	/* SMB_SET_FILE_DISPOSITION_INFO */
		if(f == nil || !unpack(b, p, e, "b", &delete))
			goto unsup;
		if((f->dacc & FILE_DELETE) == 0)
			return STATUS_ACCESS_DENIED;
		deletefile(f, delete);
		break;

	case 0x0103:	/* SMB_SET_FILE_ALLOCATION_INFO */
	case 0x0104:	/* SMB_SET_FILE_END_OF_FILE_INFO */
		if(f == nil || !unpack(b, p, e, "v", &len))
			goto unsup;
		if(d->qid.type & QTDIR)
			return STATUS_OS2_INVALID_ACCESS;
		if(len != -1LL)
			nd.length = len;
		break;

	default:
		logit("[%.4x] unknown SET infolevel", level);
		return STATUS_OS2_INVALID_LEVEL;
	unsup:
		return STATUS_NOT_SUPPORTED;
	}
	if(debug)
		fprint(2, "wstat\nmode %lo\natime %ld\nmtime %ld\nlength %llux\n",
			nd.mode, nd.atime, nd.mtime, nd.length);
	if(((f && f->fd >= 0) ? dirfwstat(f->fd, &nd) : dirwstat(path, &nd)) < 0)
		return smbmkerror();
	xdirflush(path, r->namecmp);
	return 0;
}

void
trans2setpathinformation(Trans *t)
{
	int err, level;
	Tree *tree;
	char *name, *path;
	Dir *d;

	d = nil;
	name = path = nil;
	if(!unpack(t->in.param.b, t->in.param.p, t->in.param.e, "w____f", &level, 
		t->o->nameunpack, &name)){
		t->respond(t, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if((path = getpath(t->r->tid, name, &tree, &err)) == nil)
		goto errout;
	if((d = xdirstat(&path, t->namecmp)) == nil){
		t->respond(t, smbmkerror());
		goto out;
	}
	if(err = setfilepathinformation(t->r, d, nil, path, level, t->in.data.b, t->in.data.p, t->in.data.e)){
errout:
		t->respond(t, err);
		goto out;
	}
	pack(t->out.param.b, t->out.param.p, t->out.param.e, "__.", &t->out.param.p);
	t->respond(t, 0);
out:
	free(name);
	free(path);
	free(d);
}

void
trans2setfileinformation(Trans *t)
{
	int err, fid, level;
	Tree *tree;
	File *f;
	Dir *d;

	f = nil;
	d = nil;
	if(!unpack(t->in.param.b, t->in.param.p, t->in.param.e, "ww__", &fid, &level)){
		t->respond(t, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if((f = getfile(t->r->tid, fid, &tree, &err)) == nil)
		goto errout;
	if((d = statfile(f)) == nil){
		t->respond(t, smbmkerror());
		goto out;
	}
	if(err = setfilepathinformation(t->r, d, f, f->path, level, t->in.data.b, t->in.data.p, t->in.data.e)){
errout:
		t->respond(t, err);
		goto out;
	}
	pack(t->out.param.b, t->out.param.p, t->out.param.e, "__.", &t->out.param.p);
	t->respond(t, 0);
out:
	putfile(f);
	free(d);
}

enum {
	FILE_CASE_SENSITIVE_SEARCH = 1,
	FILE_CASE_PRESERVED_NAMES = 2,
	FILE_UNICODE_ON_DISK = 4,
};

void
trans2queryfsinformation(Trans *t)
{
	int n, level;
	Share *share;
	Tree *tree;
	char *s;

	s = nil;
	if(!unpack(t->in.param.b, t->in.param.p, t->in.param.e, "w", &level)){
		t->respond(t, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if((tree = gettree(t->r->tid)) == nil){
		t->respond(t, STATUS_SMB_BAD_TID);
		goto out;
	}
	share = tree->share;
	if(debug)
		fprint(2, "FS level %.4x\n", level);
	switch(level){
	case 0x0001:	/* SMB_INFO_ALLOCATION */
		n = pack(t->out.data.b, t->out.data.p, t->out.data.e, "llllw", 
			0x00000000, share->blocksize/share->sectorsize,
			filesize32(allocsize(share->allocsize+share->freesize, share->blocksize)/share->blocksize),
			filesize32(allocsize(share->freesize, share->blocksize)/share->blocksize),
			share->sectorsize);
		break;

	case 0x0002:	/* SMB_INFO_VOLUME */
		s = smprint("%.12s", share->name);
		n = pack(t->out.data.b, t->out.data.p, t->out.data.e, "l#0b{f}",
			(int)namehash(share->root), smbuntermstrpack8, s);
		break;

	case 0x0102:	/* SMB_QUERY_FS_VOLUME_INFO */
		s = smprint("%.12s", share->name);
		n = pack(t->out.data.b, t->out.data.p, t->out.data.e, "vl#0l__{f}",
			tofiletime(starttime), (int)namehash(share->root), smbuntermstrpack16, s);
		break;

	case 0x0103:	/* SMB_QUERY_FS_SIZE_INFO */
		n = pack(t->out.data.b, t->out.data.p, t->out.data.e, "vvll", 
			allocsize(share->allocsize+share->freesize, share->blocksize)/share->blocksize,
			allocsize(share->freesize, share->blocksize)/share->blocksize, 
			share->blocksize/share->sectorsize,
			share->sectorsize);
		break;

	case 0x0105:	/* SMB_QUERY_FS_ATTRIBUTE_INFO */
		n = pack(t->out.data.b, t->out.data.p, t->out.data.e, "ll#0l{f}", 
			FILE_CASE_SENSITIVE_SEARCH |
			FILE_CASE_PRESERVED_NAMES |
			FILE_UNICODE_ON_DISK,
			share->namelen, smbuntermstrpack16, share->fsname);
		break;

	default:
		logit("[%.4x] unknown FS infolevel", level);
		t->respond(t, STATUS_OS2_INVALID_LEVEL);
		goto out;
	}
	if(n <= 0)
		t->respond(t, STATUS_INVALID_SMB);
	else {
		t->out.data.p += n;
		t->respond(t, 0);
	}
out:
	free(s);
}

enum {
	SMB_FIND_CLOSE_AFTER_REQUEST = 0x1,
	SMB_FIND_CLOSE_AT_EOS = 0x2,
	SMB_FIND_RETURN_RESUME_KEYS = 0x4,
	SMB_FIND_CONTINUE_FROM_LAST = 0x8,
};

void
trans2findfirst2(Trans *t)
{
	int i, nsid, eos, n, attr, count, flags, level;
	uchar *prevoff, *nameoff;
	char *name, *path;
	Tree *tree;
	Find *f;
	Dir *d;

	f = nil;
	name = path = nil;
	if(!unpack(t->in.param.b, t->in.param.p, t->in.param.e, "wwww____f", 
		&attr, &count, &flags, &level, t->o->nameunpack, &name)){
		t->respond(t, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if(debug)
		fprint(2, "FIND level %.4x\n", level);
	if((path = getpath(t->r->tid, name, &tree, &n)) == nil){
		t->respond(t, n);
		goto out;
	}
	if((f = openfind(path, t->namecmp, attr, 1, &n)) == nil){
		t->respond(t, n);
		goto out;
	}
	n = eos = 0;
	prevoff = nameoff = nil;
	for(i = 0; i < count; i++){
		if((eos = readfind(f, f->index, &d)) < 0)
			break;
		if((n = fpackdir(t->r, d, tree, 0, level,
			t->out.data.b, t->out.data.p, t->out.data.e, 
			&prevoff, &nameoff)) <= 0)
			break;
		t->out.data.p += n;
		f->index = eos + 1;
	}
	if((n < 0) || (flags & SMB_FIND_CLOSE_AFTER_REQUEST) || 
	   ((flags & SMB_FIND_CLOSE_AT_EOS) && (eos < 0))){
		if(n < 0){
			t->respond(t, STATUS_OS2_INVALID_LEVEL);
			goto out;
		}
		eos = -1;
		nsid = 0;
	} else {
		nsid = newsid(tree, f);
	}
	if(!i && (eos < 0)){
		t->respond(t, STATUS_NO_MORE_FILES);
		goto out;
	}
	if(!pack(t->out.param.b, t->out.param.p, t->out.param.e, "wwwww.",
		nsid, i, (eos < 0), 0, (int)(nameoff - t->out.data.b), &t->out.param.p)){
		t->respond(t, STATUS_INVALID_SMB);
		delsid(tree, nsid);
	} else
		t->respond(t, 0);
out:
	free(name);
	free(path);
	putfind(f);
}

void
trans2findnext2(Trans *t)
{
	int i, n, eos, sid, count, level, index, flags;
	uchar *prevoff, *nameoff;
	char *name;
	Tree *tree;
	Find *f;
	Dir *d;

	f = nil;
	name = nil;
	if(!unpack(t->in.param.b, t->in.param.p, t->in.param.e, "wwwlwf", 
		&sid, &count, &level, &index, &flags, t->o->nameunpack, &name)){
		t->respond(t, STATUS_NOT_SUPPORTED);
		goto out;
	}
	if(debug)
		fprint(2, "FIND level %.4x\n", level);
	if((f = getfind(t->r->tid, sid, &tree, &n)) == nil){
		t->respond(t, n);
		goto out;
	}
	n = eos = 0;
	if((flags & SMB_FIND_CONTINUE_FROM_LAST) == 0){
		f->index = 0;
		while((eos = readfind(f, f->index, &d)) >= 0){
			f->index = eos + 1;
			if(strcmp(name, d->name) == 0)
				break;
		}
	}
	prevoff = nameoff = nil;
	for(i = 0; i < count; i++){
		if((eos = readfind(f, f->index, &d)) < 0)
			break;
		if((n = fpackdir(t->r, d, tree, 0, level,
			t->out.data.b, t->out.data.p, t->out.data.e, 
			&prevoff, &nameoff)) <= 0)
			break;
		t->out.data.p += n;
		f->index = eos + 1;
	}
	if((flags & SMB_FIND_CLOSE_AFTER_REQUEST) || 
	   ((flags & SMB_FIND_CLOSE_AT_EOS) && (eos < 0))){
		delsid(tree, sid);
		eos = -1;
	}
	if(!i && (eos < 0)){
		t->respond(t, STATUS_NO_MORE_FILES);
		goto out;
	}
	if(!pack(t->out.param.b, t->out.param.p, t->out.param.e, "wwww.",
		i, (eos < 0), 0, (int)(nameoff - t->out.data.b), &t->out.param.p))
		t->respond(t, STATUS_INVALID_SMB);
	else
		t->respond(t, 0);
out:
	free(name);
	putfind(f);
}

static void
transrespond(Trans *t, int err)
{
	Req *r;

	r = t->r;
	t->r = nil;
	t->respond = nil;
	if(!err && !pack(r->rh, r->rp, r->re, 
		"#0b{*2ww__#3w@3ww#4w@4ww#1b_[*2]}#2w{%4[]%4[]}.",
		t->out.param.p - t->out.param.b, 
		t->out.data.p - t->out.data.b,
		0, 0,
		t->out.setup.b, t->out.setup.p,
		t->out.param.b, t->out.param.p,
		t->out.data.b, t->out.data.p, &r->rp))
		r->respond(r, STATUS_INVALID_SMB);
	else
		r->respond(r, err);
	free(t->out.param.b);
	free(t->out.data.b);
	free(t->out.setup.b);
}

struct {
	char *name;
	void (*fun)(Trans *t);
} transoptab[] = {
	[0x0000] { "TRANS_RAP", transrap },
}, trans2optab[] = {
	[0x0001] { "TRANS2_FIND_FIRST2", trans2findfirst2 },
	[0x0002] { "TRANS2_FIND_NEXT2", trans2findnext2 },
	[0x0003] { "TRANS2_QUERY_FS_INFORMATION", trans2queryfsinformation },
	[0x0005] { "TRANS2_QUERY_PATH_INFORMATION", trans2querypathinformation },
	[0x0007] { "TRANS2_QUERY_FILE_INFORMATION", trans2queryfileinformation },
	[0x0006] { "TRANS2_SET_PATH_INFORMATION", trans2setpathinformation },
	[0x0008] { "TRANS2_SET_FILE_INFORMATION", trans2setfileinformation },
};

void
smbtransaction(Req *r, uchar *h, uchar *p, uchar *e)
{
	int tpc, tdc, rpc, rdc, rsc;
	uchar *sa, *se, *da, *de, *pa, *pe;
	void (*fun)(Trans *t);
	Trans t;

	t.r = r;
	t.o = r->o;
	t.namecmp = r->namecmp;
	t.cmd = 0;
	t.respond = transrespond;
	if(!unpack(h, p, e, "#0b{*2wwwwb_w______#3w@3w#4w@4w#1b_[*2]}#2w{[?][?]}",
		&tpc, &tdc, &rpc, &rdc, &rsc, &t.flags, &sa, &se, &pa, &pe, &da, &de)){
unsup:
		r->respond(r, STATUS_NOT_SUPPORTED);
		return;
	}
	unpack(sa, sa, se, "w", &t.cmd);

	switch(r->cmd){
	case 0x25:	/* SMB_COM_TRANSACTION */
		if((t.cmd >= nelem(transoptab)) || ((fun = transoptab[t.cmd].fun) == nil)){
			logit("[%.4x] transaction subcommand not implemented", t.cmd);
			goto unsup;
		}
		t.name = transoptab[t.cmd].name;
		break;
	case 0x32:	/* SMB_COM_TRANSACTION2 */
		if((t.cmd >= nelem(trans2optab)) || ((fun = trans2optab[t.cmd].fun) == nil)){
			logit("[%.4x] transaction2 subcommand not implemented", t.cmd);
			goto unsup;
		}
		t.name = trans2optab[t.cmd].name;
		break;
	default:
		goto unsup;
	}

	if((tpc > (pe - pa)) || (tdc > (de - da))){
		logit("[%.4x] %s request truncated", t.cmd, t.name);
		goto unsup;
	}
	if(57+((rsc+1)&~1)+((rpc+3)&~3)+((rdc+3)&~3) > remotebuffersize){
		rdc = remotebuffersize-(57+((rsc+1)&~1)+((rpc+3)&~3)) & ~3;
		if(rdc <= 0){
			logit("[%.4x] %s response doesnt fit in client buffer", t.cmd, t.name);
			goto unsup;
		}
	}

	t.in.param.b = t.in.param.p = pa; t.in.param.e = pe;
	t.in.data.b = t.in.data.p = da; t.in.data.e = de;
	t.in.setup.b = t.in.setup.p = sa; t.in.setup.e = se;

	t.out.param.b = t.out.param.p = t.out.param.e = (rpc > 0) ? malloc(rpc) : nil;
	t.out.param.e += rpc;
	t.out.data.b = t.out.data.p = t.out.data.e = (rdc > 0) ? malloc(rdc) : nil;
	t.out.data.e += rdc;
	t.out.setup.b = t.out.setup.p = t.out.setup.e = (rsc > 0) ? malloc(rsc) : nil;
	t.out.setup.e += rsc;

	if(debug)
		fprint(2, "[%.4x] %s\n", t.cmd, t.name);
	(*fun)(&t);
}

void
smbnoandxcommand(Req *r, uchar *, uchar *, uchar *)
{
	r->respond(r, (r->cmd == 0xFF) ? STATUS_INVALID_SMB : 0);
}

struct {
	char *name;
	void (*fun)(Req *, uchar *, uchar *, uchar *);
} optab[] = {
	[0x00] { "SMB_COM_CREATE_DIRECTORY", smbcreatedirectory },
	[0x01] { "SMB_COM_DELETE_DIRECTORY", smbdeletedirectory },
	[0x04] { "SMB_COM_CLOSE", smbcloseflush },
	[0x05] { "SMB_COM_FLUSH", smbcloseflush },
	[0x06] { "SMB_COM_DELETE", smbdelete },
	[0x07] { "SMB_COM_RENAME", smbrename },
	[0x08] { "SMB_COM_QUERY_INFORMATION", smbqueryinformation },
	[0x09] { "SMB_COM_SET_INFORMATION", smbsetinformation },
	[0x10] { "SMB_CON_CHECK_DIRECTORY", smbcheckdirectory },
	[0x0b] { "SMB_COM_WRITE", smbwrite },
	[0x23] { "SMB_COM_QUERY_INFORMATION2", smbqueryinformation2 },
	[0x24] { "SMB_COM_LOCKING_ANDX", smblockingandx },
	[0x25] { "SMB_COM_TRANSACTION", smbtransaction },
	[0x2b] { "SMB_COM_ECHO", smbecho },
	[0x2d] { "SMB_COM_OPEN_ANDX", smbopenandx },
	[0x2e] { "SMB_COM_READ_ANDX", smbreadandx },
	[0x2f] { "SMB_COM_WRITE_ANDX", smbwriteandx },
	[0x32] { "SMB_COM_TRANSACTION2", smbtransaction },
	[0x34] { "SMB_COM_FIND_CLOSE2", smbcloseflush },
	[0x71] { "SMB_COM_DISCONNECT_TREE", smbdisconnecttree },
	[0x72] { "SMB_COM_NEGOTIATE", smbnegotiate },
	[0x73] { "SMB_COM_SESSION_SETUP_ANX", smbsessionsetupandx },
	[0x74] { "SMB_COM_LOGOFF_ANDX", smblogoffandx },
	[0x75] { "SMB_COM_TREE_CONNECT_ANDX", smbtreeconnectandx },
	[0x80] { "SMB_COM_QUERY_INFORMATION_DISK", smbqueryinformationdisk },
	[0xa2] { "SMB_COM_NT_CREATE_ANDX", smbntcreatendx },
	[0xFF] { "SMB_COM_NO_ANDX_COMMAND", smbnoandxcommand },
};

void
smbcmd(Req *r, int cmd, uchar *h, uchar *p, uchar *e)
{
	if((cmd >= nelem(optab)) || (optab[cmd].fun == nil)){
		logit("[%.2x] command not implemented", cmd);
		r->respond(r, STATUS_NOT_SUPPORTED);
		return;
	}
	r->name = optab[cmd].name;
	if(debug)
		fprint(2, "[%.2x] %s\n", cmd, r->name);
	if((!negotiated && cmd != 0x72) || (negotiated && cmd == 0x72)){
		r->respond(r, STATUS_INVALID_SMB);
		return;
	}
	if(!remoteuser){
		switch(cmd){
		case 0x72: /* SMB_COM_NEGOTIATE */
		case 0x73: /* SMB_COM_SESSION_SETUP_ANX */
		case 0x74: /* SMB_COM_LOGOFF_ANDX */
		case 0xFF: /* SMB_COM_NO_ANDX_COMMAND */
			break;
		default:
			logit("auth not completed in %s request", r->name);
		case 0x75: /* SMB_COM_TREE_CONNECT_ANDX */
			r->respond(r, STATUS_LOGON_FAILURE);
			return;
		}
	} else if(r->uid != sessionuid){
		switch(cmd){
		case 0x73: /* SMB_COM_SESSION_SETUP_ANX */
		case 0x2b: /* SMB_COM_ECHO */
			break;
		default:
			logit("bad uid %.4x in %s request", r->uid, r->name);
			r->respond(r, STATUS_SMB_BAD_UID);
			return;
		}
	}
	(*optab[cmd].fun)(r, h, p, e);
}