Adding Aquarela

Signed-off-by: Álvaro Jurado <elbingmiss@gmail.com>

sys/src/cmd/aquarela/alarm.c

@@ -16,22 +16,22 @@
 static struct {
 	int thread;
 	int die;
-	QLock;
+	QLock	qlock;
 	NbnsAlarm *head;
 } alarmlist = { -1 };
 
-#define MaxLong ((1 << (sizeof(long) * 8 - 1)) - 1)
+#define MaxLong ((1 << (sizeof(int32_t) * 4 - 1)) - 1)
 
 void
-alarmist(void *)
+alarmist(void *v)
 {
 	for (;;) {
 		int64_t now;
 		int32_t snooze;
 //print("running\n");
-		qlock(&alarmlist);
+		qlock(&alarmlist.qlock);
 		if (alarmlist.die) {
-			qunlock(&alarmlist);
+			qunlock(&alarmlist.qlock);
 			break;
 		}
 		now = nsec() / 1000000;
@@ -50,7 +50,7 @@ alarmist(void *)
 		else
 			snooze = 60 * 1000;
 //print("snoozing for %ld\n", snooze);
-		qunlock(&alarmlist);
+		qunlock(&alarmlist.qlock);
 		sleep(snooze);
 	}
 }
@@ -75,7 +75,7 @@ nbnsalarmcancel(NbnsAlarm *a)
 {
 	NbnsAlarm **ap;
 	int rv;
-	qlock(&alarmlist);
+	qlock(&alarmlist.qlock);
 	for (ap = &alarmlist.head; *ap && *ap != a; ap = &(*ap)->next)
 		;
 	if (*ap) {
@@ -83,7 +83,7 @@ nbnsalarmcancel(NbnsAlarm *a)
 		if (ap == &alarmlist.head)
 			threadint(alarmlist.thread);
 	}
-	qunlock(&alarmlist);
+	qunlock(&alarmlist.qlock);
 	do {
 		uint32_t v;
 		rv = nbrecv(a->c, &v);
@@ -93,12 +93,12 @@ nbnsalarmcancel(NbnsAlarm *a)
 void
 nbnsalarmend(void)
 {
-	qlock(&alarmlist);
+	qlock(&alarmlist.qlock);
 	if (alarmlist.thread >= 0) {
 		alarmlist.die = 1;
 		threadint(alarmlist.thread);
 	}
-	qunlock(&alarmlist);
+	qunlock(&alarmlist.qlock);
 }
 
 void
@@ -107,7 +107,7 @@ nbnsalarmset(NbnsAlarm *a, uint32_t millisec)
 	NbnsAlarm **ap;
 	nbnsalarmcancel(a);
 	a->expirems = nsec() / 1000000 + millisec;
-	qlock(&alarmlist);
+	qlock(&alarmlist.qlock);
 	for (ap = &alarmlist.head; *ap; ap = &(*ap)->next)
 		if (a->expirems < (*ap)->expirems)
 			break;
@@ -117,7 +117,7 @@ nbnsalarmset(NbnsAlarm *a, uint32_t millisec)
 		alarmlist.thread = proccreate(alarmist, nil, 16384);
 	else
 		threadint(alarmlist.thread);
-	qunlock(&alarmlist);
+	qunlock(&alarmlist.qlock);
 }
 
 void

sys/src/cmd/aquarela/aquarela.c

@@ -116,6 +116,11 @@ smblogunlock();
 		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);
@@ -159,7 +164,7 @@ cifswrite(SmbCifsSession *cifs, void *p, int32_t n)
 }
 
 int
