ref: 6d429cf9e8418ec69d2516ccba370860e20afd63
dir: /sys/src/cmd/ip/cifsd/smb.c/
#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);
}