SmbProcessResult
smbresponsesend(SmbSession *s)
{
uchar cmd;
SmbProcessResult pr;
assert(smbbufferoffsetgetb(s->response, 4, &cmd));
smbloglock();
smblogprint(cmd, "sending:\n");
smblogdata(cmd, smblogprint, smbbufferreadpointer(s->response), smbbufferreadspace(s->response), 256);
smblogunlock();
if (s->nbss) {
NbScatterGather a[2];
a[0].p = smbbufferreadpointer(s->response);
a[0].l = smbbufferreadspace(s->response);
a[1].p = nil;
nbssgatherwrite(s->nbss, a);
pr = SmbProcessResultOk;
}
else if (s->cifss) {
ulong l = smbbufferreadspace(s->response);
uchar nl[4];
hnputl(nl, l);
write(s->cifss->fd, nl, 4);
write(s->cifss->fd, smbbufferreadpointer(s->response), l);
pr = SmbProcessResultOk;
}
else
pr = SmbProcessResultDie;
smbbufferreset(s->response);
return pr;
}
int
smbtransactionrespond(SmbTransaction *t, SmbHeader *h, SmbPeerInfo *p, SmbBuffer *ob, SmbTransactionMethod *method, void *magic,
char **errmsgp)
{
/* generate one or more responses */
while (smbbufferreadspace(t->out.parameters) || smbbufferreadspace(t->out.data)) {
assert(method->encoderesponse);
if (!(*method->encoderesponse)(t, h, p, ob, errmsgp))
return 0;
assert(method->sendresponse);
if (!(*method->sendresponse)(magic, ob, errmsgp))
return 0;
}
return 1;
}
int
smbbuffercopy(SmbBuffer *to, SmbBuffer *from, ulong amount)
{
if (smbbufferreadspace(from) < amount)
return 0;
if (smbbufferputbytes(to, smbbufferreadpointer(from), amount)) {
assert(smbbuffergetbytes(from, nil, amount));
return 1;
}
return 0;
}
int
smbtransactionnbdgramsend(void *magic, SmbBuffer *ob, char **errmsgp)
{
NbDgramSendParameters *p = magic;
//print("sending to %B\n", p->to);
//nbdumpdata(smbbufferreadpointer(ob), smbbufferreadspace(ob));
if (!nbdgramsend(p, smbbufferreadpointer(ob), smbbufferreadspace(ob))) {
smbstringprint(errmsgp, "dgram send failed");
return 0;
}
return 1;
}
int
smbclienttrans2(SmbClient *c, uchar scount, ushort *setup, SmbBuffer *inparam, SmbBuffer *outparam, SmbBuffer *outdata, SmbHeader *rh, char **errmsgp)
{
SmbTransaction transaction;
SmbHeader h;
memset(&transaction, 0, sizeof(transaction));
transaction.in.scount = scount;
transaction.in.setup = setup;
transaction.in.parameters = smbbufferreadpointer(inparam);
transaction.in.tpcount = smbbufferreadspace(inparam);
transaction.in.maxpcount = smbbufferwritespace(outparam);
transaction.in.maxdcount = smbbufferwritespace(outdata);
transaction.out.parameters = outparam;
transaction.out.data = outdata;
h = c->protoh;
h.tid = c->sharetid;
h.mid = 0;
return smbtransactionexecute(&transaction, &h, &c->peerinfo, c->b, &method, c, rh, errmsgp);
}
int
smbclientrap(SmbClient *c, SmbBuffer *inparam, SmbBuffer *outparam, SmbBuffer *outdata,
char **errmsgp)
{
SmbTransaction transaction;
SmbHeader h;
memset(&transaction, 0, sizeof(transaction));
transaction.in.name = smbglobals.pipelanman;
transaction.in.parameters = smbbufferreadpointer(inparam);
transaction.in.tpcount = smbbufferreadspace(inparam);
transaction.in.maxpcount = smbbufferwritespace(outparam);
transaction.in.maxdcount = smbbufferwritespace(outdata);
transaction.out.parameters = outparam;
transaction.out.data = outdata;
h = c->protoh;
h.tid = c->ipctid;
h.mid = 0;
return smbtransactionexecute(&transaction, &h, &c->peerinfo, c->b, &smbtransactionmethodrap, c, nil, errmsgp);
}
SmbProcessResult
smbcomecho(SmbSession *s, SmbHeader *h, uchar *pdata, SmbBuffer *b)
{
ushort echocount, e;
if (!smbcheckwordcount("comecho", h, 1))
return SmbProcessResultFormat;
echocount = smbnhgets(pdata);
for (e = 0; e < echocount; e++) {
ulong bytecountfixupoffset;
SmbProcessResult pr;
if (!smbbufferputheader(s->response, h, &s->peerinfo)
|| !smbbufferputs(s->response, e))
return SmbProcessResultMisc;
bytecountfixupoffset = smbbufferwriteoffset(s->response);
if (!smbbufferputbytes(s->response, smbbufferreadpointer(b), smbbufferreadspace(b))
|| !smbbufferfixuprelatives(s->response, bytecountfixupoffset))
return SmbProcessResultMisc;
pr = smbresponsesend(s);
if (pr != SmbProcessResultOk)
return SmbProcessResultDie;
}
return SmbProcessResultOk;
}
int
smbclienttrans2findfirst2(SmbClient *c, ushort searchcount, char *filename,
ushort *sidp, ushort *searchcountp, ushort *endofsearchp,SmbFindFileBothDirectoryInfo *ip, char **errmsgp)
{
int rv;
ushort setup;
SmbBuffer *inparam;
SmbBuffer *outparam;
SmbBuffer *outdata;
SmbHeader rh;
setup = SMB_TRANS2_FIND_FIRST2;
inparam = smbbuffernew(512);
smbbufferputs(inparam, 0x16);
smbbufferputs(inparam, searchcount);
smbbufferputs(inparam, 7);
smbbufferputs(inparam, SMB_FIND_FILE_BOTH_DIRECTORY_INFO);
smbbufferputl(inparam, 0);
smbbufferputstring(inparam, &c->peerinfo, 0, filename);
outparam = smbbuffernew(10);
outdata = smbbuffernew(65535);
rv = smbclienttrans2(c, 1, &setup, inparam, outparam, outdata, &rh, errmsgp);
smbbufferfree(&inparam);
if (rv) {
ushort eaerroroffset, lastnameoffset;
ulong nextentry;
int i;
if (!smbbuffergets(outparam, sidp)
|| !smbbuffergets(outparam, searchcountp)
|| !smbbuffergets(outparam, endofsearchp)
|| !smbbuffergets(outparam, &eaerroroffset)
|| !smbbuffergets(outparam, &lastnameoffset)) {
smbstringprint(errmsgp, "smbclienttrans2findfirst2: not enough parameters returned");
rv = 0;
goto done;
}
nextentry = 0;
smblogprint(-1, "returned data:\n");
smblogdata(-1, smblogprint, smbbufferreadpointer(outdata), smbbufferreadspace(outdata), 256);
for (i = 0; i < *searchcountp; i++) {
SmbFindFileBothDirectoryInfo *info = ip + i;
ulong neo, filenamelength, easize;
uchar shortnamelength;
if (i && !smbbufferreadskipto(outdata, nextentry)) {
underflow:
smbstringprint(errmsgp, "smbclientrans2findfirst2: not enough data returned");
rv = 0;
goto done;
}
if (!smbbuffergetl(outdata, &neo))
goto underflow;
nextentry = smbbufferreadoffset(outdata) + neo - 4;
print("neo 0x%.8lux\n", neo);
if (!smbbuffergetl(outdata, &info->fileindex)
|| !smbbuffergetv(outdata, &info->creationtime)
|| !smbbuffergetv(outdata, &info->lastaccesstime)
|| !smbbuffergetv(outdata, &info->lastwritetime)
|| !smbbuffergetv(outdata, &info->changetime)
|| !smbbuffergetv(outdata, &info->endoffile)
|| !smbbuffergetv(outdata, &info->allocationsize))
goto underflow;
print("got here\n");
if (!smbbuffergetl(outdata, &info->extfileattributes)
|| !smbbuffergetl(outdata, &filenamelength)
|| !smbbuffergetl(outdata, &easize)
|| !smbbuffergetb(outdata, &shortnamelength)
|| !smbbuffergetbytes(outdata, nil, 1)
|| !smbbuffergetbytes(outdata, nil, 24)
|| !smbbuffergetstring(outdata, &rh, SMB_STRING_REVPATH, &info->filename))
goto underflow;
print("got here as well\n");
}
}
done:
smbbufferfree(&outparam);
smbbufferfree(&outdata);
return rv;
}
SmbProcessResult
smbcomwrite(SmbSession *s, SmbHeader *h, uchar *pdata, SmbBuffer *b)
{
SmbTree *t;
SmbFile *f;
ushort fid;
ushort count;
ulong offset;
long nb;
ushort yacount;
uchar fmt;
if (h->wordcount != 5)
return SmbProcessResultFormat;
fid = smbnhgets(pdata); pdata += 2;
count = smbnhgets(pdata); pdata += 2;
offset = smbnhgetl(pdata);
smblogprint(SMB_COM_WRITE, "smbcomwrite: fid 0x%.4ux count 0x%.4ux offset 0x%.8lux\n",
fid, count, offset);
if (!smbbuffergetb(b, &fmt)
|| fmt != 1
|| !smbbuffergets(b, &yacount)
|| yacount != count
|| smbbufferreadspace(b) < count)
return SmbProcessResultFormat;
t = smbidmapfind(s->tidmap, h->tid);
if (t == nil) {
smbseterror(s, ERRSRV, ERRinvtid);
return SmbProcessResultError;
}
f = smbidmapfind(s->fidmap, fid);
if (f == nil) {
smbseterror(s, ERRDOS, ERRbadfid);
return SmbProcessResultError;
}
if (!f->ioallowed) {
smbseterror(s, ERRDOS, ERRbadaccess);
return SmbProcessResultError;
}
if (count == 0) {
SmbProcessResult pr = smbtruncatefile(s, f, offset);
if (pr != SmbProcessResultReply)
return pr;
nb = 0;
}
else {
seek(f->fd, offset, 0);
nb = write(f->fd, smbbufferreadpointer(b), count);
if (nb < 0) {
smbseterror(s, ERRDOS, ERRnoaccess);
return SmbProcessResultError;
}
}
h->wordcount = 1;
if (!smbbufferputheader(s->response, h, &s->peerinfo)
|| !smbbufferputs(s->response, nb)
|| !smbbufferputs(s->response, 0))
return SmbProcessResultMisc;
return SmbProcessResultReply;
}
int
_transactionencoderesponse(SmbTransaction *t, SmbHeader *h, SmbPeerInfo *p, SmbBuffer *ob,
uint8_t cmd,
char **errmsgp)
{
SmbHeader mh;
uint32_t countsfixupoffset, bytecountfixupoffset;
int palign, dalign;
uint32_t pbytecount, dbytecount;
uint32_t poffset, doffset;
if (t->in.maxpcount > 65535 || t->in.maxdcount > 65535) {
smbstringprint(errmsgp, "counts too big");
return 0;
}
mh = *h;
mh.wordcount = 10;
mh.flags &= ~SMB_FLAGS_SERVER_TO_REDIR;
mh.command = cmd;
mh.errclass = SUCCESS;
mh.error = SUCCESS;
if (!smbbufferputheader(ob, &mh, p)
|| !smbbufferputs(ob, smbbufferwriteoffset(t->out.parameters))
|| !smbbufferputs(ob, smbbufferwriteoffset(t->out.data))
|| !smbbufferputs(ob, 0)) {
toosmall:
smbstringprint(errmsgp, "output buffer too small");
goto toosmall;
}
countsfixupoffset = smbbufferwriteoffset(ob);
if (!smbbufferputbytes(ob, nil, 6 * sizeof(uint16_t))
|| !smbbufferputb(ob, 0) // scount == 0
|| !smbbufferputb(ob, 0)) // reserved2
goto toosmall;
/* now the byte count */
bytecountfixupoffset = smbbufferwriteoffset(ob);
if (!smbbufferputs(ob, 0))
goto toosmall;
smbbufferwritelimit(ob, smbbufferwriteoffset(ob) + 65535);
palign = bytecountfixupoffset & 1;
if (palign && !smbbufferputb(ob, 0))
goto toosmall;
pbytecount = smbbufferreadspace(t->out.parameters);
if (pbytecount > smbbufferwritespace(ob))
pbytecount = smbbufferwritespace(ob);
poffset = smbbufferwriteoffset(ob);
if (poffset > 65535)
goto toosmall;
if (!smbbufferputbytes(ob, smbbufferreadpointer(t->out.parameters), pbytecount))
goto toosmall;
dalign = smbbufferwritespace(ob) > 0 && (smbbufferwriteoffset(ob) & 1) != 0;
if (dalign && !smbbufferputb(ob, 0))
goto toosmall;
dbytecount = smbbufferreadspace(t->out.data);
if (dbytecount > smbbufferwritespace(ob))
dbytecount = smbbufferwritespace(ob);
doffset = smbbufferwriteoffset(ob);
if (doffset > 65535)
goto toosmall;
if (!smbbufferputbytes(ob, smbbufferreadpointer(t->out.data), dbytecount))
goto toosmall;
if (!smbbufferoffsetputs(ob, bytecountfixupoffset, palign + pbytecount + dalign + dbytecount)
|| !smbbufferoffsetputs(ob, countsfixupoffset, pbytecount)
|| !smbbufferoffsetputs(ob, countsfixupoffset + 2, poffset)
|| !smbbufferoffsetputs(ob, countsfixupoffset + 4, smbbufferreadoffset(t->out.parameters))
|| !smbbufferoffsetputs(ob, countsfixupoffset + 6, dbytecount)
|| !smbbufferoffsetputs(ob, countsfixupoffset + 8, doffset)
|| !smbbufferoffsetputs(ob, countsfixupoffset + 10, smbbufferreadoffset(t->out.data)))
goto toosmall;
assert(smbbufferoffsetputs(ob, bytecountfixupoffset, smbbufferwriteoffset(ob) - bytecountfixupoffset - 2));
smbbuffergetbytes(t->out.parameters, nil, pbytecount);
smbbuffergetbytes(t->out.data, nil, dbytecount);
return 1;
}
int
smbnetserverenum2(SmbClient *c, uint32_t stype, char *domain,
int *entriesp,
SmbRapServerInfo1 **sip, char **errmsgp)
{
int rv;
uint16_t ec, entries, total, converter;
SmbRapServerInfo1 *si = nil;
SmbBuffer *ipb = smbbuffernew(512);
SmbBuffer *odb = smbbuffernew(65535);
SmbBuffer *opb = smbbuffernew(8);
smbbufferputs(ipb, 104);
smbbufferputstring(ipb, nil, SMB_STRING_ASCII, "WrLehDz");
smbbufferputstring(ipb, nil, SMB_STRING_ASCII, "B16BBDz");
smbbufferputs(ipb, 1);
smbbufferputs(ipb, smbbufferwritespace(odb));
smbbufferputl(ipb, stype);
smbbufferputstring(ipb, nil, SMB_STRING_ASCII, domain);
rv = !smbclientrap(c, ipb, opb, odb, errmsgp);
smbbufferfree(&ipb);
if (rv == 0) {
char *remark, *eremark;
int remarkspace;
int i;
if (!smbbuffergets(opb, &ec)
|| !smbbuffergets(opb, &converter)
|| !smbbuffergets(opb, &entries)
|| !smbbuffergets(opb, &total)) {
smbstringprint(errmsgp, "smbnetserverenum2: not enough return parameters");
rv = -1;
goto done;
}
if (ec != 0) {
rv = ec;
goto done;
}
if (smbbufferreadspace(odb) < entries * 26) {
smbstringprint(errmsgp, "smbnetserverenum2: not enough return data");
rv = -1;
goto done;
}
remarkspace = smbbufferreadspace(odb) - entries * 26;
si = smbemalloc(entries * sizeof(SmbRapServerInfo1) + remarkspace);
remark = (char *)&si[entries];
eremark = remark + remarkspace;
for (i = 0; i < entries; i++) {
uint32_t offset;
int remarklen;
assert(smbbuffergetbytes(odb, si[i].name, 16));
assert(smbbuffergetb(odb, &si[i].vmaj));
assert(smbbuffergetb(odb, &si[i].vmin));
assert(smbbuffergetl(odb, &si[i].type));
assert(smbbuffergetl(odb, &offset));
offset -= converter;
if (!smbbufferoffsetcopystr(odb, offset, remark, eremark - remark, &remarklen)) {
smbstringprint(errmsgp, "smbnetserverenum2: invalid string offset");
rv = -1;
goto done;
}
si[i].remark = remark;
remark += remarklen;
}
*sip = si;
si = nil;
*entriesp = entries;
}
else
rv = -1;
done:
free(si);
smbbufferfree(&opb);
smbbufferfree(&odb);
return rv;
}