-nbssaccept(void *, NbSession *s, NBSSWRITEFN **writep)
+nbssaccept(void *v, NbSession *s, NBSSWRITEFN **writep)
 {
 	SmbSession *smbs = smbemallocz(sizeof(SmbSession), 1);
 	smbs->nbss = s;

sys/src/cmd/aquarela/build.json

@@ -0,0 +1,21 @@
+{
+	"aquarela": {
+		"Include": [
+			"../cmd.json"
+		],
+		"Install": "/$ARCH/bin",
+		"Libs": [
+			"/sys/src/cmd/aquarela/libsmb.a"
+		],
+		"Post": [
+			"rm -f /sys/src/cmd/aquarela/libsmb.a"
+		],
+		"Projects": [
+			"libsmb.json"
+		],
+		"SourceFilesCmd": [
+			"aquarela.c",
+			"cifscmd.c"
+		]
+	}
+}

sys/src/cmd/aquarela/cifscmd.c

@@ -98,7 +98,7 @@ typedef struct {
 static Cmd cmd[];
 
 static int32_t
-cmdhelp(SmbClient *, int argc, char *argv[])
+cmdhelp(SmbClient *s, int argc, char *argv[])
 {
 	Cmd *cp;
 	char *p;
@@ -212,7 +212,7 @@ threadmain(int argc, char *argv[])
 		if (c == nil)
 			fprint(2, "failed to connect: %s\n", errmsg);
 	}
-	while (ap = Brdline(&bin, '\n')) {
+	while ((ap = Brdline(&bin, '\n'))) {
 		ap[Blinelen(&bin) - 1] = 0;
 		switch (ac = parse(ap, av, nelem(av))) {
 		default:

sys/src/cmd/aquarela/client.c

@@ -114,7 +114,7 @@ threadmain(int argc, char **argv)
 {
 	int broadcast = 1, i, listen137thread, rv;
 	char *ip;
-	uchar ipaddr[IPaddrlen], serveripaddr[IPaddrlen];
+	char ipaddr[IPaddrlen], serveripaddr[IPaddrlen];
 	NbName nbname;
 
 	ARGBEGIN {

sys/src/cmd/aquarela/libsmb.json

@@ -0,0 +1,76 @@
+{
+	"aquarela": {
+		"Include": [
+			"../../lib.json"
+		],
+		"Install": "/sys/src/cmd/aquarela/",
+		"Library": "libsmb.a",
+		"SourceFiles": [
+			"nbnsconv.c",
+			"dump.c",
+			"message.c",
+			"findname.c",
+			"addname.c",
+			"alarm.c",
+			"nbss.c",
+			"nbns.c",
+			"nbname.c",
+			"alloc.c",
+			"nbresolve.c",
+			"smbconv.c",
+			"smbnegotiate.c",
+			"smballoc.c",
+			"smbcommon.c",
+			"smbcomsessionsetupandx.c",
+			"smbstring.c",
+			"smbresponse.c",
+			"smbcomtreeconnectandx.c",
+			"smbtree.c",
+			"smbservice.c",
+			"smbcomtransaction.c",
+			"smbrap2.c",
+			"smbcomdir.c",
+			"smbglobals.c",
+			"smboptable.c",
+			"smbconnect.c",
+			"smbbuffer.c",
+			"nbdgram.c",
+			"nbdgramconv.c",
+			"nbdgramdump.c",
+			"nb.c",
+			"nblistener.c",
+			"smbtransaction.c",
+			"smbbrowse.c",
+			"smbtrans2find.c",
+			"smbidmap.c",
+			"smbcomecho.c",
+			"smbcomopen.c",
+			"smbtime.c",
+			"smbpath.c",
+			"smbfile.c",
+			"smbtrans2query.c",
+			"smbcomclose.c",
+			"smbcomread.c",
+			"smblog.c",
+			"smbcomquery.c",
+			"smbcomfindclose2.c",
+			"smbcomtreedisconnect.c",
+			"smbsharedfile.c",
+			"smblisten.c",
+			"smbrap2client.c",
+			"smbtrans2client.c",
+			"smbcomdelete.c",
+			"smbdircache.c",
+			"smbrep.c",
+			"smbcomflush.c",
+			"smbcomwrite.c",
+			"smbclientopen.c",
+			"smbcomsetinfo.c",
+			"smbcomcreatedir.c",
+			"smbcomdeletedir.c",
+			"smbcomrename.c",
+			"smbcomlocking.c",
+			"smbtrans2set.c"
+		]
+	}
+}

sys/src/cmd/aquarela/nbdgram.c

@@ -15,7 +15,7 @@
 
 static struct {
 	int thread;
-	QLock;
+	QLock	qlock;
 	int fd;
 } udp = { -1 };
 
@@ -29,12 +29,12 @@ struct Listen {
 };
 
 static struct {
-	QLock;
+	QLock	qlock;
 	Listen *head;
 } listens;
 
 static void
-udplistener(void *)
+udplistener(void *v)
 {
 //print("udplistener - starting\n");
 	for (;;) {
@@ -76,7 +76,7 @@ udplistener(void *)
 */
 						break;
 					}
-					qlock(&listens);
+					qlock(&listens.qlock);
 					for (lp = &listens.head; (l = *lp) != nil;) {
 						if (nbnameisany(l->to) || nbnameequal(l->to, s.datagram.dstname)) {
 							switch ((*l->deliver)(l->magic, &s)) {
@@ -94,7 +94,7 @@ udplistener(void *)
 						}
 						lp = &l->next;
 					}
-					qunlock(&listens);
+					qunlock(&listens.qlock);
 					USED(delivered);
 				}
 				default:
@@ -104,25 +104,25 @@ udplistener(void *)
 		}
 	}
 print("udplistener - exiting\n");
-	qlock(&udp);
+	qlock(&udp.qlock);
 	udp.thread = -1;
-	qunlock(&udp);
+	qunlock(&udp.qlock);
 }
 
 static char *
 startlistener(void)
 {
-	qlock(&udp);
+	qlock(&udp.qlock);
 	if (udp.thread < 0) {
 		char *e;
 		e = nbudpannounce(NbDgramPort, &udp.fd);
 		if (e) {
-			qunlock(&udp);
+			qunlock(&udp.qlock);
 			return e;
 		}
 		udp.thread = proccreate(udplistener, nil, 16384);
 	}
-	qunlock(&udp);
+	qunlock(&udp.qlock);
 	return nil;
 }
 
@@ -139,10 +139,10 @@ nbdgramlisten(NbName to, int (*deliver)(void *magic, NbDgram *s), void *magic)
 	nbnamecpy(l->to, to);
 	l->deliver = deliver;
 	l->magic = magic;
-	qlock(&listens);
+	qlock(&listens.qlock);
 	l->next = listens.head;
 	listens.head = l;
-	qunlock(&listens);
+	qunlock(&listens.qlock);
 	return 0;
 }
 
@@ -177,17 +177,17 @@ nbdgramsendto(uint8_t *ipaddr, uint16_t port, NbDgram *s)
 }
 
 static struct {
-	Lock;
-	ushort id;
+	Lock	lock;
+	uint16_t id;
 } id;
 
 static uint16_t
 nextdgramid(void)
 {
 	uint16_t v;
-	lock(&id);
+	lock(&id.lock);
 	v = id.id++;
-	unlock(&id);
+	unlock(&id.lock);
 	return v;
 }
 

sys/src/cmd/aquarela/nbname.c

@@ -221,7 +221,7 @@ struct NbNameTableEntry {
 };
 
 static struct {
-	QLock;
+	QLock	qlock;
 	NbNameTableEntry *head;
 } nbnametable;
 
@@ -230,10 +230,10 @@ nbnametablefind(NbName name, int add)
 {
 	int rv;
 	NbNameTableEntry *p;
-	qlock(&nbnametable);
+	qlock(&nbnametable.qlock);
 	for (p = nbnametable.head; p; p = p->next) {
 		if (nbnameequal(p->name, name)) {
-			qunlock(&nbnametable);
+			qunlock(&nbnametable.qlock);
 			return 1;
 		}
 	}
@@ -246,7 +246,7 @@ nbnametablefind(NbName name, int add)
 	}
 	else
 		rv = 0;
-	qunlock(&nbnametable);
+	qunlock(&nbnametable.qlock);
 	return rv;
 }
 
@@ -259,7 +259,7 @@ struct NbRemoteNameTableEntry {
 };
 
 static struct {
-	QLock;
+	QLock	qlock;
 	NbRemoteNameTableEntry *head;
 } nbremotenametable;
 
@@ -268,7 +268,7 @@ nbremotenametablefind(NbName name, uint8_t *ipaddr)
 {
 	NbRemoteNameTableEntry *p, **pp;
 	int32_t now = time(nil);
-	qlock(&nbremotenametable);
+	qlock(&nbremotenametable.qlock);
 	for (pp = &nbremotenametable.head; (p = *pp) != nil;) {
 		if (p->expire <= now) {
 //print("nbremotenametablefind: expired %B\n", p->name);
@@ -278,12 +278,12 @@ nbremotenametablefind(NbName name, uint8_t *ipaddr)
 		}
 		if (nbnameequal(p->name, name)) {
 			ipmove(ipaddr, p->ipaddr);
-			qunlock(&nbremotenametable);
+			qunlock(&nbremotenametable.qlock);
 			return 1;
 		}
 		pp = &p->next;
 	}
-	qunlock(&nbremotenametable);
+	qunlock(&nbremotenametable.qlock);
 	return 0;
 }
 
@@ -291,7 +291,7 @@ int
 nbremotenametableadd(NbName name, uint8_t *ipaddr, uint32_t ttl)
 {
 	NbRemoteNameTableEntry *p;
-	qlock(&nbremotenametable);
+	qlock(&nbremotenametable.qlock);
 	for (p = nbremotenametable.head; p; p = p->next)
 		if (nbnameequal(p->name, name))
 			break;
@@ -304,6 +304,6 @@ nbremotenametableadd(NbName name, uint8_t *ipaddr, uint32_t ttl)
 	ipmove(p->ipaddr, ipaddr);
 	p->expire = time(nil) + ttl;
 //print("nbremotenametableadd: %B ttl %lu expire %ld\n", p->name, ttl, p->expire);
-	qunlock(&nbremotenametable);
+	qunlock(&nbremotenametable.qlock);
 	return 1;
 }

sys/src/cmd/aquarela/nbns.c

@@ -15,7 +15,7 @@
 
 static struct {
 	int thread;
-	QLock;
+	QLock	qlock;
 	int fd;
 } udp = { -1 };
 
@@ -29,17 +29,17 @@ struct Listen {
 };
 
 static struct {
-	Lock;
-	ushort id;
+	Lock	lock;
+	uint16_t id;
 } id;
 
 struct {
-	QLock;
+	QLock	qlock;
 	NbnsTransaction *head;
 } transactionlist;
 
 static void
-udplistener(void *)
+udplistener(void *v)
 {
 	for (;;) {
 		uint8_t msg[Udphdrsize + 576];
@@ -60,7 +60,7 @@ udplistener(void *)
 //nbnsdumpmessage(s);
 				if (s->response) {
 					NbnsTransaction *t;
-					qlock(&transactionlist);
+					qlock(&transactionlist.qlock);
 					for (t = transactionlist.head; t; t = t->next)
 						if (t->id == s->id)
 							break;
@@ -68,7 +68,7 @@ udplistener(void *)
 						sendp(t->c, s);
 					else
 						nbnsmessagefree(&s);
-					qunlock(&transactionlist);
+					qunlock(&transactionlist.qlock);
 				}
 				else
 					nbnsmessagefree(&s);
@@ -80,17 +80,17 @@ udplistener(void *)
 static char *
 startlistener(void)
 {
-	qlock(&udp);
+	qlock(&udp.qlock);
 	if (udp.thread < 0) {
 		char *e;
 		e = nbudpannounce(NbnsPort, &udp.fd);
 		if (e) {
-			qunlock(&udp);
+			qunlock(&udp.qlock);
 			return e;
 		}
 		udp.thread = proccreate(udplistener, nil, 16384);
 	}
-	qunlock(&udp);
+	qunlock(&udp.qlock);
 	return nil;
 }
 
@@ -98,9 +98,9 @@ uint16_t
 nbnsnextid(void)
 {
 	uint16_t rv;
-	lock(&id);
+	lock(&id.lock);
 	rv = id.id++;
-	unlock(&id);
+	unlock(&id.lock);
 	return rv;
 }
 
@@ -125,10 +125,10 @@ nbnstransactionnew(NbnsMessage *s, uint8_t *ipaddr)
 		free(t);
 		return nil;
 	}
-	qlock(&transactionlist);
+	qlock(&transactionlist.qlock);
 	t->next = transactionlist.head;
 	transactionlist.head = t;
-	qunlock(&transactionlist);
+	qunlock(&transactionlist.qlock);
 	u = (Udphdr *)msg;
 	ipmove(u->laddr, nbglobals.myipaddr);
 	hnputs(u->lport, NbnsPort);
@@ -150,7 +150,7 @@ nbnstransactionfree(NbnsTransaction **tp)
 
 	t = *tp;
 	if (t) {
-		qlock(&transactionlist);
+		qlock(&transactionlist.qlock);
 		while ((s = nbrecvp(t->c)) != nil)
 			nbnsmessagefree(&s);
 		for (tp2 = &transactionlist.head; *tp2 && *tp2 != t; tp2 = &(*tp2)->next)
@@ -159,7 +159,7 @@ nbnstransactionfree(NbnsTransaction **tp)
 			*tp2 = t->next;
 			free(t);
 		}
-		qunlock(&transactionlist);
+		qunlock(&transactionlist.qlock);
 		*tp = nil;
 	}
 }

sys/src/cmd/aquarela/nbss.c

@@ -15,7 +15,7 @@
 
 static struct {
 	int thread;
-	QLock;
+	QLock	qlock;
 	char adir[NETPATHLEN];
 	int acfd;
 	char ldir[NETPATHLEN];
@@ -27,7 +27,7 @@ typedef struct Session Session;
 enum { NeedSessionRequest, Connected, Dead };
 
 struct Session {
-	NbSession;
+	NbSession nbs;
 	int thread;
 	Session *next;
 	int state;
@@ -35,7 +35,7 @@ struct Session {
 };
 
 static struct {
-	QLock;
+	QLock qlock;
 	Session *head;
 } sessions;
 
@@ -50,7 +50,7 @@ struct Listen {
 };
 
 static struct {
-	QLock;
+	QLock qlock;
 	Listen *head;
 } listens;
 
@@ -58,13 +58,13 @@ static void
 deletesession(Session *s)
 {
 	Session **sp;
-	close(s->fd);
-	qlock(&sessions);
+	close(s->nbs.fd);
+	qlock(&sessions.qlock);
 	for (sp = &sessions.head; *sp && *sp != s; sp = &(*sp)->next)
 		;
 	if (*sp)
 		*sp = s->next;
-	qunlock(&sessions);
+	qunlock(&sessions.qlock);
 	free(s);
 }
 
@@ -80,18 +80,18 @@ tcpreader(void *a)
 		uint8_t flags;
 		uint16_t length;
 
-		n = readn(s->fd, buf, 4);
+		n = readn(s->nbs.fd, buf, 4);
 		if (n != 4) {
 		die:
 			free(buf);
 			if (s->state == Connected)
-				(*s->write)(s, nil, -1);
+				(*s->write)(&s->nbs, nil, -1);
 			deletesession(s);
 			return;
 		}
 		flags = buf[1];
 		length = nhgets(buf + 2) | ((flags & 1) << 16);
-		n = readn(s->fd, buf + 4, length);
+		n = readn(s->nbs.fd, buf + 4, length);
 		if (n != length)
 			goto die;
 		if (flags & 0xfe) {
@@ -105,7 +105,7 @@ tcpreader(void *a)
 				goto die;
 			}
 			if (s->state == Connected) {
-				if ((*s->write)(s, buf + 4, length) != 0) {
+				if ((*s->write)(&s->nbs, buf + 4, length) != 0) {
 					s->state = Dead;
 					goto die;
 				}
@@ -124,13 +124,13 @@ tcpreader(void *a)
 			}
 			p = buf + 4;
 			ep = p + length;
-			k = nbnamedecode(p, p, ep, s->to);
+			k = nbnamedecode(p, p, ep, s->nbs.to);
 			if (k == 0) {
 				print("nbss: malformed called name in session request\n");
 				goto die;
 			}
 			p += k;
-			k = nbnamedecode(p, p, ep, s->from);
+			k = nbnamedecode(p, p, ep, s->nbs.from);
 			if (k == 0) {
 				print("nbss: malformed calling name in session request\n");
 				goto die;
@@ -144,38 +144,38 @@ tcpreader(void *a)
 */
 			called_found = 0;
 //print("nbss: called %B calling %B\n", s->to, s->from);
-			qlock(&listens);
+			qlock(&listens.qlock);
 			for (l = listens.head; l; l = l->next)
-				if (nbnameequal(l->to, s->to)) {
+				if (nbnameequal(l->to, s->nbs.to)) {
 					called_found = 1;
-					if (nbnameequal(l->from, s->from))
+					if (nbnameequal(l->from, s->nbs.from))
 						break;
 				}
 			if (l == nil) {
-				qunlock(&listens);
+				qunlock(&listens.qlock);
 				error_code  = called_found ? 0x81 : 0x80;
 			replydie:
 				buf[0] = 0x83;
 				buf[1] = 0;
 				hnputs(buf + 2, 1);
 				buf[4] = error_code;
-				write(s->fd, buf, 5);
+				write(s->nbs.fd, buf, 5);
 				goto die;
 			}
-			if (!(*l->accept)(l->magic, s, &s->write)) {
-				qunlock(&listens);
+			if (!(*l->accept)(l->magic, &s->nbs, &s->write)) {
+				qunlock(&listens.qlock);
 				error_code = 0x83;
 				goto replydie;
 			}
 			buf[0] = 0x82;
 			buf[1] = 0;
 			hnputs(buf + 2, 0);
-			if (write(s->fd, buf, 4) != 4) {
-				qunlock(&listens);
+			if (write(s->nbs.fd, buf, 4) != 4) {
+				qunlock(&listens.qlock);
 				goto die;
 			}
 			s->state = Connected;
-			qunlock(&listens);
+			qunlock(&listens.qlock);
 			break;
 		}
 		case 0x85: /* keep awake */
@@ -192,23 +192,23 @@ createsession(int fd)
 {
 	Session *s;
 	s = nbemalloc(sizeof(Session));
-	s->fd = fd;
+	s->nbs.fd = fd;
 	s->state = NeedSessionRequest;
-	qlock(&sessions);
+	qlock(&sessions.qlock);
 	s->thread = procrfork(tcpreader, s, 32768, RFNAMEG);
 	if (s->thread < 0) {
-		qunlock(&sessions);
+		qunlock(&sessions.qlock);
 		free(s);
 		return nil;
 	}
 	s->next = sessions.head;
 	sessions.head = s;
-	qunlock(&sessions);
-	return s;
+	qunlock(&sessions.qlock);
+	return &s->nbs;
 }
 
 static void
-tcplistener(void *)
+tcplistener(void *v)
 {
 	for (;;) {
 		int dfd;
@@ -219,10 +219,10 @@ tcplistener(void *)
 //print("tcplistener: contact\n");
 		if (lcfd < 0) {
 		die:
-			qlock(&tcp);
+			qlock(&tcp.qlock);
 			close(tcp.acfd);
 			tcp.thread = -1;
-			qunlock(&tcp);
+			qunlock(&tcp.qlock);
 			return;
 		}
 		dfd = accept(lcfd, ldir);
@@ -238,27 +238,27 @@ int
 nbsslisten(NbName to, NbName from,int (*accept)(void *magic, NbSession *s, NBSSWRITEFN **writep), void *magic)
 {
 	Listen *l;
-	qlock(&tcp);
+	qlock(&tcp.qlock);
 	if (tcp.thread < 0) {
 		fmtinstall('B', nbnamefmt);
 		tcp.acfd = announce("tcp!*!netbios", tcp.adir);
 		if (tcp.acfd < 0) {
 			print("nbsslisten: can't announce: %r\n");
-			qunlock(&tcp);
+			qunlock(&tcp.qlock);
 			return -1;
 		}
 		tcp.thread = proccreate(tcplistener, nil, 16384);
 	}
-	qunlock(&tcp);
+	qunlock(&tcp.qlock);
 	l = nbemalloc(sizeof(Listen));
 	nbnamecpy(l->to, to);
 	nbnamecpy(l->from, from);
 	l->accept = accept;
 	l->magic = magic;
-	qlock(&listens);
+	qlock(&listens.qlock);
 	l->next = listens.head;
 	listens.head = l;
-	qunlock(&listens);
+	qunlock(&listens.qlock);
 	return 0;
 }
 
@@ -352,13 +352,13 @@ nbssconnect(NbName to, NbName from)
 		return nil;
 	}
 	s = nbemalloc(sizeof(Session));
-	s->fd = fd;
+	s->nbs.fd = fd;
 	s->state = Connected;
-	qlock(&sessions);
+	qlock(&sessions.qlock);
 	s->next = sessions.head;
 	sessions.head = s;
-	qunlock(&sessions);
-	return s;
+	qunlock(&sessions.qlock);
+	return &s->nbs;
 }
 
 int32_t
@@ -375,7 +375,7 @@ nbssscatterread(NbSession *nbs, NbScatterGather *a)
 		l += ap->l;
 //print("nbssscatterread %ld bytes\n", l);
 again:
-	if (readn(s->fd, hdr, 4) != 4) {
+	if (readn(s->nbs.fd, hdr, 4) != 4) {
 	dead:
 		s->state = Dead;
 		return -1;
@@ -408,7 +408,7 @@ again:
 		if (thistime > ap->l)
 			thistime = ap->l;
 //print("reading %d\n", length);
-		n = readn(s->fd, ap->p, thistime);
+		n = readn(s->nbs.fd, ap->p, thistime);
 		if (n != thistime)
 			goto dead;
 		length -= thistime;

sys/src/cmd/aquarela/netbios.h

@@ -16,12 +16,12 @@ enum {
 };
 
 typedef struct NbnsHdr {
-	uchar name_trn_id[2];
-	uchar ctrl[2];
-	uchar qdcount[2];
-	uchar ancount[2];
-	uchar nscount[2];
-	uchar arcount[2];
+	uint8_t name_trn_id[2];
+	uint8_t ctrl[2];
+	uint8_t qdcount[2];
+	uint8_t ancount[2];
+	uint8_t nscount[2];
+	uint8_t arcount[2];
 } NbnsHdr;
 
 enum {
@@ -69,41 +69,41 @@ enum {
 typedef struct NbnsMessageQuestion NbnsMessageQuestion;
 typedef struct NbnsMessageResource NbnsMessageResource;
 
-typedef uchar NbName[NbNameLen];
-int nbnamedecode(uchar *base, uchar *p, uchar *ep, NbName name);
-int nbnameencode(uchar *p, uchar *ep, NbName name);
+typedef uint8_t NbName[NbNameLen];
+int nbnamedecode(uint8_t *base, uint8_t *p, uint8_t *ep, NbName name);
+int nbnameencode(uint8_t *p, uint8_t *ep, NbName name);
 int nbnameequal(NbName name1, NbName name2);
 void nbnamecpy(NbName n1, NbName n2);
 void nbmknamefromstring(NbName nbname, char *string);
-void nbmknamefromstringandtype(NbName nbname, char *string, uchar type);
+void nbmknamefromstringandtype(NbName nbname, char *string, uint8_t type);
 void nbmkstringfromname(char *buf, int buflen, NbName name);
 
 int nbnamefmt(Fmt *);
 
 struct NbnsMessageQuestion {
 	NbName name;
-	ushort type;
-	ushort class;
+	uint16_t type;
+	uint16_t class;
 	NbnsMessageQuestion *next;
 };
 
-NbnsMessageQuestion *nbnsmessagequestionnew(NbName name, ushort type, ushort class);
+NbnsMessageQuestion *nbnsmessagequestionnew(NbName name, uint16_t type, uint16_t class);
 
 struct NbnsMessageResource {
 	NbName name;
-	ushort type;
-	ushort class;
+	uint16_t type;
+	uint16_t class;
 	uint32_t ttl;
-	ushort rdlength;
-	uchar *rdata;
+	uint16_t rdlength;
+	uint8_t *rdata;
 	NbnsMessageResource *next;
 };
-NbnsMessageResource *nbnsmessageresourcenew(NbName name, ushort type, ushort class,
+NbnsMessageResource *nbnsmessageresourcenew(NbName name, uint16_t type, uint16_t class,
 					    uint32_t ttl, int rdcount,
-					    uchar *rdata);
+					    uint8_t *rdata);
 
 typedef struct NbnsMessage {
-	ushort id;
+	uint16_t id;
 	int response;
 	int opcode;
 	int broadcast;
@@ -121,39 +121,39 @@ typedef struct NbnsMessage {
 NbnsMessage *nbnsmessagenew(void);
 void nbnsmessageaddquestion(NbnsMessage *s, NbnsMessageQuestion *q);
 void nbnsmessageaddresource(NbnsMessageResource **rp, NbnsMessageResource *r);
-NbnsMessage *nbnsconvM2S(uchar *ap, int nap);
+NbnsMessage *nbnsconvM2S(uint8_t *ap, int nap);
 void nbnsmessagefree(NbnsMessage **sp);
 void nbnsdumpmessage(NbnsMessage *s);
-int nbnsconvS2M(NbnsMessage *s, uchar *ap, int nap);
+int nbnsconvS2M(NbnsMessage *s, uint8_t *ap, int nap);
 
 
-NbnsMessage *nbnsmessagenamequeryrequestnew(ushort id, int broadcast, NbName name);
-NbnsMessage *nbnsmessagenameregistrationrequestnew(ushort id, int broadcast, NbName name,
+NbnsMessage *nbnsmessagenamequeryrequestnew(uint16_t id, int broadcast, NbName name);
+NbnsMessage *nbnsmessagenameregistrationrequestnew(uint16_t id, int broadcast, NbName name,
 						   uint32_t ttl,
-						   uchar *ipaddr);
+						   uint8_t *ipaddr);
 
 typedef struct NbnsTransaction NbnsTransaction;
 
 struct NbnsTransaction {
-	ushort id;
+	uint16_t id;
 	Channel *c;
 	NbnsTransaction *next;
 };
-ushort nbnsnextid(void);
+uint16_t nbnsnextid(void);
 
-int nbnsfindname(uchar *serveripaddr, NbName name, uchar *ipaddr,
+int nbnsfindname(uint8_t *serveripaddr, NbName name, uint8_t *ipaddr,
 		 uint32_t *ttlp);
-int nbnsaddname(uchar *serveripaddr, NbName name, uint32_t ttl,
-		uchar *ipaddr);
+int nbnsaddname(uint8_t *serveripaddr, NbName name, uint32_t ttl,
+		uint8_t *ipaddr);
 
-NbnsTransaction *nbnstransactionnew(NbnsMessage *request, uchar *ipaddr);
+NbnsTransaction *nbnstransactionnew(NbnsMessage *request, uint8_t *ipaddr);
 void nbnstransactionfree(NbnsTransaction **tp);
 
 typedef struct NbnsAlarm NbnsAlarm;
 
 struct NbnsAlarm {
 	Channel *c;
-	vlong expirems;
+	int64_t expirems;
 	NbnsAlarm *next;
 };
 
@@ -164,7 +164,7 @@ NbnsAlarm *nbnsalarmnew(void);
 void nbnsalarmend(void);
 
 typedef struct NbSession NbSession;
-typedef int NBSSWRITEFN(NbSession *s, void *buf, long n);
+typedef int NBSSWRITEFN(NbSession *s, void *buf, int32_t n);
 
 struct NbSession {
 	int fd;
@@ -181,35 +181,35 @@ typedef struct NbScatterGather NbScatterGather;
 
 struct NbScatterGather {
 	void *p;
-	long l;
+	int32_t l;
 };
 
 int nbssgatherwrite(NbSession *s, NbScatterGather *a);
-long nbssscatterread(NbSession *, NbScatterGather *a);
-int nbsswrite(NbSession *s, void *buf, long n);
-long nbssread(NbSession *s, void *buf, long n);
+int32_t nbssscatterread(NbSession *, NbScatterGather *a);
+int nbsswrite(NbSession *s, void *buf, int32_t n);
+int32_t nbssread(NbSession *s, void *buf, int32_t n);
 void *nbemalloc(uint32_t);
 
-int nbnameresolve(NbName name, uchar *ipaddr);
+int nbnameresolve(NbName name, uint8_t *ipaddr);
 
-void nbdumpdata(void *data, long datalen);
+void nbdumpdata(void *data, int32_t datalen);
 
 typedef struct NbDgram {
-	uchar type;
-	uchar flags;
-	ushort id;
-	uchar srcip[IPaddrlen];
-	ushort srcport;
+	uint8_t type;
+	uint8_t flags;
+	uint16_t id;
+	uint8_t srcip[IPaddrlen];
+	uint16_t srcport;
 	union {
 		struct {
-			ushort length;
-			ushort offset;
+			uint16_t length;
+			uint16_t offset;
 			NbName srcname;
 			NbName dstname;
-			uchar *data;
+			uint8_t *data;
 		} datagram;
 		struct {
-			uchar code;
+			uint8_t code;
 		} error;
 		struct {
 			NbName dstname;
@@ -234,25 +234,25 @@ enum {
 
 typedef struct NbDgramSendParameters {
 	NbName to;
-	uchar type;
+	uint8_t type;
 } NbDgramSendParameters;
 
-int nbdgramconvM2S(NbDgram *s, uchar *p, uchar *ep);
-int nbdgramconvS2M(uchar *p, uchar *ep, NbDgram *s);
+int nbdgramconvM2S(NbDgram *s, uint8_t *p, uint8_t *ep);
+int nbdgramconvS2M(uint8_t *p, uint8_t *ep, NbDgram *s);
 void nbdgramdump(NbDgram *s);
-int nbdgramsendto(uchar *ipaddr, ushort port, NbDgram *s);
-int nbdgramsend(NbDgramSendParameters *p, unsigned char *data, long datalen);
+int nbdgramsendto(uint8_t *ipaddr, uint16_t port, NbDgram *s);
+int nbdgramsend(NbDgramSendParameters *p, unsigned char *data, int32_t datalen);
 char *nbdgramlisten(NbName to, int (*deliver)(void *magic, NbDgram *s), void *magic);
 
 int nbnametablefind(NbName name, int add);
 int nbnameisany(NbName name);
 
-int nbremotenametablefind(NbName name, uchar *ipaddr);
-int nbremotenametableadd(NbName name, uchar *ipaddr, uint32_t ttl);
+int nbremotenametablefind(NbName name, uint8_t *ipaddr);
+int nbremotenametableadd(NbName name, uint8_t *ipaddr, uint32_t ttl);
 
 typedef struct NbGlobals {
-	uchar myipaddr[IPaddrlen];
-	uchar bcastaddr[IPaddrlen];
+	uint8_t myipaddr[IPaddrlen];
+	uint8_t bcastaddr[IPaddrlen];
 	NbName myname;
 } NbGlobals;
 
@@ -260,6 +260,6 @@ extern NbGlobals nbglobals;
 extern NbName nbnameany;
 
 int nbinit(void);
-char *nbudpannounce(ushort port, int *fdp);
+char *nbudpannounce(uint16_t port, int *fdp);
 
 extern int nbudphdrsize;

sys/src/cmd/aquarela/smb.h

@@ -8,31 +8,31 @@
  */
 
 typedef struct SmbRawHeader {
-	uchar protocol[4];
-	uchar command;
+	uint8_t protocol[4];
+	uint8_t command;
 //	union {
 //		struct {
-//			uchar errorclass;
-//			uchar reserved;
-//			uchar error[2];
+//			uint8_t errorclass;
+//			uint8_t reserved;
+//			uint8_t error[2];
 //		} doserror;
-		uchar status[4];
+		uint8_t status[4];
 //	};
-	uchar flags;
-	uchar flags2[2];
+	uint8_t flags;
+	uint8_t flags2[2];
 //	union {
-		uchar extra[12];
+		uint8_t extra[12];
 //		struct {
-//			uchar pidhigh[2];
-//			uchar securitysignature[8];
+//			uint8_t pidhigh[2];
+//			uint8_t securitysignature[8];
 //		};
 //	};
-	uchar tid[2];
-	uchar pid[2];
-	uchar uid[2];
-	uchar mid[2];
-	uchar wordcount;
-	uchar parameterwords[1];
+	uint8_t tid[2];
+	uint8_t pid[2];
+	uint8_t uid[2];
+	uint8_t mid[2];
+	uint8_t wordcount;
+	uint8_t parameterwords[1];
 } SmbRawHeader;
 
 enum {
@@ -105,7 +105,7 @@ enum {
 	SMB_COM_TRANSACTION2_SECONDARY = 0x33,
 	SMB_COM_FIND_CLOSE2 = 0x34,
 	SMB_COM_FIND_NOTIFY_CLOSE = 0x35,
-/* Used by Xenix/Unix 0x60 - 0x6E */,
+/* Used by Xenix/Unix 0x60 - 0x6E ,*/
 	SMB_COM_TREE_CONNECT = 0x70,
 	SMB_COM_TREE_DISCONNECT = 0x71,
 	SMB_COM_NEGOTIATE = 0x72,

sys/src/cmd/aquarela/smbcomclose.c

@@ -10,7 +10,7 @@
 #include "headers.h"
 
 SmbProcessResult
-smbcomclose(SmbSession *s, SmbHeader *h, uint8_t *pdata, SmbBuffer *)
+smbcomclose(SmbSession *s, SmbHeader *h, uint8_t *pdata, SmbBuffer *sb)
 {
 	SmbTree *t;
 	SmbFile *f;

sys/src/cmd/aquarela/smbcomcreatedir.c

@@ -10,7 +10,7 @@
 #include "headers.h"
 
 SmbProcessResult
-smbcomcreatedirectory(SmbSession *s, SmbHeader *h, uint8_t *, SmbBuffer *b)
+smbcomcreatedirectory(SmbSession *s, SmbHeader *h, uint8_t *l, SmbBuffer *b)
 {
 	int fd;
 	char *path;

sys/src/cmd/aquarela/smbcomdeletedir.c

@@ -10,7 +10,7 @@
 #include "headers.h"
 
 SmbProcessResult
-smbcomdeletedirectory(SmbSession *s, SmbHeader *h, uint8_t *, SmbBuffer *b)
+smbcomdeletedirectory(SmbSession *s, SmbHeader *h, uint8_t *l, SmbBuffer *b)
 {
 	int rv;
 	char *path;

sys/src/cmd/aquarela/smbcomdir.c

@@ -10,7 +10,7 @@
 #include "headers.h"
 
 SmbProcessResult
-smbcomcheckdirectory(SmbSession *s, SmbHeader *h, uint8_t *, SmbBuffer *b)
+smbcomcheckdirectory(SmbSession *s, SmbHeader *h, uint8_t *l, SmbBuffer *b)
 {
 	char *path;
 	Dir *d;

sys/src/cmd/aquarela/smbcomfindclose2.c

@@ -10,7 +10,7 @@
 #include "headers.h"
 
 SmbProcessResult
-smbcomfindclose2(SmbSession *s, SmbHeader *h, uint8_t *pdata, SmbBuffer *)
+smbcomfindclose2(SmbSession *s, SmbHeader *h, uint8_t *pdata, SmbBuffer *b)
 {
 	uint16_t sid;
 	if (!smbcheckwordcount("comfindclose2", h, 1))

sys/src/cmd/aquarela/smbcomflush.c

@@ -11,7 +11,7 @@
 #include <String.h>
 
 SmbProcessResult
-smbcomflush(SmbSession *s, SmbHeader *h, uint8_t *pdata, SmbBuffer *)
+smbcomflush(SmbSession *s, SmbHeader *h, uint8_t *pdata, SmbBuffer *sb)
 {
 	SmbTree *t;
 	SmbFile *f;

sys/src/cmd/aquarela/smbcommon.c

@@ -50,7 +50,7 @@ smbcheckwordandbytecount(char *name, SmbHeader *h, uint16_t wordcount,
 	return 1;
 }
 
-SmbProcessResult
+int
 smbchaincommand(SmbSession *s, SmbHeader *h, uint32_t andxoffsetfixup,
 		uint8_t cmd, uint16_t offset, SmbBuffer *b)
 {
@@ -249,7 +249,7 @@ smbseterror(SmbSession *s, uint8_t errclass, uint16_t error)
 	s->error = error;
 }
 
-SmbProcessResult
+int
 smbbufferputack(SmbBuffer *b, SmbHeader *h, SmbPeerInfo *p)
 {
 	h->wordcount = 0;
@@ -306,7 +306,7 @@ smbplan9length2size32(int64_t length)
 }
 
 int64_t
-smbl2roundupvlong(int64_t v, int l2)
+smbl2roundupint64_t(int64_t v, int l2)
 {
 	uint64_t mask;
 	mask = (1 << l2) - 1;

sys/src/cmd/aquarela/smbcomopen.c

@@ -333,13 +333,13 @@ smbcomopen(SmbSession *s, SmbHeader *h, uint8_t *pdata, SmbBuffer *b)
 	SmbFile *f;
 	SmbProcessResult pr;
 
+	path = malloc(sizeof(path));
 	if (!smbcheckwordcount("comopen", h, 2))
 		return SmbProcessResultFormat;
 	mode = smbnhgets(pdata);
 	attr = smbnhgets(pdata + 2);
 	if (!smbbuffergetb(b, &fmt)
-		|| fmt != 4
-		|| !smbbuffergetstring(b, h, SMB_STRING_PATH, &path)) {
+		|| fmt != 4 || !smbbuffergetstring(b, h, SMB_STRING_PATH, &path)) {
 		pr = SmbProcessResultFormat;
 		goto done;
 	}
@@ -403,8 +403,8 @@ smbcomcreate(SmbSession *s, SmbHeader *h, uint8_t *pdata, SmbBuffer *b)
 	smblogprint(h->command, "tid=%d\n", h->tid);
 	attr = smbnhgets(pdata); pdata += 2;
 	createtime = smbnhgetl(pdata);
-	if (!smbbuffergetb(b, &fmt) || fmt != 0x04 ||
-	    !smbbuffergetstring(b, h, SMB_STRING_PATH, &path)){
+	if (!smbbuffergetb(b, &fmt) || (fmt != 0x04 ||
+	    !smbbuffergetstring(b, h, SMB_STRING_PATH, &path))){
 		pr = SmbProcessResultError;
 		goto done;
 	}
@@ -524,7 +524,7 @@ static void
 smbsblutlogprint(uint8_t cmd, SmbSblut *sblut, uint32_t mask)
 {
 	while (sblut->s) {
-		if (mask && (sblut->mask & mask) || (mask == 0 && sblut->mask == 0))
+		if ((mask && (sblut->mask & mask)) || ((mask == 0 && sblut->mask == 0)))
 			smblogprint(cmd, " %s", sblut->s);
 		sblut++;
 	}
@@ -638,7 +638,7 @@ smbcomntcreateandx(SmbSession *s, SmbHeader *h, uint8_t *pdata, SmbBuffer *b)
 
 	if (shareaccess == SMB_SA_NO_SHARE)
 		sharemode = SMB_OPEN_MODE_SHARE_EXCLUSIVE;
-	else if (shareaccess & (SMB_SA_SHARE_READ | SMB_SA_SHARE_WRITE) ==
+	else if ((shareaccess & (SMB_SA_SHARE_READ | SMB_SA_SHARE_WRITE)) ==
 		(SMB_SA_SHARE_READ | SMB_SA_SHARE_WRITE))
 		sharemode = SMB_OPEN_MODE_SHARE_DENY_NONE;
 	else if (shareaccess & SMB_SA_SHARE_READ)
@@ -696,7 +696,7 @@ smbcomntcreateandx(SmbSession *s, SmbHeader *h, uint8_t *pdata, SmbBuffer *b)
 		|| !smbbufferputv(s->response, mtime)
 		|| !smbbufferputv(s->response, mtime)
 		|| !smbbufferputl(s->response, smbplan9mode2dosattr(d->mode))
-		|| !smbbufferputv(s->response, smbl2roundupvlong(d->length, smbglobals.l2allocationsize))
+		|| !smbbufferputv(s->response, smbl2roundupint64_t(d->length, smbglobals.l2allocationsize))
 		|| !smbbufferputv(s->response, d->length)
 		|| !smbbufferputbytes(s->response, nil, 4)
 		|| !smbbufferputb(s->response, (d->qid.type & QTDIR) != 0)

sys/src/cmd/aquarela/smbcomquery.c

@@ -10,7 +10,7 @@
 #include "headers.h"
 
 SmbProcessResult
-smbcomqueryinformation(SmbSession *s, SmbHeader *h, uint8_t *, SmbBuffer *b)
+smbcomqueryinformation(SmbSession *s, SmbHeader *h, uint8_t *l, SmbBuffer *b)
 {
 	SmbTree *t;
 	uint8_t fmt;
@@ -55,7 +55,7 @@ smbcomqueryinformation(SmbSession *s, SmbHeader *h, uint8_t *, SmbBuffer *b)
 
 SmbProcessResult
 smbcomqueryinformation2(SmbSession *s, SmbHeader *h, uint8_t *pdata,
-			SmbBuffer *)
+			SmbBuffer *sb)
 {
 	SmbTree *t;
 	Dir *d;
@@ -94,7 +94,7 @@ smbcomqueryinformation2(SmbSession *s, SmbHeader *h, uint8_t *pdata,
 		|| !smbbufferputs(s->response, mtime)
 		|| !smbbufferputl(s->response, smbplan9length2size32(d->length))
 		|| !smbbufferputl(s->response,
-			smbplan9length2size32(smbl2roundupvlong(d->length, smbglobals.l2allocationsize)))
+			smbplan9length2size32(smbl2roundupint64_t(d->length, smbglobals.l2allocationsize)))
 		|| !smbbufferputs(s->response, smbplan9mode2dosattr(d->mode))
 		|| !smbbufferputs(s->response, 0)) {
 		free(d);

sys/src/cmd/aquarela/smbcomrename.c

@@ -10,7 +10,7 @@
 #include "headers.h"
 
 SmbProcessResult
-smbcomrename(SmbSession *s, SmbHeader *h, uint8_t *, SmbBuffer *b)
+smbcomrename(SmbSession *s, SmbHeader *h, uint8_t *l, SmbBuffer *b)
 {
 	int rv;
 	char *old,     *new;

sys/src/cmd/aquarela/smbcomsetinfo.c

@@ -11,7 +11,7 @@
 
 SmbProcessResult
 smbcomsetinformation2(SmbSession *s, SmbHeader *h, uint8_t *pdata,
-		      SmbBuffer *)
+		      SmbBuffer *sb)
 {
 	uint16_t fid, adate, atime, mdate, mtime;
 	SmbTree *t;

sys/src/cmd/aquarela/smbcomtransaction.c

@@ -10,7 +10,7 @@
 #include "headers.h"
 
 static int
-sendresponse(void *magic, SmbBuffer *, char **errmsgp)
+sendresponse(void *magic, SmbBuffer *sb, char **errmsgp)
 {
 	int rv;
 	SmbSession *s = magic;
@@ -32,7 +32,7 @@ SmbTransactionMethod smbtransactionmethod2 = {
 	.sendresponse = sendresponse,
 };
 
-int
+SmbProcessResult
 smbcomtransaction(SmbSession *s, SmbHeader *h, uint8_t *pdata, SmbBuffer *b)
 {
 	int rv;
@@ -82,7 +82,7 @@ done:
 	return pr;
 }
 
-int
+SmbProcessResult
 smbcomtransaction2(SmbSession *s, SmbHeader *h, uint8_t *pdata, SmbBuffer *b)
 {
 	int rv;

sys/src/cmd/aquarela/smbcomtreeconnectandx.c

@@ -21,7 +21,7 @@ smbcomtreeconnectandx(SmbSession *s, SmbHeader *h, uint8_t *pdata,
 	char *service = nil;
 	uint16_t flags;
 	uint16_t passwordlength;
-//	ushort bytecount;
+//	uint16_t bytecount;
 	uint8_t errclass;
 	uint16_t error;
 	SmbService *serv;

sys/src/cmd/aquarela/smbcomtreedisconnect.c

@@ -10,7 +10,7 @@
 #include "headers.h"
 
 SmbProcessResult
-smbcomtreedisconnect(SmbSession *s, SmbHeader *h, uint8_t *, SmbBuffer *)
+smbcomtreedisconnect(SmbSession *s, SmbHeader *h, uint8_t *l, SmbBuffer *b)
 {
 	if (!smbcheckwordcount("comtreedisconnect", h, 0))
 		return SmbProcessResultFormat;

sys/src/cmd/aquarela/smbconnect.c

@@ -104,7 +104,7 @@ print("netbios session established\n");
 	print("utc: %s(and %lld μs)\n", asctime(gmtime(peerinfo.utc / 1000000000)), peerinfo.utc % 1000000000);
 	print("tzoff: %d\n", peerinfo.tzoff);
 	print("encryptionkeylength: %d\n", peerinfo.encryptionkeylength);
-	smberealloc(&peerinfo.encryptionkey, peerinfo.encryptionkeylength);
+	smberealloc((void *)&peerinfo.encryptionkey, peerinfo.encryptionkeylength);
 	if (!smbbuffergetbytes(b, peerinfo.encryptionkey, peerinfo.encryptionkeylength)) {
 		smbstringprint(errmsgp, "not enough data for encryption key");
 		goto fail;
@@ -260,7 +260,7 @@ smbclientfree(SmbClient *c)
 }
 
 int
-smbtransactionclientsend(void *magic, SmbBuffer *ob, char **)
+smbtransactionclientsend(void *magic, SmbBuffer *ob, char **l)
 {
 	SmbClient *c = magic;
 smblogprint(-1, "sending:\n");
@@ -269,7 +269,7 @@ smblogdata(-1, smblogprint, smbbufferreadpointer(ob), smbbufferwriteoffset(ob),
 }
 
 int
-smbtransactionclientreceive(void *magic, SmbBuffer *ib, char **)
+smbtransactionclientreceive(void *magic, SmbBuffer *ib, char **l)
 {
 	int32_t n;
 	SmbClient *c = magic;

sys/src/cmd/aquarela/smbdat.h

@@ -30,23 +30,23 @@ typedef struct SmbSlut SmbSlut;
 //#pragma incomplete SmbBuffer
 //#pragma incomplete SmbLockList
 
-typedef int SMBCIFSWRITEFN(SmbCifsSession *cifs, void *buf, long n);
+typedef int SMBCIFSWRITEFN(SmbCifsSession *cifs, void *buf, int32_t n);
 typedef int SMBCIFSACCEPTFN(SmbCifsSession *cifs, SMBCIFSWRITEFN **fnp);
 typedef void SMBIDMAPAPPLYFN(void *magic, void *p);
 
 struct SmbPeerInfo {
 	uint32_t capabilities;
-	ushort maxlen;
-	uchar securitymode;
-	ushort maxmpxcount;
-	ushort maxnumbervcs;
+	uint16_t maxlen;
+	uint8_t securitymode;
+	uint16_t maxmpxcount;
+	uint16_t maxnumbervcs;
 	uint32_t maxbuffersize;
 	uint32_t maxrawsize;
 	uint32_t sessionkey;
-	vlong utc;
-	short tzoff;
-	uchar encryptionkeylength;
-	uchar *encryptionkey;
+	int64_t utc;
+	int16_t tzoff;
+	uint8_t encryptionkeylength;
+	uint8_t *encryptionkey;
 	char *oemdomainname;
 };
 
@@ -54,24 +54,24 @@ struct SmbTransaction {
 	struct {
 		char *name;
 		uint32_t tpcount;
-		uchar *parameters;
+		uint8_t *parameters;
 		uint32_t pcount;
 		uint32_t tdcount;
-		uchar *data;
+		uint8_t *data;
 		uint32_t maxpcount;
 		uint32_t maxdcount;
 		uint32_t maxscount;
 		uint32_t dcount;
-		ushort scount;
-		ushort *setup;
-		ushort flags;
+		uint16_t scount;
+		uint16_t *setup;
+		uint16_t flags;
 	} in;
 	struct {
 		uint32_t tpcount;
 		uint32_t tdcount;
 		SmbBuffer *parameters;
 		SmbBuffer *data;
-		ushort *setup;
+		uint16_t *setup;
 	} out;
 };
 
@@ -84,7 +84,7 @@ enum {
 struct SmbSession {
 	NbSession *nbss;
 	SmbCifsSession *cifss;
-	uchar nextcommand;
+	uint8_t nextcommand;
 	SmbBuffer *response;
 	SmbPeerInfo peerinfo;
 	Chalstate *cs;
@@ -93,7 +93,7 @@ struct SmbSession {
 		char *primarydomain;
 		char *nativeos;
 		char *nativelanman;
-		ushort maxmpxcount;
+		uint16_t maxmpxcount;
 		MSchapreply mschapreply;
 	} client;
 	SmbTransaction transaction;
@@ -101,34 +101,34 @@ struct SmbSession {
 	SmbIdMap *tidmap;
 	SmbIdMap *sidmap;
 	int state;
-	uchar errclass;
-	ushort error;
+	uint8_t errclass;
+	uint16_t error;
 	int tzoff;		// as passed to client during negotiation
 	SmbService *serv;
 };
 
 typedef struct SmbHeader {
-	uchar command;
+	uint8_t command;
 	union {
 		struct {
-			uchar errclass;
-			ushort error;
+			uint8_t errclass;
+			uint16_t error;
 		};
 		uint32_t status;
 	};
-	uchar flags;
-	ushort flags2;
+	uint8_t flags;
+	uint16_t flags2;
 	union {
 		struct {
-			ushort pidhigh;
-			uchar securitysignature[8];
+			uint16_t pidhigh;
+			uint8_t securitysignature[8];
 		};
 	};
-	ushort tid;
-	ushort pid;
-	ushort uid;
-	ushort mid;
-	uchar wordcount;
+	uint16_t tid;
+	uint16_t pid;
+	uint16_t uid;
+	uint16_t mid;
+	uint8_t wordcount;
 } SmbHeader;
 
 typedef enum SmbProcessResult {
@@ -141,7 +141,7 @@ typedef enum SmbProcessResult {
 	SmbProcessResultDie,
 } SmbProcessResult;
 
-typedef SmbProcessResult SMBPROCESSFN(SmbSession *s, SmbHeader *h, uchar *pdata, SmbBuffer *);
+typedef SmbProcessResult SMBPROCESSFN(SmbSession *s, SmbHeader *h, uint8_t *pdata, SmbBuffer *b);
 typedef struct SmbOpTableEntry SmbOpTableEntry;
 struct SmbOpTableEntry {
 	char *name;
@@ -158,7 +158,7 @@ extern SmbGlobals smbglobals;
 struct SmbServerInfo {
 	char *name;
 	char *nativelanman;
-	uchar vmaj, vmin;
+	uint8_t vmaj, vmin;
 	uint32_t stype;
 	char *remark;
 };
@@ -194,15 +194,15 @@ struct SmbGlobals {
 };
 
 struct SmbTree {
-	long id;
+	int32_t id;
 	SmbService *serv;
 };
 
 struct SmbService {
-	Ref;
+	Ref	ref;
 	char *name;
 	char *type;
-	ushort stype;
+	uint16_t stype;
 	char *path;
 	char *remark;
 	SmbService *next;
@@ -215,12 +215,12 @@ typedef struct SmbClient SmbClient;
 
 typedef struct SmbTransactionMethod {
 	int (*encodeprimary)(SmbTransaction *t, SmbHeader *h, SmbPeerInfo *p,
-		SmbBuffer *ob, uchar *wordcount, ushort *bytecount, char **errmsgp);
+		SmbBuffer *ob, uint8_t *wordcount, uint16_t *bytecount, char **errmsgp);
 	int (*encodesecondary)(SmbTransaction *t, SmbHeader *h, SmbBuffer *ob, char **errmsgp);
 	int (*sendrequest)(void *magic, SmbBuffer *ob, char **errmsgp);
-	int (*receiveintermediate)(void *magic, uchar *wordcountp, ushort *bytecountp, char **errmsgp);
+	int (*receiveintermediate)(void *magic, uint8_t *wordcountp, uint16_t *bytecountp, char **errmsgp);
 	int (*receiveresponse)(void *magic, SmbBuffer *ib, char **errmsgp);
-	int (*decoderesponse)(SmbTransaction *t, SmbHeader *h, uchar *pdata, SmbBuffer *b, char **errmsgp);
+	int (*decoderesponse)(SmbTransaction *t, SmbHeader *h, uint8_t *pdata, SmbBuffer *b, char **errmsgp);
 	int (*encoderesponse)(SmbTransaction *t, SmbHeader *h, SmbPeerInfo *p,
 		SmbBuffer *ob, char **errmsgp);
 	int (*sendresponse)(void *magic, SmbBuffer *ob, char **errmsgp);
@@ -229,16 +229,16 @@ typedef struct SmbTransactionMethod {
 extern SmbTransactionMethod smbtransactionmethoddgram;
 
 struct SmbSearch {
-	long id;
+	int32_t id;
 	SmbTree *t;
 	SmbDirCache *dc;
 	Reprog *rep;
-	ushort tid;
+	uint16_t tid;
 };
 
 struct SmbFile {
-	long id;
-	SmbTree *t;		// tree this belongs to
+	int32_t id;
+	SmbTree *t;		// tree this beint32_ts to
 	int fd;
 	char *name;
 	int p9mode;		// how it was opened
@@ -248,9 +248,9 @@ struct SmbFile {
 };
 
 struct SmbSharedFile {
-	ushort type;
+	uint16_t type;
 	uint32_t dev;
-	vlong path;
+	int64_t path;
 //	char *name;
 	int share;			// current share level
 	int deleteonclose;
@@ -258,10 +258,10 @@ struct SmbSharedFile {
 };
 
 struct SmbLock {
-	vlong base;
-	vlong limit;
+	int64_t base;
+	int64_t limit;
 	SmbSession *s;		// owning session
-	ushort pid;		// owning pid
+	uint16_t pid;		// owning pid
 };
 
 struct SmbCifsSession {
@@ -273,27 +273,27 @@ struct SmbClient {
 	SmbPeerInfo peerinfo;
 	NbSession *nbss;
 	SmbBuffer *b;
-	ushort ipctid;
-	ushort sharetid;
+	uint16_t ipctid;
+	uint16_t sharetid;
 	SmbHeader protoh;
 };
 
 struct SmbRapServerInfo1 {
 	char name[16];
-	uchar vmaj;
-	uchar vmin;
+	uint8_t vmaj;
+	uint8_t vmin;
 	uint32_t type;
 	char *remark;
 };
 
 struct SmbFindFileBothDirectoryInfo {
 	uint32_t fileindex;
-	vlong creationtime;
-	vlong lastaccesstime;
-	vlong lastwritetime;
-	vlong changetime;
-	vlong endoffile;
-	vlong allocationsize;
+	int64_t creationtime;
+	int64_t lastaccesstime;
+	int64_t lastwritetime;
+	int64_t changetime;
+	int64_t endoffile;
+	int64_t allocationsize;
 	uint32_t extfileattributes;
 	char *filename;
 };
@@ -311,8 +311,8 @@ enum {
 
 struct SmbDirCache {
 	Dir *buf;
-	long n;
-	long i;
+	int32_t n;
+	int32_t i;
 };
 
 typedef struct SmbTrans2OpTableEntry SmbTrans2OpTableEntry;

sys/src/cmd/aquarela/smbfns.h

@@ -7,40 +7,40 @@
  * in the LICENSE file.
  */
 
-ushort smbnhgets(uchar *);
-uint32_t smbnhgetl(uchar *);
-vlong smbnhgetv(uchar *);
-void smbhnputs(uchar *, ushort);
-void smbhnputl(uchar *, uint32_t);
-void smbhnputv(uchar *, vlong);
-
-SMBPROCESSFN smbnegotiate;
-SMBPROCESSFN smbcomsessionsetupandx;
-SMBPROCESSFN smbcomtreeconnectandx;
-SMBPROCESSFN smbcomtransaction;
-SMBPROCESSFN smbcomcheckdirectory;
-SMBPROCESSFN smbcomtransaction2;
-SMBPROCESSFN smbcomecho;
-SMBPROCESSFN smbcomopenandx;
-SMBPROCESSFN smbcomcreate;
-SMBPROCESSFN smbcomopen;
-SMBPROCESSFN smbcomclose;
-SMBPROCESSFN smbcomreadandx;
-SMBPROCESSFN smbcomwriteandx;
-SMBPROCESSFN smbcomqueryinformation;
-SMBPROCESSFN smbcomfindclose2;
-SMBPROCESSFN smbcomtreedisconnect;
-SMBPROCESSFN smbcomqueryinformation2;
-SMBPROCESSFN smbcomdelete;
-SMBPROCESSFN smbcomflush;
-SMBPROCESSFN smbcomwrite;
-SMBPROCESSFN smbcomsetinformation2;
-SMBPROCESSFN smbcomcreatedirectory;
-SMBPROCESSFN smbcomdeletedirectory;
-SMBPROCESSFN smbcomrename;
-SMBPROCESSFN smbcomlockingandx;
-SMBPROCESSFN smbcomsetinformation;
-SMBPROCESSFN smbcomntcreateandx;
+uint16_t smbnhgets(uint8_t *);
+uint32_t smbnhgetl(uint8_t *);
+int64_t smbnhgetv(uint8_t *);
+void smbhnputs(uint8_t *, uint16_t);
+void smbhnputl(uint8_t *, uint32_t);
+void smbhnputv(uint8_t *, int64_t);
+
+SmbProcessResult smbnegotiate (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomsessionsetupandx (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomtreeconnectandx (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomtransaction (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomcheckdirectory (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomtransaction2 (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomecho (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomopenandx (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomcreate (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomopen (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomclose (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomreadandx (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomwriteandx (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomqueryinformation (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomfindclose2 (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomtreedisconnect (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomqueryinformation2 (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomdelete (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomflush (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomwrite (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomsetinformation2 (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomcreatedirectory (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomdeletedirectory (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomrename (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomlockingandx (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomsetinformation (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
+SmbProcessResult smbcomntcreateandx (SmbSession *, SmbHeader *, uint8_t *, SmbBuffer *);
 
 void *smbemalloc(uint32_t size);
 void *smbemallocz(uint32_t size, int clear);
@@ -48,52 +48,52 @@ void smberealloc(void **pp, uint32_t size);
 char *smbestrdup(char *s);
 void smbfree(void **pp);
 
-int smbcheckwordcount(char *name, SmbHeader *h, ushort wordcount);
-int smbcheckwordandbytecount(char *name, SmbHeader *h, ushort wordcount, uchar **bdatap, uchar **edatap);
+int smbcheckwordcount(char *name, SmbHeader *h, uint16_t wordcount);
+int smbcheckwordandbytecount(char *name, SmbHeader *h, uint16_t wordcount, uint8_t **bdatap, uint8_t **edatap);
 int smbsendunicode(SmbPeerInfo *i);
 
-char *smbstringdup(SmbHeader *h, uchar *base, uchar **bdatap, uchar *edata);
-char *smbstrdup(uchar **bdatap, uchar *edata);
-char *smbstrinline(uchar **bdatap, uchar *edata);
+char *smbstringdup(SmbHeader *h, uint8_t *base, uint8_t **bdatap, uint8_t *edata);
+char *smbstrdup(uint8_t **bdatap, uint8_t *edata);
+char *smbstrinline(uint8_t **bdatap, uint8_t *edata);
 int smbstrlen(char *string);
 int smbstringlen(SmbPeerInfo *i, char *string);
 void smbstringprint(char **p, char *fmt, ...);
 
 int smbucs2len(char *string);
-int smbstringput(SmbPeerInfo *p, uint32_t flags, uchar *buf, ushort n,
-		 ushort maxlen, char *string);
-int smbstrput(uint32_t flags, uchar *buf, ushort n, ushort maxlen,
+int smbstringput(SmbPeerInfo *p, uint32_t flags, uint8_t *buf, uint16_t n,
+		 uint16_t maxlen, char *string);
+int smbstrput(uint32_t flags, uint8_t *buf, uint16_t n, uint16_t maxlen,
 	      char *string);
-int smbstrnput(uchar *buf, ushort n, ushort maxlen, char *string, ushort size, int upcase);
-int smbucs2put(uint32_t flags, uchar *buf, ushort n, ushort maxlen,
+int smbstrnput(uint8_t *buf, uint16_t n, uint16_t maxlen, char *string, uint16_t size, int upcase);
+int smbucs2put(uint32_t flags, uint8_t *buf, uint16_t n, uint16_t maxlen,
 	       char *string);
 
-void smbresponseinit(SmbSession *s, ushort maxlen);
+void smbresponseinit(SmbSession *s, uint16_t maxlen);
 int smbresponsealignl2(SmbSession *s, int l2a);
-ushort smbresponseoffset(SmbSession *s);
-int smbresponseputheader(SmbSession *s, SmbHeader *h, uchar errclass, ushort error);
-int smbresponseputandxheader(SmbSession *s, SmbHeader *h, ushort andxcommand,
+uint16_t smbresponseoffset(SmbSession *s);
+int smbresponseputheader(SmbSession *s, SmbHeader *h, uint8_t errclass, uint16_t error);
+int smbresponseputandxheader(SmbSession *s, SmbHeader *h, uint16_t andxcommand,
 			     uint32_t *andxoffsetfixup);
-int smbresponseputb(SmbSession *s, uchar b);
-int smbresponseputs(SmbSession *s, ushort s);
+int smbresponseputb(SmbSession *s, uint8_t b);
+int smbresponseputs(SmbSession *s, uint16_t b);
 int smbresponseputl(SmbSession *s, uint32_t l);
-int smbresponseoffsetputs(SmbSession *s, ushort offset, ushort s);
+int smbresponseoffsetputs(SmbSession *s, uint16_t offset, uint16_t b);
 int smbresponseputstring(SmbSession *s, int mustalign, char *string);
 int smbresponseputstr(SmbSession *s, char *string);
 SmbProcessResult smbresponsesend(SmbSession *s);
-int smbresponseputerror(SmbSession *s, SmbHeader *h, uchar errclass, ushort error);
-int smbresponseskip(SmbSession *s, ushort amount);
-ushort smbresponsespace(SmbSession *s);
+int smbresponseputerror(SmbSession *s, SmbHeader *h, uint8_t errclass, uint16_t error);
+int smbresponseskip(SmbSession *s, uint16_t amount);
+uint16_t smbresponsespace(SmbSession *s);
 void smbresponsereset(SmbSession *s);
-int smbresponsecpy(SmbSession *s, uchar *data, ushort datalen);
+int smbresponsecpy(SmbSession *s, uint8_t *data, uint16_t datalen);
 
 void smbtreedisconnect(SmbSession *s, SmbTree *t);
-void smbtreedisconnectbyid(SmbSession *s, ushort id);
+void smbtreedisconnectbyid(SmbSession *s, uint16_t id);
 SmbTree *smbtreeconnect(SmbSession *s, SmbService *serv);
 int smbchaincommand(SmbSession *s, SmbHeader *h, uint32_t andxfixupoffset,
-		    uchar cmd, ushort offset, SmbBuffer *b);
+		    uint8_t cmd, uint16_t offset, SmbBuffer *b);
 
-SmbService *smbservicefind(SmbSession *s, char *path, char *service, uchar *errclassp, ushort *errorp);
+SmbService *smbservicefind(SmbSession *s, char *path, char *service, uint8_t *errclassp, uint16_t *errorp);
 void smbserviceput(SmbService *serv);
 void smbserviceget(SmbService *serv);
 
@@ -110,19 +110,19 @@ uint32_t smbbufferreadoffset(SmbBuffer *s);
 void *smbbufferwritepointer(SmbBuffer *s);
 void *smbbufferreadpointer(SmbBuffer *s);
 int smbbufferputheader(SmbBuffer *s, SmbHeader *h, SmbPeerInfo *p);
-int smbbufferputandxheader(SmbBuffer *s, SmbHeader *h, SmbPeerInfo *p, uchar andxcommand,
+int smbbufferputandxheader(SmbBuffer *s, SmbHeader *h, SmbPeerInfo *p, uint8_t andxcommand,
 			   uint32_t *andxoffsetfixup);
-int smbbufferputb(SmbBuffer *s, uchar b);
-int smbbufferputs(SmbBuffer *s, ushort s);
+int smbbufferputb(SmbBuffer *s, uint8_t b);
+int smbbufferputs(SmbBuffer *s, uint16_t b);
 int smbbufferputl(SmbBuffer *s, uint32_t l);
-int smbbufferoffsetputs(SmbBuffer *s, uint32_t offset, ushort s);
+int smbbufferoffsetputs(SmbBuffer *s, uint32_t offset, uint16_t b);
 int smbbufferputstring(SmbBuffer *b, SmbPeerInfo *p, uint32_t flags,
 		       char *string);
 int smbbufferpututstring(SmbBuffer *b, SmbPeerInfo *p, int mustalign, char *string);
 int smbbufferputucs2(SmbBuffer *b, int mustalign, char *string);
 int smbbufferputstr(SmbBuffer *s, char *string);
 int smbbufferputstrn(SmbBuffer *s, char *string, int len, int upcase);
-int smbbufferputerror(SmbBuffer *s, SmbHeader *h, SmbPeerInfo *p, uchar errclass, ushort error);
+int smbbufferputerror(SmbBuffer *s, SmbHeader *h, SmbPeerInfo *p, uint8_t errclass, uint16_t error);
 int smbbufferskip(SmbBuffer *s, uint32_t amount);
 uint32_t smbbufferspace(SmbBuffer *s);
 void smbbufferreset(SmbBuffer *s);
@@ -131,16 +131,16 @@ int smbbuffergetbytes(SmbBuffer *b, void *buf, uint32_t len);
 void smbbuffersetreadlen(SmbBuffer *b, uint32_t len);
 int smbbuffertrimreadlen(SmbBuffer *b, uint32_t len);
 uint32_t smbbufferwritespace(SmbBuffer *b);
-int smbbuffergets(SmbBuffer *b, ushort *sp);
+int smbbuffergets(SmbBuffer *b, uint16_t *sp);
 int smbbuffergetstr(SmbBuffer *b, uint32_t flags, char **sp);
 int smbbuffergetstrinline(SmbBuffer *b, char **sp);
-int smbbuffergetstrn(SmbBuffer *b, ushort size, char **sp);
+int smbbuffergetstrn(SmbBuffer *b, uint16_t size, char **sp);
 int smbbuffergetstring(SmbBuffer *b, SmbHeader *h, uint32_t flags, char **sp);
 int smbbuffergetucs2(SmbBuffer *b, uint32_t flags, char **sp);
 void *smbbufferpointer(SmbBuffer *b, uint32_t offset);
-int smbbuffergetb(SmbBuffer *b, uchar *bp);
+int smbbuffergetb(SmbBuffer *b, uint8_t *bp);
 int smbbuffergetl(SmbBuffer *b, uint32_t *lp);
-int smbbuffergetv(SmbBuffer *b, vlong *vp);
+int smbbuffergetv(SmbBuffer *b, int64_t *vp);
 uint32_t smbbufferreadspace(SmbBuffer *b);
 void smbbufferwritelimit(SmbBuffer *b, uint32_t limit);
 int smbbufferreadskipto(SmbBuffer *b, uint32_t offset);
@@ -155,10 +155,10 @@ int smbbufferfixuprelativeinclusivel(SmbBuffer *b, uint32_t fixupoffset);
 int smbbufferfixupabsolutes(SmbBuffer *b, uint32_t fixupoffset);
 int smbbufferfixupabsolutel(SmbBuffer *b, uint32_t fixupoffset);
 int smbbufferfixupl(SmbBuffer *b, uint32_t fixupoffset, uint32_t val);
-int smbbufferputv(SmbBuffer *b, vlong v);
+int smbbufferputv(SmbBuffer *b, int64_t v);
 int smbbufferputack(SmbBuffer *b, SmbHeader *h, SmbPeerInfo *p);
-int smbbufferfill(SmbBuffer *b, uchar c, uint32_t len);
-int smbbufferoffsetgetb(SmbBuffer *b, uint32_t offset, uchar *bp);
+int smbbufferfill(SmbBuffer *b, uint8_t c, uint32_t len);
+int smbbufferoffsetgetb(SmbBuffer *b, uint32_t offset, uint8_t *bp);
 int smbbuffercopy(SmbBuffer *to, SmbBuffer *from, uint32_t amount);
 int smbbufferoffsetcopystr(SmbBuffer *b, uint32_t offset, char *buf,
 			   int buflen, int *lenp);
@@ -167,17 +167,17 @@ SmbClient *smbconnect(char *to, char *share, char **errmsgp);
 void smbclientfree(SmbClient *s);
 int smbsuccess(SmbHeader *h, char **errmsgp);
 
-int smbtransactiondecodeprimary(SmbTransaction *t, SmbHeader *h, uchar *pdata, SmbBuffer *b, char **errmsgp);
-int smbtransactiondecodeprimary2(SmbTransaction *t, SmbHeader *h, uchar *pdata, SmbBuffer *b, char **errmsgp);
+int smbtransactiondecodeprimary(SmbTransaction *t, SmbHeader *h, uint8_t *pdata, SmbBuffer *b, char **errmsgp);
+int smbtransactiondecodeprimary2(SmbTransaction *t, SmbHeader *h, uint8_t *pdata, SmbBuffer *b, char **errmsgp);
 void smbtransactionfree(SmbTransaction *t);
 int smbtransactionencoderesponse(SmbTransaction *t, SmbHeader *h, SmbPeerInfo *p, SmbBuffer *ob, char **errmsgp);
 int smbtransactionencoderesponse2(SmbTransaction *t, SmbHeader *h, SmbPeerInfo *p, SmbBuffer *ob, char **errmsgp);
 int smbtransactionencodeprimary(SmbTransaction *t, SmbHeader *h, SmbPeerInfo *p, SmbBuffer *ob,
-	uchar *wordcountp, ushort *bytecountp, char **errmsgp);
+	uint8_t *wordcountp, uint16_t *bytecountp, char **errmsgp);
 int smbtransactionencodeprimary2(SmbTransaction *t, SmbHeader *h, SmbPeerInfo *p, SmbBuffer *ob,
-	uchar *wordcountp, ushort *bytecountp, char **errmsgp);
-int smbtransactiondecoderesponse(SmbTransaction *t, SmbHeader *h, uchar *pdata, SmbBuffer *b, char **errmsgp);
-int smbtransactiondecoderesponse2(SmbTransaction *t, SmbHeader *h, uchar *pdata, SmbBuffer *b, char **errmsgp);
+	uint8_t *wordcountp, uint16_t *bytecountp, char **errmsgp);
+int smbtransactiondecoderesponse(SmbTransaction *t, SmbHeader *h, uint8_t *pdata, SmbBuffer *b, char **errmsgp);
+int smbtransactiondecoderesponse2(SmbTransaction *t, SmbHeader *h, uint8_t *pdata, SmbBuffer *b, char **errmsgp);
 int smbtransactionclientsend(void *magic, SmbBuffer *ob, char **errmsgp);
 int smbtransactionclientreceive(void *magic, SmbBuffer *ib, char **errmsgp);
 
@@ -195,35 +195,35 @@ SmbProcessResult smbtrans2setfileinformation(SmbSession *s, SmbHeader *h);
 SmbProcessResult smbtrans2setpathinformation(SmbSession *s, SmbHeader *h);
 
 SmbIdMap *smbidmapnew(void);
-long smbidmapadd(SmbIdMap *m, void *p);
-void smbidmapremovebyid(SmbIdMap *m, long id);
+int32_t smbidmapadd(SmbIdMap *m, void *p);
+void smbidmapremovebyid(SmbIdMap *m, int32_t id);
 void smbidmapremove(SmbIdMap *m, void *thing);
 void smbidmapfree(SmbIdMap **mp, SMBIDMAPAPPLYFN *free, void *magic);
 void smbidmapapply(SmbIdMap *mp, SMBIDMAPAPPLYFN *free, void *magic);
-void *smbidmapfind(SmbIdMap *m, long id);
+void *smbidmapfind(SmbIdMap *m, int32_t id);
 void smbidmapremoveif(SmbIdMap *m, int (*f)(void *p, void *arg), void *arg);
 
 void smbsearchfree(SmbSearch **searchp);
 void smbsearchclose(SmbSession *s, SmbSearch *search);
-void smbsearchclosebyid(SmbSession *s, ushort sid);
+void smbsearchclosebyid(SmbSession *s, uint16_t sid);
 
-void smbseterror(SmbSession *s, uchar errclass, ushort error);
+void smbseterror(SmbSession *s, uint8_t errclass, uint16_t error);
 
-void smbplan9time2datetime(uint32_t time, int tzoff, ushort *datep,
-			   ushort *timep);
-uint32_t smbdatetime2plan9time(ushort date, ushort time, int tzoff);
-vlong smbplan9time2time(uint32_t time);
+void smbplan9time2datetime(uint32_t time, int tzoff, uint16_t *datep,
+			   uint16_t *timep);
+uint32_t smbdatetime2plan9time(uint16_t date, uint16_t time, int tzoff);
+int64_t smbplan9time2time(uint32_t time);
 uint32_t smbplan9time2utime(uint32_t time, int tzoff);
 uint32_t smbutime2plan9time(uint32_t time, int tzoff);
-uint32_t smbtime2plan9time(vlong);
+uint32_t smbtime2plan9time(int64_t);
 void smbpathcanon(char *path);
 void smbpathsplit(char *path, char **dirp, char **namep);
 
-ushort smbplan9mode2dosattr(uint32_t mode);
-uint32_t smbdosattr2plan9wstatmode(uint32_t oldmode, ushort attr);
-uint32_t smbdosattr2plan9mode(ushort attr);
+uint16_t smbplan9mode2dosattr(uint32_t mode);
+uint32_t smbdosattr2plan9wstatmode(uint32_t oldmode, uint16_t attr);
+uint32_t smbdosattr2plan9mode(uint16_t attr);
 
-uint32_t smbplan9length2size32(vlong size);
+uint32_t smbplan9length2size32(int64_t size);
 
 void smbfileclose(SmbSession *s, SmbFile *f);
 
@@ -233,14 +233,14 @@ int smblogvprint(int cmd, char *fmt, va_list ap);
 int translogprint(int cmd, char *fmt, ...);
 int smblogprint(int cmd, char *fmt, ...);
 int smblogprintif(int v, char *fmt, ...);
-void smblogdata(int cmd, int (*print)(int cmd, char *fmt, ...), void *p, long data, long limit);
+void smblogdata(int cmd, int (*print)(int cmd, char *fmt, ...), void *p, int32_t data, int32_t limit);
 
 SmbSharedFile *smbsharedfileget(Dir *d, int p9mode, int *sharep);
 void smbsharedfileput(SmbFile *f, SmbSharedFile *sf, int share);
-int smbsharedfilelock(SmbSharedFile *sf, SmbSession *s, ushort pid, vlong base, vlong limit);
-int smbsharedfileunlock(SmbSharedFile *sf, SmbSession *s, ushort pid, vlong base, vlong limit);
+int smbsharedfilelock(SmbSharedFile *sf, SmbSession *s, uint16_t pid, int64_t base, int64_t limit);
+int smbsharedfileunlock(SmbSharedFile *sf, SmbSession *s, uint16_t pid, int64_t base, int64_t limit);
 
-vlong smbl2roundupvlong(vlong v, int l2);
+int64_t smbl2roundupint64_t(int64_t v, int l2);
 
 int smblistencifs(SMBCIFSACCEPTFN *accept);
 
@@ -248,10 +248,10 @@ int smbnetserverenum2(SmbClient *c, uint32_t stype, char *domain,
 		      int *entriesp, SmbRapServerInfo1 **sip,
 		      char **errmsgp);
 
-int smbbuffergetheader(SmbBuffer *b, SmbHeader *h, uchar **parametersp, ushort *bytecountp);
-int smbbuffergetandcheckheader(SmbBuffer *b, SmbHeader *h, uchar command, int response,
-	uchar **pdatap, ushort *bytecountp, char **errmsgp);
-int smbcheckheader(SmbHeader *h, uchar command, int response, char **errmsgp);
+int smbbuffergetheader(SmbBuffer *b, SmbHeader *h, uint8_t **parametersp, uint16_t *bytecountp);
+int smbbuffergetandcheckheader(SmbBuffer *b, SmbHeader *h, uint8_t command, int response,
+	uint8_t **pdatap, uint16_t *bytecountp, char **errmsgp);
+int smbcheckheader(SmbHeader *h, uint8_t command, int response, char **errmsgp);
 int smbcheckheaderdirection(SmbHeader *h, int response, char **errmsgp);
 
 SmbDirCache *smbmkdircache(SmbTree *t, char *path);
@@ -260,15 +260,15 @@ void smbdircachefree(SmbDirCache **cp);
 int smbmatch(char *name, Reprog *rep);
 Reprog *smbmkrep(char *pattern);
 
-int smbclientopen(SmbClient *c, ushort mode, char *name, uchar *errclassp, ushort *errorp, ushort *fid, ushort *attrp,
-uint32_t *mtimep, uint32_t *sizep, ushort *accessallowedp, char **errmsgp);
+int smbclientopen(SmbClient *c, uint16_t mode, char *name, uint8_t *errclassp, uint16_t *errorp, uint16_t *fid, uint16_t *attrp,
+uint32_t *mtimep, uint32_t *sizep, uint16_t *accessallowedp, char **errmsgp);
 
 Rune smbruneconvert(Rune r, uint32_t flags);
 
 int smbslut(SmbSlut *table, char *name);
 char *smbrevslut(SmbSlut *table, int val);
 
-SmbProcessResult smbtruncatefile(SmbSession *s, SmbFile *f, vlong offset);
+SmbProcessResult smbtruncatefile(SmbSession *s, SmbFile *f, int64_t offset);
 
 #ifdef LEAK
 #define smbemallocz(n, z) mallocz(n, z)

sys/src/cmd/aquarela/smbglobals.c

@@ -44,7 +44,7 @@ smbglobalsguess(int client)
 		smbglobals.primarydomain = "PLAN9";
 	if (smbglobals.serverinfo.remark == nil)
 		smbglobals.serverinfo.remark = "This is a default server comment";
-	if (smbglobals.log.fd < 0)
+	if (smbglobals.log.fd < 0){
 		if (client){
 			smbglobals.log.fd = create("client.log", OWRITE|OTRUNC, 0666);
 		}
@@ -52,4 +52,5 @@ smbglobalsguess(int client)
 			if (access("/sys/log/aquarela", 2) == 0)
 				smbglobals.log.fd = open("/sys/log/aquarela", OWRITE);
 		}
+	}
 }

sys/src/cmd/aquarela/smbidmap.c

@@ -74,7 +74,7 @@ grow(SmbIdMap *m)
 		m->entries = INITIALCHUNKSIZE;
 	else
 		m->entries *= 2;
-	smberealloc(&m->array, sizeof(Entry) * m->entries);
+	smberealloc((void *)&m->array, sizeof(Entry) * m->entries);
 	for (x = m->entries - 1; x >= oldentries; x--) {
 		m->array[x].freechain = m->freeindex;
 		m->freeindex = x;

sys/src/cmd/aquarela/smblisten.c

@@ -11,7 +11,7 @@
 
 static struct {
 	int thread;
-	QLock;
+	QLock	qlock;
 	char adir[NETPATHLEN];
 	int acfd;
 	char ldir[NETPATHLEN];
@@ -24,7 +24,7 @@ typedef struct Session Session;
 enum { Connected, Dead };
 
 struct Session {
-	SmbCifsSession;
+	SmbCifsSession	scs;
 	int thread;
 	Session *next;
 	int state;
@@ -32,7 +32,7 @@ struct Session {
 };
 
 static struct {
-	QLock;
+	QLock	qlock;
 	Session *head;
 } sessions;
 
@@ -42,13 +42,13 @@ static void
 deletesession(Session *s)
 {
 	Session **sp;
-	close(s->fd);
-	qlock(&sessions);
+	close(s->scs.fd);
+	qlock(&sessions.qlock);
 	for (sp = &sessions.head; *sp && *sp != s; sp = &(*sp)->next)
 		;
 	if (*sp)
 		*sp = s->next;
-	qunlock(&sessions);
+	qunlock(&sessions.qlock);
 	free(s);
 }
 
@@ -64,12 +64,12 @@ tcpreader(void *a)
 		uint8_t flags;
 		uint16_t length;
 
-		n = readn(s->fd, buf, 4);
+		n = readn(s->scs.fd, buf, 4);
 		if (n != 4) {
 		die:
 			free(buf);
 			if (s->state == Connected)
-				(*s->write)(s, nil, -1);
+				(*s->write)(&s->scs, nil, -1);
 			deletesession(s);
 			return;
 		}
@@ -79,11 +79,11 @@ tcpreader(void *a)
 			print("nbss: too much data (%u)\n", length);
 			goto die;
 		}
-		n = readn(s->fd, buf + 4, length);
+		n = readn(s->scs.fd, buf + 4, length);
 		if (n != length)
 			goto die;
 		if (s->state == Connected) {
-			if ((*s->write)(s, buf + 4, length) != 0) {
+			if ((*s->write)(&s->scs, buf + 4, length) != 0) {
 				s->state = Dead;
 				goto die;
 			}
@@ -96,29 +96,29 @@ createsession(int fd)
 {
 	Session *s;
 	s = smbemalloc(sizeof(Session));
-	s->fd = fd;
+	s->scs.fd = fd;
 	s->state = Connected;
-	qlock(&sessions);
-	if (!(*tcp.accept)(s, &s->write)) {
-		qunlock(&sessions);
+	qlock(&sessions.qlock);
+	if (!(*tcp.accept)(&s->scs, &s->write)) {
+		qunlock(&sessions.qlock);
 		free(s);
 		return nil;
 	}
 	s->thread = procrfork(tcpreader, s, 32768, RFNAMEG);
 	if (s->thread < 0) {
-		qunlock(&sessions);
-		(*s->write)(s, nil, -1);
+		qunlock(&sessions.qlock);
+		(*s->write)(&s->scs, nil, -1);
 		free(s);
 		return nil;
 	}
 	s->next = sessions.head;
 	sessions.head = s;
-	qunlock(&sessions);
+	qunlock(&sessions.qlock);
 	return s;
 }
 
 static void
-tcplistener(void *)
+tcplistener(void *v)
 {
 	for (;;) {
 		int dfd;
@@ -129,10 +129,10 @@ tcplistener(void *)
 //print("cifstcplistener: contact\n");
 		if (lcfd < 0) {
 		die:
-			qlock(&tcp);
+			qlock(&tcp.qlock);
 			close(tcp.acfd);
 			tcp.thread = -1;
-			qunlock(&tcp);
+			qunlock(&tcp.qlock);
 			return;
 		}
 		dfd = accept(lcfd, ldir);
@@ -147,17 +147,17 @@ tcplistener(void *)
 int
 smblistencifs(SMBCIFSACCEPTFN *accept)
 {
-	qlock(&tcp);
+	qlock(&tcp.qlock);
 	if (tcp.thread < 0) {
 		tcp.acfd = announce("tcp!*!cifs", tcp.adir);
 		if (tcp.acfd < 0) {
 			print("smblistentcp: can't announce: %r\n");
-			qunlock(&tcp);
+			qunlock(&tcp.qlock);
 			return -1;
 		}
 		tcp.thread = proccreate(tcplistener, nil, 16384);
 	}
 	tcp.accept = accept;
-	qunlock(&tcp);
+	qunlock(&tcp.qlock);
 	return 0;
 }

sys/src/cmd/aquarela/smbnegotiate.c

@@ -10,7 +10,7 @@
 #include "headers.h"
 
 SmbProcessResult
-smbnegotiate(SmbSession *s, SmbHeader *h, uint8_t *, SmbBuffer *b)
+smbnegotiate(SmbSession *s, SmbHeader *h, uint8_t *l, SmbBuffer *b)
 {
 	uint16_t index;
 	int i;

sys/src/cmd/aquarela/smbrap2.c

@@ -123,7 +123,7 @@ shareinfoput(SmbBuffer *b, uint16_t level, void *data)
 	if (level > 1) {
 		if (!smbbufferputs(b, 7)
 			|| !smbbufferputs(b, -1)
-			|| !smbbufferputs(b, serv->ref)
+			|| !smbbufferputs(b, serv->ref.ref)
 			|| !smbbufferputl(b, 0)
 			|| !smbbufferfill(b, 0, 10))
 			return 0;
@@ -159,7 +159,7 @@ shareinfoputstrings(SmbBuffer *b, uint16_t level, int instance, void *data)
 }
 
 static void *
-shareinfoenumerate(void *, int i)
+shareinfoenumerate(void *v, int i)
 {
 	SmbService *serv;
 	for (serv = smbservices; i-- > 0 && serv; serv = serv->next)
@@ -236,7 +236,7 @@ netshareenum(SmbBuffer *inparam, SmbBuffer *outparam, SmbBuffer *outdata)
 	uint16_t level;
 
 	/* WrLeh */
-	/* ushort sLevel, RCVBUF pbBuffer, RCVBUFLEN cbBuffer, ENTCOUNT pcEntriesRead, ushort *pcTotalAvail */
+	/* uint16_t sLevel, RCVBUF pbBuffer, RCVBUFLEN cbBuffer, ENTCOUNT pcEntriesRead, uint16_t *pcTotalAvail */
 
 	if (!smbbuffergets(inparam, &level))
 		return SmbProcessResultFormat;
@@ -262,10 +262,11 @@ netserverenum2(SmbBuffer *inparam, SmbBuffer *outparam, SmbBuffer *outdata)
 	int entries;
 
 	/* WrLehDz
-	 * ushort sLevel, RCVBUF pbBuffer, RCVBUFLEN cbBuffer, ENTCOUNT pcEntriesRead, ushort *pcTotalAvail,
-	 * ulong fServerType, char *pszDomain
+	 * uint16_t sLevel, RCVBUF pbBuffer, RCVBUFLEN cbBuffer, ENTCOUNT pcEntriesRead, uint16_t *pcTotalAvail,
+	 * uint32_t fServerType, char *pszDomain
 	*/
 
+	domain = malloc(sizeof(domain));
 	if (!smbbuffergets(inparam, &level)
 		|| !smbbuffergets(inparam, &rbl)
 		|| !smbbuffergetl(inparam, &servertype)
@@ -320,7 +321,7 @@ netsharegetinfo(SmbBuffer *inparam, SmbBuffer *outparam, SmbBuffer *outdata)
 
 	/*
 	 * zWrLh
-	 * char *pszNetName, ushort sLevel, RCVBUF pbBuffer, RCVBUFLEN cbBuffer, ushort *pcbTotalAvail
+	 * char *pszNetName, uint16_t sLevel, RCVBUF pbBuffer, RCVBUFLEN cbBuffer, uint16_t *pcbTotalAvail
 	*/
 
 	if (!smbbuffergetstrinline(inparam, &netname)
@@ -359,7 +360,7 @@ netservergetinfo(SmbBuffer *inparam, SmbBuffer *outparam, SmbBuffer *outdata)
 	SmbProcessResult pr;
 
 	/* WrLh
-	 * ushort sLevel, RCVBUF pbBuffer, RCVBUFLEN cbBuffer, ushort *pcbTotalAvail
+	 * uint16_t sLevel, RCVBUF pbBuffer, RCVBUFLEN cbBuffer, uint16_t *pcbTotalAvail
 	*/
 
 	if (!smbbuffergets(inparam, &level)) {
@@ -389,7 +390,7 @@ netwkstagetinfo(SmbBuffer *inparam, SmbBuffer *outparam, SmbBuffer *outdata)
 	int moredata;
 
 	/* WrLh
-	 * ushort sLevel, RCVBUF pbBuffer, RCVBUFLEN cbBuffer, ushort *pcbTotalAvail
+	 * uint16_t sLevel, RCVBUF pbBuffer, RCVBUFLEN cbBuffer, uint16_t *pcbTotalAvail
 	*/
 
 	if (!smbbuffergets(inparam, &level)) {
@@ -441,14 +442,14 @@ done:
 }
 
 static RapTableEntry raptable[] = {
-[RapNetShareGetInfo] { "NetShareGetInfo", netsharegetinfo },
-[RapNetShareEnum] { "NetShareEnum", netshareenum },
-[RapNetServerGetInfo] {"NetServerGetInfo", netservergetinfo },
-[RapNetWkstaGetInfo] { "NetWkstaGetInfo", netwkstagetinfo },
-[RapNetServerEnum2] { "NetServerEnum2", netserverenum2 },
+[RapNetShareGetInfo] = { "NetShareGetInfo", netsharegetinfo },
+[RapNetShareEnum] = { "NetShareEnum", netshareenum },
+[RapNetServerGetInfo] = {"NetServerGetInfo", netservergetinfo },
+[RapNetWkstaGetInfo] = { "NetWkstaGetInfo", netwkstagetinfo },
+[RapNetServerEnum2] = { "NetServerEnum2", netserverenum2 },
 };
 
-SmbProcessResult
+int
 smbrap2(SmbSession *s)
 {
 	char *pstring;

sys/src/cmd/aquarela/smbservice.c

@@ -117,11 +117,11 @@ bad:
 void
 smbserviceget(SmbService *serv)
 {
-	incref(serv);
+	incref(&serv->ref);
 }
 
 void
 smbserviceput(SmbService *serv)
 {
-	decref(serv);
+	decref(&serv->ref);
 }

sys/src/cmd/aquarela/smbsharedfile.c

@@ -11,20 +11,20 @@
 
 typedef struct SmbSharedFileEntry SmbSharedFileEntry;
 struct SmbSharedFileEntry {
-	SmbSharedFile;
-	Ref;
+	SmbSharedFile	ssf;
+	Ref	ref;
 	SmbSharedFileEntry *next;
 };
 
 static struct {
-	QLock;
+	QLock	qlock;
 	SmbSharedFileEntry *list;
 } sharedfiletable;
 
 typedef struct SmbLockListEntry SmbLockListEntry;
 
 struct SmbLockListEntry {
-	SmbLock;
+	SmbLock smblock;
 	SmbLockListEntry *next;
 };
 
@@ -74,22 +74,22 @@ smbsharedfilelock(SmbSharedFile *sf, SmbSession *s, uint16_t pid,
 {
 	SmbLockListEntry smblock;
 	SmbLockListEntry *l, *nl, **lp;
-	smblock.s = s;
-	smblock.pid = pid;
-	smblock.base = base;
-	smblock.limit = limit;
+	smblock.smblock.s = s;
+	smblock.smblock.pid = pid;
+	smblock.smblock.base = base;
+	smblock.smblock.limit = limit;
 	if (sf->locklist) {
 		for (l = sf->locklist->head; l; l = l->next)
-			if (lockconflict(l, &smblock)) {
+			if (lockconflict(&l->smblock, &smblock.smblock)) {
 				smblogprintif(smbglobals.log.locks, "smbsharedfilelock: lock [%lld, %lld) failed because conflicts with [%lld, %lld)\n",
-					base, limit, l->base, l->limit);
+					base, limit, l->smblock.base, l->smblock.limit);
 				return 0;
 			}
 	}
 	if (sf->locklist == nil)
 		sf->locklist = smbemallocz(sizeof(SmbLockList), 1);
 	for (lp = &sf->locklist->head; (l = *lp) != nil; lp = &l->next)
-		if (lockorder(&smblock, l) <= 0)
+		if (lockorder(&smblock.smblock, &l->smblock) <= 0)
 			break;
 	smblogprintif(smbglobals.log.locks, "smbsharedfilelock: lock [%lld, %lld) succeeded\n", base, limit);
 	nl = smbemalloc(sizeof(*nl));
@@ -110,16 +110,16 @@ smbsharedfileunlock(SmbSharedFile *sf, SmbSession *s, uint16_t pid,
 {
 	SmbLockListEntry smblock;
 	SmbLockListEntry *l, **lp;
-	smblock.s = s;
-	smblock.pid = pid;
-	smblock.base = base;
-	smblock.limit = limit;
+	smblock.smblock.s = s;
+	smblock.smblock.pid = pid;
+	smblock.smblock.base = base;
+	smblock.smblock.limit = limit;
 	if (sf->locklist == nil)
 		goto failed;
 	for (lp = &sf->locklist->head; (l = *lp) != nil; lp = &l->next) {
-		if (l->s != s || l->pid != pid)
+		if (l->smblock.s != s || l->smblock.pid != pid)
 			continue;
-		switch (lockorder(&smblock, l)) {
+		switch (lockorder(&smblock.smblock, &l->smblock)) {
 		case 0:
 			*lp = l->next;
 			free(l);
@@ -226,58 +226,58 @@ SmbSharedFile *
 smbsharedfileget(Dir *d, int p9mode, int *sharep)
 {
 	SmbSharedFileEntry *sfe;
-	qlock(&sharedfiletable);
+	qlock(&sharedfiletable.qlock);
 	for (sfe = sharedfiletable.list; sfe; sfe = sfe->next) {
-		if (sfe->type == d->type && sfe->dev == d->dev && sfe->path == d->qid.path) {
-			if (p9denied(p9mode, sfe->share)) {
-				qunlock(&sharedfiletable);
+		if (sfe->ssf.type == d->type && sfe->ssf.dev == d->dev && sfe->ssf.path == d->qid.path) {
+			if (p9denied(p9mode, sfe->ssf.share)) {
+				qunlock(&sharedfiletable.qlock);
 				return nil;
 			}
-			*sharep = sharesubtract(*sharep, sfe->share);
-			sfe->share = shareadd(sfe->share, *sharep);
-			sfe->ref++;
+			*sharep = sharesubtract(*sharep, sfe->ssf.share);
+			sfe->ssf.share = shareadd(sfe->ssf.share, *sharep);
+			sfe->ref.ref++;
 			goto done;
 		}
 	}
 	sfe = smbemallocz(sizeof(SmbSharedFileEntry), 1);
-	sfe->type = d->type;
-	sfe->dev = d->dev;
-	sfe->path = d->qid.path;
+	sfe->ssf.type = d->type;
+	sfe->ssf.dev = d->dev;
+	sfe->ssf.path = d->qid.path;
 //	sfe->name = smbestrdup(name);
-	sfe->ref = 1;
-	sfe->share = *sharep;
+	sfe->ref.ref = 1;
+	sfe->ssf.share = *sharep;
 	sfe->next = sharedfiletable.list;
 	sharedfiletable.list = sfe;
 done:
 	smblogprintif(smbglobals.log.sharedfiles, "smbsharedfileget: ref %d share %d\n",
-		sfe->ref, sfe->share);
-	qunlock(&sharedfiletable);
-	return sfe;
+		sfe->ref.ref, sfe->ssf.share);
+	qunlock(&sharedfiletable.qlock);
+	return &sfe->ssf;
 }
 
 void
 smbsharedfileput(SmbFile *f, SmbSharedFile *sf, int share)
 {
 	SmbSharedFileEntry *sfe, **sfep;
-	qlock(&sharedfiletable);
+	qlock(&sharedfiletable.qlock);
 	for (sfep = &sharedfiletable.list; (sfe = *sfep) != nil; sfep = &sfe->next) {
-		if (sfe == sf) {
-			sfe->ref--;
-			if (sfe->ref == 0) {
+		if (&sfe->ssf == sf) {
+			sfe->ref.ref--;
+			if (sfe->ref.ref == 0) {
 				*sfep = sfe->next;
-				if (sfe->deleteonclose && f)
+				if (sfe->ssf.deleteonclose && f)
 					smbremovefile(f->t, nil, f->name);
 				smblogprintif(smbglobals.log.sharedfiles, "smbsharedfileput: removed\n");
-				locklistfree(&sfe->locklist);
+				locklistfree(&sfe->ssf.locklist);
 				free(sfe);
 			}
 			else {
-				sfe->share = sharesubtract(sfe->share, share);
+				sfe->ssf.share = sharesubtract(sfe->ssf.share, share);
 				smblogprintif(smbglobals.log.sharedfiles,
-					"smbsharedfileput: ref %d share %d\n", sfe->ref, sfe->share);
+					"smbsharedfileput: ref %d share %d\n", sfe->ref.ref, sfe->ssf.share);
 			}
 			break;
 		}
 	}
-	qunlock(&sharedfiletable);
+	qunlock(&sharedfiletable.qlock);
 }

sys/src/cmd/aquarela/smbtrans2find.c

@@ -99,7 +99,7 @@ poolcheck(mainmem);
 		|| !smbbufferputv(b, mtime)
 		|| !smbbufferputv(b, mtime)
 		|| !smbbufferputv(b, d->length)
-		|| !smbbufferputv(b, smbl2roundupvlong(d->length, smbglobals.l2allocationsize))			// ha
+		|| !smbbufferputv(b, smbl2roundupint64_t(d->length, smbglobals.l2allocationsize))			// ha
 		|| !smbbufferputl(b, (d->qid.type & QTDIR) ? 0x10 : 0x80)
 		|| !smbbufferputl(b, smbstringlen(p, d->name))
 		|| !smbbufferputl(b, 0)

sys/src/cmd/aquarela/smbtrans2query.c

@@ -86,7 +86,7 @@ query(SmbSession *s, char *cmdname, char *filename, uint16_t infolevel,
 		translogprint(s->transaction.in.setup[0], "length=%lld", d->length);
 		translogprint(s->transaction.in.setup[0], "isdir=%d\n", (d->qid.type & QTDIR) != 0);
 
-		if (!smbbufferputv(s->transaction.out.data, smbl2roundupvlong(d->length, smbglobals.l2allocationsize))
+		if (!smbbufferputv(s->transaction.out.data, smbl2roundupint64_t(d->length, smbglobals.l2allocationsize))
 			|| !smbbufferputv(s->transaction.out.data, d->length)
 			|| !smbbufferputl(s->transaction.out.data, 1)
 			|| !smbbufferputb(s->transaction.out.data, 0)

sys/src/cmd/aquarela/smbtrans2set.c

@@ -122,7 +122,7 @@ smbtrans2setpathinformation(SmbSession *s, SmbHeader *h)
 	uint32_t attr;
 	uint32_t mode;
 	uint32_t size;
-//	uvlong length;
+//	uint64_t length;
 
 	t = smbidmapfind(s->tidmap, h->tid);
 	if (t == nil) {

sys/src/cmd/aquarela/smbtransaction.c

@@ -51,7 +51,7 @@ _smbtransactiondecodeprimary(SmbTransaction *t, SmbHeader *h, uint8_t *pdata,
 	doffset = smbnhgets(pdata); pdata += 2;
 	pdata++; /* scount */
 	pdata++; /* reserved */
-	smbfree(&t->in.setup);
+	smbfree((void *)&t->in.setup);
 	if (t->in.scount) {
 		int x;
 		t->in.setup = smbemalloc(t->in.scount * sizeof(uint16_t));
@@ -60,7 +60,7 @@ _smbtransactiondecodeprimary(SmbTransaction *t, SmbHeader *h, uint8_t *pdata,
 			pdata += 2;
 		}
 	}
-	smbfree(&t->in.name);
+	smbfree((void *)&t->in.name);
 	if (hasname && !smbbuffergetstring(b, h, SMB_STRING_PATH, &t->in.name)) {
 		smbstringprint(errmsgp, "not enough bdata for name");
 		return -1;
@@ -73,7 +73,7 @@ _smbtransactiondecodeprimary(SmbTransaction *t, SmbHeader *h, uint8_t *pdata,
 		smbstringprint(errmsgp, "too many parameters");
 		return -1;
 	}
-	smbfree(&t->in.parameters);
+	smbfree((void *)&t->in.parameters);
 	t->in.parameters = smbemalloc(t->in.tpcount);
 	memcpy(t->in.parameters, smbbufferpointer(b, poffset), t->in.pcount);
 	if (doffset + t->in.dcount > smbbufferwriteoffset(b)) {
@@ -84,7 +84,7 @@ _smbtransactiondecodeprimary(SmbTransaction *t, SmbHeader *h, uint8_t *pdata,
 		smbstringprint(errmsgp, "too much data");
 		return -1;
 	}
-	smbfree(&t->in.data);
+	smbfree((void *)&t->in.data);
 	t->in.data = smbemalloc(t->in.tdcount);
 	memcpy(t->in.data, smbbufferpointer(b, doffset), t->in.dcount);
 	if (t->in.dcount < t->in.tdcount || t->in.pcount < t->in.tpcount)