35
36#include <sys/param.h>
37#include <sys/condvar.h>
38#include <sys/kernel.h>
39#include <sys/lock.h>
40#include <sys/malloc.h>
41#include <sys/mbuf.h>
42#include <sys/poll.h>
43#include <sys/proc.h>
44#include <sys/protosw.h>
45#include <sys/signalvar.h>
46#include <sys/socket.h>
47#include <sys/socketvar.h>
48#include <sys/sx.h>
49#include <sys/sysctl.h>
50#include <sys/systm.h>
51#include <sys/uio.h>
52
53#include <net/if.h>
54#include <net/route.h>
55
56#include <netinet/in.h>
57#include <netinet/tcp.h>
58
59#include <sys/mchain.h>
60
61#include <netsmb/netbios.h>
62
63#include <netsmb/smb.h>
64#include <netsmb/smb_conn.h>
65#include <netsmb/smb_tran.h>
66#include <netsmb/smb_trantcp.h>
67#include <netsmb/smb_subr.h>
68
69#define M_NBDATA M_PCB
70
71static int smb_tcpsndbuf = NB_SNDQ - 1;
72static int smb_tcprcvbuf = NB_RCVQ - 1;
73
74SYSCTL_DECL(_net_smb);
75SYSCTL_INT(_net_smb, OID_AUTO, tcpsndbuf, CTLFLAG_RW, &smb_tcpsndbuf, 0, "");
76SYSCTL_INT(_net_smb, OID_AUTO, tcprcvbuf, CTLFLAG_RW, &smb_tcprcvbuf, 0, "");
77
78#define nb_sosend(so,m,flags,td) sosend(so, NULL, 0, m, 0, flags, td)
79
80static int nbssn_recv(struct nbpcb *nbp, struct mbuf **mpp, int *lenp,
81 u_int8_t *rpcodep, struct thread *td);
82static int smb_nbst_disconnect(struct smb_vc *vcp, struct thread *td);
83
84static int
85nb_setsockopt_int(struct socket *so, int level, int name, int val)
86{
87 struct sockopt sopt;
88
89 bzero(&sopt, sizeof(sopt));
90 sopt.sopt_level = level;
91 sopt.sopt_name = name;
92 sopt.sopt_val = &val;
93 sopt.sopt_valsize = sizeof(val);
94 return sosetopt(so, &sopt);
95}
96
97static int
98nb_intr(struct nbpcb *nbp, struct proc *p)
99{
100 return 0;
101}
102
103static int
104nb_upcall(struct socket *so, void *arg, int waitflag)
105{
106 struct nbpcb *nbp = arg;
107
108 if (arg == NULL || nbp->nbp_selectid == NULL)
109 return (SU_OK);
110 wakeup(nbp->nbp_selectid);
111 return (SU_OK);
112}
113
114static int
115nb_sethdr(struct mbuf *m, u_int8_t type, u_int32_t len)
116{
117 u_int32_t *p = mtod(m, u_int32_t *);
118
119 *p = htonl((len & 0x1FFFF) | (type << 24));
120 return 0;
121}
122
123static int
124nb_put_name(struct mbchain *mbp, struct sockaddr_nb *snb)
125{
126 int error;
127 u_char seglen, *cp;
128
129 cp = snb->snb_name;
130 if (*cp == 0)
131 return EINVAL;
132 NBDEBUG("[%s]\n", cp);
133 for (;;) {
134 seglen = (*cp) + 1;
135 error = mb_put_mem(mbp, cp, seglen, MB_MSYSTEM);
136 if (error)
137 return error;
138 if (seglen == 1)
139 break;
140 cp += seglen;
141 }
142 return 0;
143}
144
145static int
146nb_connect_in(struct nbpcb *nbp, struct sockaddr_in *to, struct thread *td)
147{
148 struct socket *so;
149 int error, s;
150
151 error = socreate(AF_INET, &so, SOCK_STREAM, IPPROTO_TCP,
152 td->td_ucred, td);
153 if (error)
154 return error;
155 nbp->nbp_tso = so;
156 SOCKBUF_LOCK(&so->so_rcv);
157 soupcall_set(so, SO_RCV, nb_upcall, nbp);
158 SOCKBUF_UNLOCK(&so->so_rcv);
159 so->so_rcv.sb_timeo = (5 * hz);
160 so->so_snd.sb_timeo = (5 * hz);
161 error = soreserve(so, nbp->nbp_sndbuf, nbp->nbp_rcvbuf);
162 if (error)
163 goto bad;
164 nb_setsockopt_int(so, SOL_SOCKET, SO_KEEPALIVE, 1);
165 nb_setsockopt_int(so, IPPROTO_TCP, TCP_NODELAY, 1);
166 SOCKBUF_LOCK(&so->so_rcv);
167 so->so_rcv.sb_flags &= ~SB_NOINTR;
168 SOCKBUF_UNLOCK(&so->so_rcv);
169 SOCKBUF_LOCK(&so->so_snd);
170 so->so_snd.sb_flags &= ~SB_NOINTR;
171 SOCKBUF_UNLOCK(&so->so_snd);
172 error = soconnect(so, (struct sockaddr*)to, td);
173 if (error)
174 goto bad;
175 s = splnet();
176 while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
177 tsleep(&so->so_timeo, PSOCK, "nbcon", 2 * hz);
178 if ((so->so_state & SS_ISCONNECTING) && so->so_error == 0 &&
179 (error = nb_intr(nbp, td->td_proc)) != 0) {
180 so->so_state &= ~SS_ISCONNECTING;
181 splx(s);
182 goto bad;
183 }
184 }
185 if (so->so_error) {
186 error = so->so_error;
187 so->so_error = 0;
188 splx(s);
189 goto bad;
190 }
191 splx(s);
192 return 0;
193bad:
194 smb_nbst_disconnect(nbp->nbp_vc, td);
195 return error;
196}
197
198static int
199nbssn_rq_request(struct nbpcb *nbp, struct thread *td)
200{
201 struct mbchain mb, *mbp = &mb;
202 struct mdchain md, *mdp = &md;
203 struct mbuf *m0;
204 struct timeval tv;
205 struct sockaddr_in sin;
206 u_short port;
207 u_int8_t rpcode;
208 int error, rplen;
209
210 error = mb_init(mbp);
211 if (error)
212 return error;
213 mb_put_uint32le(mbp, 0);
214 nb_put_name(mbp, nbp->nbp_paddr);
215 nb_put_name(mbp, nbp->nbp_laddr);
216 nb_sethdr(mbp->mb_top, NB_SSN_REQUEST, mb_fixhdr(mbp) - 4);
217 error = nb_sosend(nbp->nbp_tso, mbp->mb_top, 0, td);
218 if (!error) {
219 nbp->nbp_state = NBST_RQSENT;
220 }
221 mb_detach(mbp);
222 mb_done(mbp);
223 if (error)
224 return error;
225 TIMESPEC_TO_TIMEVAL(&tv, &nbp->nbp_timo);
226 error = selsocket(nbp->nbp_tso, POLLIN, &tv, td);
227 if (error == EWOULDBLOCK) { /* Timeout */
228 NBDEBUG("initial request timeout\n");
229 return ETIMEDOUT;
230 }
231 if (error) /* restart or interrupt */
232 return error;
233 error = nbssn_recv(nbp, &m0, &rplen, &rpcode, td);
234 if (error) {
235 NBDEBUG("recv() error %d\n", error);
236 return error;
237 }
238 /*
239 * Process NETBIOS reply
240 */
241 if (m0)
242 md_initm(mdp, m0);
243 error = 0;
244 do {
245 if (rpcode == NB_SSN_POSRESP) {
246 nbp->nbp_state = NBST_SESSION;
247 nbp->nbp_flags |= NBF_CONNECTED;
248 break;
249 }
250 if (rpcode != NB_SSN_RTGRESP) {
251 error = ECONNABORTED;
252 break;
253 }
254 if (rplen != 6) {
255 error = ECONNABORTED;
256 break;
257 }
258 md_get_mem(mdp, (caddr_t)&sin.sin_addr, 4, MB_MSYSTEM);
259 md_get_uint16(mdp, &port);
260 sin.sin_port = port;
261 nbp->nbp_state = NBST_RETARGET;
262 smb_nbst_disconnect(nbp->nbp_vc, td);
263 error = nb_connect_in(nbp, &sin, td);
264 if (!error)
265 error = nbssn_rq_request(nbp, td);
266 if (error) {
267 smb_nbst_disconnect(nbp->nbp_vc, td);
268 break;
269 }
270 } while(0);
271 if (m0)
272 md_done(mdp);
273 return error;
274}
275
276static int
277nbssn_recvhdr(struct nbpcb *nbp, int *lenp,
278 u_int8_t *rpcodep, int flags, struct thread *td)
279{
280 struct socket *so = nbp->nbp_tso;
281 struct uio auio;
282 struct iovec aio;
283 u_int32_t len;
284 int error;
285
286 aio.iov_base = (caddr_t)&len;
287 aio.iov_len = sizeof(len);
288 auio.uio_iov = &aio;
289 auio.uio_iovcnt = 1;
290 auio.uio_segflg = UIO_SYSSPACE;
291 auio.uio_rw = UIO_READ;
292 auio.uio_offset = 0;
293 auio.uio_resid = sizeof(len);
294 auio.uio_td = td;
295 error = soreceive(so, (struct sockaddr **)NULL, &auio,
296 (struct mbuf **)NULL, (struct mbuf **)NULL, &flags);
297 if (error)
298 return error;
299 if (auio.uio_resid > 0) {
300 SMBSDEBUG("short reply\n");
301 return EPIPE;
302 }
303 len = ntohl(len);
304 *rpcodep = (len >> 24) & 0xFF;
305 len &= 0x1ffff;
306 if (len > SMB_MAXPKTLEN) {
307 SMBERROR("packet too long (%d)\n", len);
308 return EFBIG;
309 }
310 *lenp = len;
311 return 0;
312}
313
314static int
315nbssn_recv(struct nbpcb *nbp, struct mbuf **mpp, int *lenp,
316 u_int8_t *rpcodep, struct thread *td)
317{
318 struct socket *so = nbp->nbp_tso;
319 struct uio auio;
320 struct mbuf *m, *tm, *im;
321 u_int8_t rpcode;
322 int len, resid;
323 int error, rcvflg;
324
325 if (so == NULL)
326 return ENOTCONN;
327
328 if (mpp)
329 *mpp = NULL;
330 m = NULL;
331 for(;;) {
332 /*
333 * Poll for a response header.
334 * If we don't have one waiting, return.
335 */
336 len = 0;
337 rpcode = 0;
338 error = nbssn_recvhdr(nbp, &len, &rpcode, MSG_DONTWAIT, td);
339 if ((so->so_state & (SS_ISDISCONNECTING | SS_ISDISCONNECTED)) ||
340 (so->so_rcv.sb_state & SBS_CANTRCVMORE)) {
341 nbp->nbp_state = NBST_CLOSED;
342 NBDEBUG("session closed by peer\n");
343 return ECONNRESET;
344 }
345 if (error)
346 return error;
347 if (len == 0 && nbp->nbp_state != NBST_SESSION)
348 break;
349 /* no data, try again */
350 if (rpcode == NB_SSN_KEEPALIVE)
351 continue;
352
353 /*
354 * Loop, blocking, for data following the response header.
355 *
356 * Note that we can't simply block here with MSG_WAITALL for the
357 * entire response size, as it may be larger than the TCP
358 * slow-start window that the sender employs. This will result
359 * in the sender stalling until the delayed ACK is sent, then
360 * resuming slow-start, resulting in very poor performance.
361 *
362 * Instead, we never request more than NB_SORECEIVE_CHUNK
363 * bytes at a time, resulting in an ack being pushed by
364 * the TCP code at the completion of each call.
365 */
366 resid = len;
367 while (resid > 0) {
368 tm = NULL;
369 rcvflg = MSG_WAITALL;
370 bzero(&auio, sizeof(auio));
371 auio.uio_resid = min(resid, NB_SORECEIVE_CHUNK);
372 auio.uio_td = td;
373 resid -= auio.uio_resid;
374 /*
375 * Spin until we have collected everything in
376 * this chunk.
377 */
378 do {
379 rcvflg = MSG_WAITALL;
380 error = soreceive(so, (struct sockaddr **)NULL,
381 &auio, &tm, (struct mbuf **)NULL, &rcvflg);
382 } while (error == EWOULDBLOCK || error == EINTR ||
383 error == ERESTART);
384 if (error)
385 goto out;
386 /* short return guarantees unhappiness */
387 if (auio.uio_resid > 0) {
388 SMBERROR("packet is shorter than expected\n");
389 error = EPIPE;
390 goto out;
391 }
392 /* append received chunk to previous chunk(s) */
393 if (m == NULL) {
394 m = tm;
395 } else {
396 /*
397 * Just glue the new chain on the end.
398 * Consumer will pullup as required.
399 */
400 for (im = m; im->m_next != NULL; im = im->m_next)
401 ;
402 im->m_next = tm;
403 }
404 }
405 /* got a session/message packet? */
406 if (nbp->nbp_state == NBST_SESSION &&
407 rpcode == NB_SSN_MESSAGE)
408 break;
409 /* drop packet and try for another */
410 NBDEBUG("non-session packet %x\n", rpcode);
411 if (m) {
412 m_freem(m);
413 m = NULL;
414 }
415 }
416
417out:
418 if (error) {
419 if (m)
420 m_freem(m);
421 return error;
422 }
423 if (mpp)
424 *mpp = m;
425 else
426 m_freem(m);
427 *lenp = len;
428 *rpcodep = rpcode;
429 return 0;
430}
431
432/*
433 * SMB transport interface
434 */
435static int
436smb_nbst_create(struct smb_vc *vcp, struct thread *td)
437{
438 struct nbpcb *nbp;
439
440 nbp = malloc(sizeof *nbp, M_NBDATA, M_WAITOK);
441 bzero(nbp, sizeof *nbp);
442 nbp->nbp_timo.tv_sec = 15; /* XXX: sysctl ? */
443 nbp->nbp_state = NBST_CLOSED;
444 nbp->nbp_vc = vcp;
445 nbp->nbp_sndbuf = smb_tcpsndbuf;
446 nbp->nbp_rcvbuf = smb_tcprcvbuf;
447 vcp->vc_tdata = nbp;
448 return 0;
449}
450
451static int
452smb_nbst_done(struct smb_vc *vcp, struct thread *td)
453{
454 struct nbpcb *nbp = vcp->vc_tdata;
455
456 if (nbp == NULL)
457 return ENOTCONN;
458 smb_nbst_disconnect(vcp, td);
459 if (nbp->nbp_laddr)
460 free(nbp->nbp_laddr, M_SONAME);
461 if (nbp->nbp_paddr)
462 free(nbp->nbp_paddr, M_SONAME);
463 free(nbp, M_NBDATA);
464 return 0;
465}
466
467static int
468smb_nbst_bind(struct smb_vc *vcp, struct sockaddr *sap, struct thread *td)
469{
470 struct nbpcb *nbp = vcp->vc_tdata;
471 struct sockaddr_nb *snb;
472 int error, slen;
473
474 NBDEBUG("\n");
475 error = EINVAL;
476 do {
477 if (nbp->nbp_flags & NBF_LOCADDR)
478 break;
479 /*
480 * It is possible to create NETBIOS name in the kernel,
481 * but nothing prevents us to do it in the user space.
482 */
483 if (sap == NULL)
484 break;
485 slen = sap->sa_len;
486 if (slen < NB_MINSALEN)
487 break;
488 snb = (struct sockaddr_nb*)sodupsockaddr(sap, M_WAITOK);
489 if (snb == NULL) {
490 error = ENOMEM;
491 break;
492 }
493 nbp->nbp_laddr = snb;
494 nbp->nbp_flags |= NBF_LOCADDR;
495 error = 0;
496 } while(0);
497 return error;
498}
499
500static int
501smb_nbst_connect(struct smb_vc *vcp, struct sockaddr *sap, struct thread *td)
502{
503 struct nbpcb *nbp = vcp->vc_tdata;
504 struct sockaddr_in sin;
505 struct sockaddr_nb *snb;
506 struct timespec ts1, ts2;
507 int error, slen;
508
509 NBDEBUG("\n");
510 if (nbp->nbp_tso != NULL)
511 return EISCONN;
512 if (nbp->nbp_laddr == NULL)
513 return EINVAL;
514 slen = sap->sa_len;
515 if (slen < NB_MINSALEN)
516 return EINVAL;
517 if (nbp->nbp_paddr) {
518 free(nbp->nbp_paddr, M_SONAME);
519 nbp->nbp_paddr = NULL;
520 }
521 snb = (struct sockaddr_nb*)sodupsockaddr(sap, M_WAITOK);
522 if (snb == NULL)
523 return ENOMEM;
524 nbp->nbp_paddr = snb;
525 sin = snb->snb_addrin;
526 getnanotime(&ts1);
527 error = nb_connect_in(nbp, &sin, td);
528 if (error)
529 return error;
530 getnanotime(&ts2);
531 timespecsub(&ts2, &ts1);
532 if (ts2.tv_sec == 0 && ts2.tv_sec == 0)
533 ts2.tv_sec = 1;
534 nbp->nbp_timo = ts2;
535 timespecadd(&nbp->nbp_timo, &ts2);
536 timespecadd(&nbp->nbp_timo, &ts2);
537 timespecadd(&nbp->nbp_timo, &ts2); /* * 4 */
538 error = nbssn_rq_request(nbp, td);
539 if (error)
540 smb_nbst_disconnect(vcp, td);
541 return error;
542}
543
544static int
545smb_nbst_disconnect(struct smb_vc *vcp, struct thread *td)
546{
547 struct nbpcb *nbp = vcp->vc_tdata;
548 struct socket *so;
549
550 if (nbp == NULL || nbp->nbp_tso == NULL)
551 return ENOTCONN;
552 if ((so = nbp->nbp_tso) != NULL) {
553 nbp->nbp_flags &= ~NBF_CONNECTED;
554 nbp->nbp_tso = (struct socket *)NULL;
555 soshutdown(so, 2);
556 soclose(so);
557 }
558 if (nbp->nbp_state != NBST_RETARGET) {
559 nbp->nbp_state = NBST_CLOSED;
560 }
561 return 0;
562}
563
564static int
565smb_nbst_send(struct smb_vc *vcp, struct mbuf *m0, struct thread *td)
566{
567 struct nbpcb *nbp = vcp->vc_tdata;
568 int error;
569
570 if (nbp->nbp_state != NBST_SESSION) {
571 error = ENOTCONN;
572 goto abort;
573 }
574 M_PREPEND(m0, 4, M_WAIT);
575 nb_sethdr(m0, NB_SSN_MESSAGE, m_fixhdr(m0) - 4);
576 error = nb_sosend(nbp->nbp_tso, m0, 0, td);
577 return error;
578abort:
579 if (m0)
580 m_freem(m0);
581 return error;
582}
583
584
585static int
586smb_nbst_recv(struct smb_vc *vcp, struct mbuf **mpp, struct thread *td)
587{
588 struct nbpcb *nbp = vcp->vc_tdata;
589 u_int8_t rpcode;
590 int error, rplen;
591
592 nbp->nbp_flags |= NBF_RECVLOCK;
593 error = nbssn_recv(nbp, mpp, &rplen, &rpcode, td);
594 nbp->nbp_flags &= ~NBF_RECVLOCK;
595 return error;
596}
597
598static void
599smb_nbst_timo(struct smb_vc *vcp)
600{
601 return;
602}
603
604static void
605smb_nbst_intr(struct smb_vc *vcp)
606{
607 struct nbpcb *nbp = vcp->vc_tdata;
608
609 if (nbp == NULL || nbp->nbp_tso == NULL)
610 return;
611 sorwakeup(nbp->nbp_tso);
612 sowwakeup(nbp->nbp_tso);
613}
614
615static int
616smb_nbst_getparam(struct smb_vc *vcp, int param, void *data)
617{
618 struct nbpcb *nbp = vcp->vc_tdata;
619
620 switch (param) {
621 case SMBTP_SNDSZ:
622 *(int*)data = nbp->nbp_sndbuf;
623 break;
624 case SMBTP_RCVSZ:
625 *(int*)data = nbp->nbp_rcvbuf;
626 break;
627 case SMBTP_TIMEOUT:
628 *(struct timespec*)data = nbp->nbp_timo;
629 break;
630 default:
631 return EINVAL;
632 }
633 return 0;
634}
635
636static int
637smb_nbst_setparam(struct smb_vc *vcp, int param, void *data)
638{
639 struct nbpcb *nbp = vcp->vc_tdata;
640
641 switch (param) {
642 case SMBTP_SELECTID:
643 nbp->nbp_selectid = data;
644 break;
645 default:
646 return EINVAL;
647 }
648 return 0;
649}
650
651/*
652 * Check for fatal errors
653 */
654static int
655smb_nbst_fatal(struct smb_vc *vcp, int error)
656{
657 switch (error) {
658 case ENOTCONN:
659 case ENETRESET:
660 case ECONNABORTED:
661 return 1;
662 }
663 return 0;
664}
665
666
667struct smb_tran_desc smb_tran_nbtcp_desc = {
668 SMBT_NBTCP,
669 smb_nbst_create, smb_nbst_done,
670 smb_nbst_bind, smb_nbst_connect, smb_nbst_disconnect,
671 smb_nbst_send, smb_nbst_recv,
672 smb_nbst_timo, smb_nbst_intr,
673 smb_nbst_getparam, smb_nbst_setparam,
674 smb_nbst_fatal
675};
676
| 29
30#include <sys/param.h>
31#include <sys/condvar.h>
32#include <sys/kernel.h>
33#include <sys/lock.h>
34#include <sys/malloc.h>
35#include <sys/mbuf.h>
36#include <sys/poll.h>
37#include <sys/proc.h>
38#include <sys/protosw.h>
39#include <sys/signalvar.h>
40#include <sys/socket.h>
41#include <sys/socketvar.h>
42#include <sys/sx.h>
43#include <sys/sysctl.h>
44#include <sys/systm.h>
45#include <sys/uio.h>
46
47#include <net/if.h>
48#include <net/route.h>
49
50#include <netinet/in.h>
51#include <netinet/tcp.h>
52
53#include <sys/mchain.h>
54
55#include <netsmb/netbios.h>
56
57#include <netsmb/smb.h>
58#include <netsmb/smb_conn.h>
59#include <netsmb/smb_tran.h>
60#include <netsmb/smb_trantcp.h>
61#include <netsmb/smb_subr.h>
62
63#define M_NBDATA M_PCB
64
65static int smb_tcpsndbuf = NB_SNDQ - 1;
66static int smb_tcprcvbuf = NB_RCVQ - 1;
67
68SYSCTL_DECL(_net_smb);
69SYSCTL_INT(_net_smb, OID_AUTO, tcpsndbuf, CTLFLAG_RW, &smb_tcpsndbuf, 0, "");
70SYSCTL_INT(_net_smb, OID_AUTO, tcprcvbuf, CTLFLAG_RW, &smb_tcprcvbuf, 0, "");
71
72#define nb_sosend(so,m,flags,td) sosend(so, NULL, 0, m, 0, flags, td)
73
74static int nbssn_recv(struct nbpcb *nbp, struct mbuf **mpp, int *lenp,
75 u_int8_t *rpcodep, struct thread *td);
76static int smb_nbst_disconnect(struct smb_vc *vcp, struct thread *td);
77
78static int
79nb_setsockopt_int(struct socket *so, int level, int name, int val)
80{
81 struct sockopt sopt;
82
83 bzero(&sopt, sizeof(sopt));
84 sopt.sopt_level = level;
85 sopt.sopt_name = name;
86 sopt.sopt_val = &val;
87 sopt.sopt_valsize = sizeof(val);
88 return sosetopt(so, &sopt);
89}
90
91static int
92nb_intr(struct nbpcb *nbp, struct proc *p)
93{
94 return 0;
95}
96
97static int
98nb_upcall(struct socket *so, void *arg, int waitflag)
99{
100 struct nbpcb *nbp = arg;
101
102 if (arg == NULL || nbp->nbp_selectid == NULL)
103 return (SU_OK);
104 wakeup(nbp->nbp_selectid);
105 return (SU_OK);
106}
107
108static int
109nb_sethdr(struct mbuf *m, u_int8_t type, u_int32_t len)
110{
111 u_int32_t *p = mtod(m, u_int32_t *);
112
113 *p = htonl((len & 0x1FFFF) | (type << 24));
114 return 0;
115}
116
117static int
118nb_put_name(struct mbchain *mbp, struct sockaddr_nb *snb)
119{
120 int error;
121 u_char seglen, *cp;
122
123 cp = snb->snb_name;
124 if (*cp == 0)
125 return EINVAL;
126 NBDEBUG("[%s]\n", cp);
127 for (;;) {
128 seglen = (*cp) + 1;
129 error = mb_put_mem(mbp, cp, seglen, MB_MSYSTEM);
130 if (error)
131 return error;
132 if (seglen == 1)
133 break;
134 cp += seglen;
135 }
136 return 0;
137}
138
139static int
140nb_connect_in(struct nbpcb *nbp, struct sockaddr_in *to, struct thread *td)
141{
142 struct socket *so;
143 int error, s;
144
145 error = socreate(AF_INET, &so, SOCK_STREAM, IPPROTO_TCP,
146 td->td_ucred, td);
147 if (error)
148 return error;
149 nbp->nbp_tso = so;
150 SOCKBUF_LOCK(&so->so_rcv);
151 soupcall_set(so, SO_RCV, nb_upcall, nbp);
152 SOCKBUF_UNLOCK(&so->so_rcv);
153 so->so_rcv.sb_timeo = (5 * hz);
154 so->so_snd.sb_timeo = (5 * hz);
155 error = soreserve(so, nbp->nbp_sndbuf, nbp->nbp_rcvbuf);
156 if (error)
157 goto bad;
158 nb_setsockopt_int(so, SOL_SOCKET, SO_KEEPALIVE, 1);
159 nb_setsockopt_int(so, IPPROTO_TCP, TCP_NODELAY, 1);
160 SOCKBUF_LOCK(&so->so_rcv);
161 so->so_rcv.sb_flags &= ~SB_NOINTR;
162 SOCKBUF_UNLOCK(&so->so_rcv);
163 SOCKBUF_LOCK(&so->so_snd);
164 so->so_snd.sb_flags &= ~SB_NOINTR;
165 SOCKBUF_UNLOCK(&so->so_snd);
166 error = soconnect(so, (struct sockaddr*)to, td);
167 if (error)
168 goto bad;
169 s = splnet();
170 while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
171 tsleep(&so->so_timeo, PSOCK, "nbcon", 2 * hz);
172 if ((so->so_state & SS_ISCONNECTING) && so->so_error == 0 &&
173 (error = nb_intr(nbp, td->td_proc)) != 0) {
174 so->so_state &= ~SS_ISCONNECTING;
175 splx(s);
176 goto bad;
177 }
178 }
179 if (so->so_error) {
180 error = so->so_error;
181 so->so_error = 0;
182 splx(s);
183 goto bad;
184 }
185 splx(s);
186 return 0;
187bad:
188 smb_nbst_disconnect(nbp->nbp_vc, td);
189 return error;
190}
191
192static int
193nbssn_rq_request(struct nbpcb *nbp, struct thread *td)
194{
195 struct mbchain mb, *mbp = &mb;
196 struct mdchain md, *mdp = &md;
197 struct mbuf *m0;
198 struct timeval tv;
199 struct sockaddr_in sin;
200 u_short port;
201 u_int8_t rpcode;
202 int error, rplen;
203
204 error = mb_init(mbp);
205 if (error)
206 return error;
207 mb_put_uint32le(mbp, 0);
208 nb_put_name(mbp, nbp->nbp_paddr);
209 nb_put_name(mbp, nbp->nbp_laddr);
210 nb_sethdr(mbp->mb_top, NB_SSN_REQUEST, mb_fixhdr(mbp) - 4);
211 error = nb_sosend(nbp->nbp_tso, mbp->mb_top, 0, td);
212 if (!error) {
213 nbp->nbp_state = NBST_RQSENT;
214 }
215 mb_detach(mbp);
216 mb_done(mbp);
217 if (error)
218 return error;
219 TIMESPEC_TO_TIMEVAL(&tv, &nbp->nbp_timo);
220 error = selsocket(nbp->nbp_tso, POLLIN, &tv, td);
221 if (error == EWOULDBLOCK) { /* Timeout */
222 NBDEBUG("initial request timeout\n");
223 return ETIMEDOUT;
224 }
225 if (error) /* restart or interrupt */
226 return error;
227 error = nbssn_recv(nbp, &m0, &rplen, &rpcode, td);
228 if (error) {
229 NBDEBUG("recv() error %d\n", error);
230 return error;
231 }
232 /*
233 * Process NETBIOS reply
234 */
235 if (m0)
236 md_initm(mdp, m0);
237 error = 0;
238 do {
239 if (rpcode == NB_SSN_POSRESP) {
240 nbp->nbp_state = NBST_SESSION;
241 nbp->nbp_flags |= NBF_CONNECTED;
242 break;
243 }
244 if (rpcode != NB_SSN_RTGRESP) {
245 error = ECONNABORTED;
246 break;
247 }
248 if (rplen != 6) {
249 error = ECONNABORTED;
250 break;
251 }
252 md_get_mem(mdp, (caddr_t)&sin.sin_addr, 4, MB_MSYSTEM);
253 md_get_uint16(mdp, &port);
254 sin.sin_port = port;
255 nbp->nbp_state = NBST_RETARGET;
256 smb_nbst_disconnect(nbp->nbp_vc, td);
257 error = nb_connect_in(nbp, &sin, td);
258 if (!error)
259 error = nbssn_rq_request(nbp, td);
260 if (error) {
261 smb_nbst_disconnect(nbp->nbp_vc, td);
262 break;
263 }
264 } while(0);
265 if (m0)
266 md_done(mdp);
267 return error;
268}
269
270static int
271nbssn_recvhdr(struct nbpcb *nbp, int *lenp,
272 u_int8_t *rpcodep, int flags, struct thread *td)
273{
274 struct socket *so = nbp->nbp_tso;
275 struct uio auio;
276 struct iovec aio;
277 u_int32_t len;
278 int error;
279
280 aio.iov_base = (caddr_t)&len;
281 aio.iov_len = sizeof(len);
282 auio.uio_iov = &aio;
283 auio.uio_iovcnt = 1;
284 auio.uio_segflg = UIO_SYSSPACE;
285 auio.uio_rw = UIO_READ;
286 auio.uio_offset = 0;
287 auio.uio_resid = sizeof(len);
288 auio.uio_td = td;
289 error = soreceive(so, (struct sockaddr **)NULL, &auio,
290 (struct mbuf **)NULL, (struct mbuf **)NULL, &flags);
291 if (error)
292 return error;
293 if (auio.uio_resid > 0) {
294 SMBSDEBUG("short reply\n");
295 return EPIPE;
296 }
297 len = ntohl(len);
298 *rpcodep = (len >> 24) & 0xFF;
299 len &= 0x1ffff;
300 if (len > SMB_MAXPKTLEN) {
301 SMBERROR("packet too long (%d)\n", len);
302 return EFBIG;
303 }
304 *lenp = len;
305 return 0;
306}
307
308static int
309nbssn_recv(struct nbpcb *nbp, struct mbuf **mpp, int *lenp,
310 u_int8_t *rpcodep, struct thread *td)
311{
312 struct socket *so = nbp->nbp_tso;
313 struct uio auio;
314 struct mbuf *m, *tm, *im;
315 u_int8_t rpcode;
316 int len, resid;
317 int error, rcvflg;
318
319 if (so == NULL)
320 return ENOTCONN;
321
322 if (mpp)
323 *mpp = NULL;
324 m = NULL;
325 for(;;) {
326 /*
327 * Poll for a response header.
328 * If we don't have one waiting, return.
329 */
330 len = 0;
331 rpcode = 0;
332 error = nbssn_recvhdr(nbp, &len, &rpcode, MSG_DONTWAIT, td);
333 if ((so->so_state & (SS_ISDISCONNECTING | SS_ISDISCONNECTED)) ||
334 (so->so_rcv.sb_state & SBS_CANTRCVMORE)) {
335 nbp->nbp_state = NBST_CLOSED;
336 NBDEBUG("session closed by peer\n");
337 return ECONNRESET;
338 }
339 if (error)
340 return error;
341 if (len == 0 && nbp->nbp_state != NBST_SESSION)
342 break;
343 /* no data, try again */
344 if (rpcode == NB_SSN_KEEPALIVE)
345 continue;
346
347 /*
348 * Loop, blocking, for data following the response header.
349 *
350 * Note that we can't simply block here with MSG_WAITALL for the
351 * entire response size, as it may be larger than the TCP
352 * slow-start window that the sender employs. This will result
353 * in the sender stalling until the delayed ACK is sent, then
354 * resuming slow-start, resulting in very poor performance.
355 *
356 * Instead, we never request more than NB_SORECEIVE_CHUNK
357 * bytes at a time, resulting in an ack being pushed by
358 * the TCP code at the completion of each call.
359 */
360 resid = len;
361 while (resid > 0) {
362 tm = NULL;
363 rcvflg = MSG_WAITALL;
364 bzero(&auio, sizeof(auio));
365 auio.uio_resid = min(resid, NB_SORECEIVE_CHUNK);
366 auio.uio_td = td;
367 resid -= auio.uio_resid;
368 /*
369 * Spin until we have collected everything in
370 * this chunk.
371 */
372 do {
373 rcvflg = MSG_WAITALL;
374 error = soreceive(so, (struct sockaddr **)NULL,
375 &auio, &tm, (struct mbuf **)NULL, &rcvflg);
376 } while (error == EWOULDBLOCK || error == EINTR ||
377 error == ERESTART);
378 if (error)
379 goto out;
380 /* short return guarantees unhappiness */
381 if (auio.uio_resid > 0) {
382 SMBERROR("packet is shorter than expected\n");
383 error = EPIPE;
384 goto out;
385 }
386 /* append received chunk to previous chunk(s) */
387 if (m == NULL) {
388 m = tm;
389 } else {
390 /*
391 * Just glue the new chain on the end.
392 * Consumer will pullup as required.
393 */
394 for (im = m; im->m_next != NULL; im = im->m_next)
395 ;
396 im->m_next = tm;
397 }
398 }
399 /* got a session/message packet? */
400 if (nbp->nbp_state == NBST_SESSION &&
401 rpcode == NB_SSN_MESSAGE)
402 break;
403 /* drop packet and try for another */
404 NBDEBUG("non-session packet %x\n", rpcode);
405 if (m) {
406 m_freem(m);
407 m = NULL;
408 }
409 }
410
411out:
412 if (error) {
413 if (m)
414 m_freem(m);
415 return error;
416 }
417 if (mpp)
418 *mpp = m;
419 else
420 m_freem(m);
421 *lenp = len;
422 *rpcodep = rpcode;
423 return 0;
424}
425
426/*
427 * SMB transport interface
428 */
429static int
430smb_nbst_create(struct smb_vc *vcp, struct thread *td)
431{
432 struct nbpcb *nbp;
433
434 nbp = malloc(sizeof *nbp, M_NBDATA, M_WAITOK);
435 bzero(nbp, sizeof *nbp);
436 nbp->nbp_timo.tv_sec = 15; /* XXX: sysctl ? */
437 nbp->nbp_state = NBST_CLOSED;
438 nbp->nbp_vc = vcp;
439 nbp->nbp_sndbuf = smb_tcpsndbuf;
440 nbp->nbp_rcvbuf = smb_tcprcvbuf;
441 vcp->vc_tdata = nbp;
442 return 0;
443}
444
445static int
446smb_nbst_done(struct smb_vc *vcp, struct thread *td)
447{
448 struct nbpcb *nbp = vcp->vc_tdata;
449
450 if (nbp == NULL)
451 return ENOTCONN;
452 smb_nbst_disconnect(vcp, td);
453 if (nbp->nbp_laddr)
454 free(nbp->nbp_laddr, M_SONAME);
455 if (nbp->nbp_paddr)
456 free(nbp->nbp_paddr, M_SONAME);
457 free(nbp, M_NBDATA);
458 return 0;
459}
460
461static int
462smb_nbst_bind(struct smb_vc *vcp, struct sockaddr *sap, struct thread *td)
463{
464 struct nbpcb *nbp = vcp->vc_tdata;
465 struct sockaddr_nb *snb;
466 int error, slen;
467
468 NBDEBUG("\n");
469 error = EINVAL;
470 do {
471 if (nbp->nbp_flags & NBF_LOCADDR)
472 break;
473 /*
474 * It is possible to create NETBIOS name in the kernel,
475 * but nothing prevents us to do it in the user space.
476 */
477 if (sap == NULL)
478 break;
479 slen = sap->sa_len;
480 if (slen < NB_MINSALEN)
481 break;
482 snb = (struct sockaddr_nb*)sodupsockaddr(sap, M_WAITOK);
483 if (snb == NULL) {
484 error = ENOMEM;
485 break;
486 }
487 nbp->nbp_laddr = snb;
488 nbp->nbp_flags |= NBF_LOCADDR;
489 error = 0;
490 } while(0);
491 return error;
492}
493
494static int
495smb_nbst_connect(struct smb_vc *vcp, struct sockaddr *sap, struct thread *td)
496{
497 struct nbpcb *nbp = vcp->vc_tdata;
498 struct sockaddr_in sin;
499 struct sockaddr_nb *snb;
500 struct timespec ts1, ts2;
501 int error, slen;
502
503 NBDEBUG("\n");
504 if (nbp->nbp_tso != NULL)
505 return EISCONN;
506 if (nbp->nbp_laddr == NULL)
507 return EINVAL;
508 slen = sap->sa_len;
509 if (slen < NB_MINSALEN)
510 return EINVAL;
511 if (nbp->nbp_paddr) {
512 free(nbp->nbp_paddr, M_SONAME);
513 nbp->nbp_paddr = NULL;
514 }
515 snb = (struct sockaddr_nb*)sodupsockaddr(sap, M_WAITOK);
516 if (snb == NULL)
517 return ENOMEM;
518 nbp->nbp_paddr = snb;
519 sin = snb->snb_addrin;
520 getnanotime(&ts1);
521 error = nb_connect_in(nbp, &sin, td);
522 if (error)
523 return error;
524 getnanotime(&ts2);
525 timespecsub(&ts2, &ts1);
526 if (ts2.tv_sec == 0 && ts2.tv_sec == 0)
527 ts2.tv_sec = 1;
528 nbp->nbp_timo = ts2;
529 timespecadd(&nbp->nbp_timo, &ts2);
530 timespecadd(&nbp->nbp_timo, &ts2);
531 timespecadd(&nbp->nbp_timo, &ts2); /* * 4 */
532 error = nbssn_rq_request(nbp, td);
533 if (error)
534 smb_nbst_disconnect(vcp, td);
535 return error;
536}
537
538static int
539smb_nbst_disconnect(struct smb_vc *vcp, struct thread *td)
540{
541 struct nbpcb *nbp = vcp->vc_tdata;
542 struct socket *so;
543
544 if (nbp == NULL || nbp->nbp_tso == NULL)
545 return ENOTCONN;
546 if ((so = nbp->nbp_tso) != NULL) {
547 nbp->nbp_flags &= ~NBF_CONNECTED;
548 nbp->nbp_tso = (struct socket *)NULL;
549 soshutdown(so, 2);
550 soclose(so);
551 }
552 if (nbp->nbp_state != NBST_RETARGET) {
553 nbp->nbp_state = NBST_CLOSED;
554 }
555 return 0;
556}
557
558static int
559smb_nbst_send(struct smb_vc *vcp, struct mbuf *m0, struct thread *td)
560{
561 struct nbpcb *nbp = vcp->vc_tdata;
562 int error;
563
564 if (nbp->nbp_state != NBST_SESSION) {
565 error = ENOTCONN;
566 goto abort;
567 }
568 M_PREPEND(m0, 4, M_WAIT);
569 nb_sethdr(m0, NB_SSN_MESSAGE, m_fixhdr(m0) - 4);
570 error = nb_sosend(nbp->nbp_tso, m0, 0, td);
571 return error;
572abort:
573 if (m0)
574 m_freem(m0);
575 return error;
576}
577
578
579static int
580smb_nbst_recv(struct smb_vc *vcp, struct mbuf **mpp, struct thread *td)
581{
582 struct nbpcb *nbp = vcp->vc_tdata;
583 u_int8_t rpcode;
584 int error, rplen;
585
586 nbp->nbp_flags |= NBF_RECVLOCK;
587 error = nbssn_recv(nbp, mpp, &rplen, &rpcode, td);
588 nbp->nbp_flags &= ~NBF_RECVLOCK;
589 return error;
590}
591
592static void
593smb_nbst_timo(struct smb_vc *vcp)
594{
595 return;
596}
597
598static void
599smb_nbst_intr(struct smb_vc *vcp)
600{
601 struct nbpcb *nbp = vcp->vc_tdata;
602
603 if (nbp == NULL || nbp->nbp_tso == NULL)
604 return;
605 sorwakeup(nbp->nbp_tso);
606 sowwakeup(nbp->nbp_tso);
607}
608
609static int
610smb_nbst_getparam(struct smb_vc *vcp, int param, void *data)
611{
612 struct nbpcb *nbp = vcp->vc_tdata;
613
614 switch (param) {
615 case SMBTP_SNDSZ:
616 *(int*)data = nbp->nbp_sndbuf;
617 break;
618 case SMBTP_RCVSZ:
619 *(int*)data = nbp->nbp_rcvbuf;
620 break;
621 case SMBTP_TIMEOUT:
622 *(struct timespec*)data = nbp->nbp_timo;
623 break;
624 default:
625 return EINVAL;
626 }
627 return 0;
628}
629
630static int
631smb_nbst_setparam(struct smb_vc *vcp, int param, void *data)
632{
633 struct nbpcb *nbp = vcp->vc_tdata;
634
635 switch (param) {
636 case SMBTP_SELECTID:
637 nbp->nbp_selectid = data;
638 break;
639 default:
640 return EINVAL;
641 }
642 return 0;
643}
644
645/*
646 * Check for fatal errors
647 */
648static int
649smb_nbst_fatal(struct smb_vc *vcp, int error)
650{
651 switch (error) {
652 case ENOTCONN:
653 case ENETRESET:
654 case ECONNABORTED:
655 return 1;
656 }
657 return 0;
658}
659
660
661struct smb_tran_desc smb_tran_nbtcp_desc = {
662 SMBT_NBTCP,
663 smb_nbst_create, smb_nbst_done,
664 smb_nbst_bind, smb_nbst_connect, smb_nbst_disconnect,
665 smb_nbst_send, smb_nbst_recv,
666 smb_nbst_timo, smb_nbst_intr,
667 smb_nbst_getparam, smb_nbst_setparam,
668 smb_nbst_fatal
669};
670
|