int
smbcomtransaction2(SmbSession *s, SmbHeader *h, uint8_t *pdata, SmbBuffer *b)
{
int rv;
char *errmsg;
SmbProcessResult pr = SmbProcessResultDie;
uint16_t op;
errmsg = nil;
rv = smbtransactiondecodeprimary2(&s->transaction, h, pdata, b, &errmsg);
if (rv < 0) {
fmtfail:
pr = SmbProcessResultFormat;
goto done;
}
if (rv == 0) {
h->wordcount = 0;
if (smbbufferputack(s->response, h, &s->peerinfo)) {
pr = SmbProcessResultReply;
s->nextcommand = SMB_COM_TRANSACTION2_SECONDARY;
}
goto done;
}
smblogprint(h->command, "smbcomtransaction2: scount %ud tpcount %lud tdcount %lud maxscount %lud maxpcount %lud maxdcount %lud\n",
s->transaction.in.scount, s->transaction.in.tpcount, s->transaction.in.tdcount,
s->transaction.in.maxscount, s->transaction.in.maxpcount, s->transaction.in.maxdcount);
smbbufferfree(&s->transaction.out.parameters);
smbbufferfree(&s->transaction.out.data);
s->transaction.out.parameters = smbbuffernew(s->transaction.in.maxpcount);
s->transaction.out.data = smbbuffernew(s->transaction.in.maxdcount);
if (s->transaction.in.scount != 1)
goto fmtfail;
op = s->transaction.in.setup[0];
if (op >= smbtrans2optablesize || smbtrans2optable[op].name == nil) {
smblogprint(-1, "smbcomtransaction2: function %d unknown\n", op);
pr = SmbProcessResultUnimp;
goto done;
}
if (smbtrans2optable[op].process == nil) {
smblogprint(-1, "smbcomtransaction2: %s unimplemented\n", smbtrans2optable[op].name);
pr = SmbProcessResultUnimp;
goto done;
}
pr = (*smbtrans2optable[op].process)(s, h);
if (pr == SmbProcessResultReply) {
char *errmsg;
errmsg = nil;
rv = smbtransactionrespond(&s->transaction, h, &s->peerinfo, s->response, &smbtransactionmethod2, s, &errmsg);
if (!rv) {
smblogprint(h->command, "smbcomtransaction2: failed: %s\n", errmsg);
pr = SmbProcessResultMisc;
}
else
pr = SmbProcessResultOk;
}
done:
free(errmsg);
return pr;
}
int
smbcomtransaction(SmbSession *s, SmbHeader *h, uint8_t *pdata, SmbBuffer *b)
{
int rv;
char *errmsg;
SmbProcessResult pr = SmbProcessResultDie;
errmsg = nil;
rv = smbtransactiondecodeprimary(&s->transaction, h, pdata, b, &errmsg);
if (rv < 0) {
pr = SmbProcessResultFormat;
goto done;
}
if (rv == 0) {
h->wordcount = 0;
if (smbbufferputack(s->response, h, &s->peerinfo)) {
pr = SmbProcessResultReply;
s->nextcommand = SMB_COM_TRANSACTION_SECONDARY;
}
goto done;
}
smblogprint(h->command, "smbcomtransaction: %s scount %ud tpcount %lud tdcount %lud maxscount %lud maxpcount %lud maxdcount %lud\n",
s->transaction.in.name, s->transaction.in.scount, s->transaction.in.tpcount, s->transaction.in.tdcount,
s->transaction.in.maxscount, s->transaction.in.maxpcount, s->transaction.in.maxdcount);
smbbufferfree(&s->transaction.out.parameters);
smbbufferfree(&s->transaction.out.data);
s->transaction.out.parameters = smbbuffernew(s->transaction.in.maxpcount);
s->transaction.out.data = smbbuffernew(s->transaction.in.maxdcount);
if (strcmp(s->transaction.in.name, smbglobals.pipelanman) == 0)
pr = smbrap2(s);
else {
smbseterror(s, ERRDOS, ERRbadpath);
pr = SmbProcessResultError;
goto done;
}
if (pr == SmbProcessResultReply) {
char *errmsg;
errmsg = nil;
rv = smbtransactionrespond(&s->transaction, h, &s->peerinfo, s->response, &smbtransactionmethod, s, &errmsg);
if (!rv) {
smblogprint(h->command, "smbcomtransaction: failed: %s\n", errmsg);
pr = SmbProcessResultMisc;
}
else
pr = SmbProcessResultOk;
}
done:
free(errmsg);
return pr;
}
int
smbclientopen(SmbClient *c, uint16_t mode, char *name, uint8_t *errclassp,
uint16_t *errorp,
uint16_t *fidp, uint16_t *attrp, uint32_t *mtimep, uint32_t *sizep,
uint16_t *accessallowedp, char **errmsgp)
{
SmbBuffer *b;
SmbHeader h;
uint32_t bytecountfixup;
int32_t n;
uint8_t *pdata;
uint16_t bytecount;
b = smbbuffernew(65535);
h = c->protoh;
h.tid = c->sharetid;
h.command = SMB_COM_OPEN;
h.wordcount = 2;
smbbufferputheader(b, &h, &c->peerinfo);
smbbufferputs(b, mode);
smbbufferputs(b, 0);
bytecountfixup = smbbufferwriteoffset(b);
smbbufferputs(b, 0);
smbbufferputb(b, 4);
smbbufferputstring(b, &c->peerinfo, SMB_STRING_REVPATH, name);
smbbufferfixuprelatives(b, bytecountfixup);
nbsswrite(c->nbss, smbbufferreadpointer(b), smbbufferwriteoffset(b));
smbbufferreset(b);
n = nbssread(c->nbss, smbbufferwritepointer(b), smbbufferwritespace(b));
if (n < 0) {
smbstringprint(errmsgp, "read error: %r");
smbbufferfree(&b);
return 0;
}
smbbuffersetreadlen(b, n);
if (!smbbuffergetandcheckheader(b, &h, h.command, 7, &pdata, &bytecount, errmsgp)) {
smbbufferfree(&b);
return 0;
}
if (h.errclass) {
*errclassp = h.errclass;
*errorp = h.error;
smbbufferfree(&b);
return 0;
}
*fidp = smbnhgets(pdata); pdata += 2;
*attrp = smbnhgets(pdata); pdata += 2;
*mtimep = smbnhgetl(pdata); pdata += 4;
*sizep = smbnhgets(pdata); pdata += 4;
*accessallowedp = smbnhgets(pdata);
return 1;
}
int
smbsessionwrite(SmbSession *smbs, void *p, int32_t n)
{
SmbHeader h;
SmbOpTableEntry *ote;
uint8_t *pdata;
int rv;
SmbBuffer *b = nil;
uint16_t bytecount;
SmbProcessResult pr;
if (smbs->response == nil)
smbs->response = smbbuffernew(576);
else
smbresponsereset(smbs);
smbs->errclass = SUCCESS;
smbs->error = SUCCESS;
// print("received %ld bytes\n", n);
if (n <= 0)
goto closedown;
b = smbbufferinit(p, p, n);
if (!smbbuffergetheader(b, &h, &pdata, &bytecount)) {
smblogprint(-1, "smb: invalid header\n");
goto closedown;
}
smbloglock();
smblogprint(h.command, "received:\n");
smblogdata(h.command, smblogprint, p, n, 0x1000);
smblogunlock();
ote = smboptable + h.command;
if (ote->name == nil) {
smblogprint(-1, "smb: illegal opcode 0x%.2x\n", h.command);
goto unimp;
}
if (ote->process == nil) {
smblogprint(-1, "smb: opcode %s unimplemented\n", ote->name);
goto unimp;
}
if (smbs->nextcommand != SMB_COM_NO_ANDX_COMMAND
&& smbs->nextcommand != h.command) {
smblogprint(-1, "smb: wrong command - expected %.2x\n", smbs->nextcommand);
goto misc;
}
smbs->nextcommand = SMB_COM_NO_ANDX_COMMAND;
switch (h.command) {
case SMB_COM_NEGOTIATE:
case SMB_COM_SESSION_SETUP_ANDX:
case SMB_COM_TREE_CONNECT_ANDX:
case SMB_COM_ECHO:
break;
default:
if (smbs->state != SmbSessionEstablished) {
smblogprint(-1, "aquarela: command %.2x unexpected\n", h.command);
goto unimp;
}
}
pr = (*ote->process)(smbs, &h, pdata, b);
switch (pr) {
case SmbProcessResultUnimp:
unimp:
smbseterror(smbs, ERRDOS, ERRunsup);
pr = SmbProcessResultError;
break;
case SmbProcessResultFormat:
smbseterror(smbs, ERRSRV, ERRsmbcmd);
pr = SmbProcessResultError;
break;
case SmbProcessResultMisc:
misc:
smbseterror(smbs, ERRSRV, ERRerror);
pr = SmbProcessResultError;
break;
case SmbProcessResultOk:
case SmbProcessResultError:
case SmbProcessResultReply:
case SmbProcessResultDie:
break;
}
if (pr == SmbProcessResultError) {
smblogprint(h.command, "reply: error %d/%d\n", smbs->errclass, smbs->error);
if (!smbresponseputerror(smbs, &h, smbs->errclass, smbs->error))
pr = SmbProcessResultDie;
else
pr = SmbProcessResultReply;
}
else
smblogprint(h.command, "reply: ok\n");
if (pr == SmbProcessResultReply)
rv = smbresponsesend(smbs) == SmbProcessResultOk ? 0 : -1;
else if (pr == SmbProcessResultDie)
rv = -1;
else
rv = 0;
goto done;
closedown:
rv = -1;
done:
if (rv < 0) {
smblogprintif(smbglobals.log.sessions, "shutting down\n");
smbsessionfree(smbs);
}
smbbufferfree(&b);
if (smbglobals.log.poolparanoia)
poolcheck(mainmem);
return rv;
}
void
smbresponseinit(SmbSession *s, ushort maxlen)
{
smbbufferfree(&s->response);
s->response = smbbuffernew(maxlen);
}
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;
}
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;
}
