1 /* 2 * Copyright (c) 2000-2001 Boris Popov 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by Boris Popov. 16 * 4. Neither the name of the author nor the names of any co-contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 * 32 * $FreeBSD: src/sys/netsmb/smb_trantcp.c,v 1.3.2.1 2001/05/22 08:32:34 bp Exp $ 33 * $DragonFly: src/sys/netproto/smb/smb_trantcp.c,v 1.4 2003/07/19 21:14:45 dillon Exp $ 34 */ 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/kernel.h> 38 #include <sys/malloc.h> 39 #include <sys/mbuf.h> 40 #include <sys/proc.h> 41 #include <sys/protosw.h> 42 #include <sys/socket.h> 43 #include <sys/socketvar.h> 44 #include <sys/poll.h> 45 #include <sys/uio.h> 46 #include <sys/sysctl.h> 47 48 #include <net/if.h> 49 #include <net/route.h> 50 51 #include <netinet/in.h> 52 #include <netinet/tcp.h> 53 54 #include <sys/mchain.h> 55 56 #include <netsmb/netbios.h> 57 58 #include <netsmb/smb.h> 59 #include <netsmb/smb_conn.h> 60 #include <netsmb/smb_tran.h> 61 #include <netsmb/smb_trantcp.h> 62 #include <netsmb/smb_subr.h> 63 64 #define M_NBDATA M_PCB 65 66 static int smb_tcpsndbuf = 10 * 1024; 67 static int smb_tcprcvbuf = 10 * 1024; 68 69 SYSCTL_DECL(_net_smb); 70 SYSCTL_INT(_net_smb, OID_AUTO, tcpsndbuf, CTLFLAG_RW, &smb_tcpsndbuf, 0, ""); 71 SYSCTL_INT(_net_smb, OID_AUTO, tcprcvbuf, CTLFLAG_RW, &smb_tcprcvbuf, 0, ""); 72 73 #define nb_sosend(so,m,flags,p) (so)->so_proto->pr_usrreqs->pru_sosend( \ 74 so, NULL, 0, m, 0, flags, td) 75 76 static int nbssn_recv(struct nbpcb *nbp, struct mbuf **mpp, int *lenp, 77 u_int8_t *rpcodep, struct thread *td); 78 static int smb_nbst_disconnect(struct smb_vc *vcp, struct thread *td); 79 80 static int 81 nb_setsockopt_int(struct socket *so, int level, int name, int val) 82 { 83 struct sockopt sopt; 84 85 bzero(&sopt, sizeof(sopt)); 86 sopt.sopt_level = level; 87 sopt.sopt_name = name; 88 sopt.sopt_val = &val; 89 sopt.sopt_valsize = sizeof(val); 90 return sosetopt(so, &sopt); 91 } 92 93 static __inline int 94 nb_poll(struct nbpcb *nbp, int events, struct thread *td) 95 { 96 return nbp->nbp_tso->so_proto->pr_usrreqs->pru_sopoll(nbp->nbp_tso, 97 events, NULL, td); 98 } 99 100 static int 101 nbssn_rselect(struct nbpcb *nbp, struct timeval *tv, int events, struct thread *td) 102 { 103 struct proc *p = td->td_proc; 104 struct timeval atv, rtv, ttv; 105 int s, timo, error; 106 107 if (tv) { 108 atv = *tv; 109 if (itimerfix(&atv)) { 110 error = EINVAL; 111 goto done; 112 } 113 getmicrouptime(&rtv); 114 timevaladd(&atv, &rtv); 115 } 116 timo = 0; 117 KKASSERT(p); 118 retry: 119 p->p_flag |= P_SELECT; 120 error = nb_poll(nbp, events, td); 121 if (error) { 122 error = 0; 123 goto done; 124 } 125 if (tv) { 126 getmicrouptime(&rtv); 127 if (timevalcmp(&rtv, &atv, >=)) 128 goto done; 129 ttv = atv; 130 timevalsub(&ttv, &rtv); 131 timo = tvtohz(&ttv); 132 } 133 s = splhigh(); 134 if ((p->p_flag & P_SELECT) == 0) { 135 splx(s); 136 goto retry; 137 } 138 p->p_flag &= ~P_SELECT; 139 error = tsleep((caddr_t)&selwait, 0, "nbsel", timo); 140 splx(s); 141 done: 142 p->p_flag &= ~P_SELECT; 143 if (error == ERESTART) 144 return 0; 145 return error; 146 } 147 148 static int 149 nb_intr(struct nbpcb *nbp, struct thread *td) 150 { 151 return 0; 152 } 153 154 static void 155 nb_upcall(struct socket *so, void *arg, int waitflag) 156 { 157 struct nbpcb *nbp = arg; 158 159 if (arg == NULL || nbp->nbp_selectid == NULL) 160 return; 161 wakeup(nbp->nbp_selectid); 162 } 163 164 static int 165 nb_sethdr(struct mbuf *m, u_int8_t type, u_int32_t len) 166 { 167 u_int32_t *p = mtod(m, u_int32_t *); 168 169 *p = htonl((len & 0x1FFFF) | (type << 24)); 170 return 0; 171 } 172 173 static int 174 nb_put_name(struct mbchain *mbp, struct sockaddr_nb *snb) 175 { 176 int error; 177 u_char seglen, *cp; 178 179 cp = snb->snb_name; 180 if (*cp == 0) 181 return EINVAL; 182 NBDEBUG("[%s]\n", cp); 183 for (;;) { 184 seglen = (*cp) + 1; 185 error = mb_put_mem(mbp, cp, seglen, MB_MSYSTEM); 186 if (error) 187 return error; 188 if (seglen == 1) 189 break; 190 cp += seglen; 191 } 192 return 0; 193 } 194 195 static int 196 nb_connect_in(struct nbpcb *nbp, struct sockaddr_in *to, struct thread *td) 197 { 198 struct socket *so; 199 int error, s; 200 201 error = socreate(AF_INET, &so, SOCK_STREAM, IPPROTO_TCP, td); 202 if (error) 203 return error; 204 nbp->nbp_tso = so; 205 so->so_upcallarg = (caddr_t)nbp; 206 so->so_upcall = nb_upcall; 207 so->so_rcv.sb_flags |= SB_UPCALL; 208 so->so_rcv.sb_timeo = (5 * hz); 209 so->so_snd.sb_timeo = (5 * hz); 210 error = soreserve(so, nbp->nbp_sndbuf, nbp->nbp_rcvbuf); 211 if (error) 212 goto bad; 213 nb_setsockopt_int(so, SOL_SOCKET, SO_KEEPALIVE, 1); 214 nb_setsockopt_int(so, IPPROTO_TCP, TCP_NODELAY, 1); 215 so->so_rcv.sb_flags &= ~SB_NOINTR; 216 so->so_snd.sb_flags &= ~SB_NOINTR; 217 error = soconnect(so, (struct sockaddr*)to, td); 218 if (error) 219 goto bad; 220 s = splnet(); 221 while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) { 222 tsleep(&so->so_timeo, 0, "nbcon", 2 * hz); 223 if ((so->so_state & SS_ISCONNECTING) && so->so_error == 0 && 224 (error = nb_intr(nbp, td)) != 0) { 225 so->so_state &= ~SS_ISCONNECTING; 226 splx(s); 227 goto bad; 228 } 229 } 230 if (so->so_error) { 231 error = so->so_error; 232 so->so_error = 0; 233 splx(s); 234 goto bad; 235 } 236 splx(s); 237 return 0; 238 bad: 239 smb_nbst_disconnect(nbp->nbp_vc, td); 240 return error; 241 } 242 243 static int 244 nbssn_rq_request(struct nbpcb *nbp, struct thread *td) 245 { 246 struct mbchain mb, *mbp = &mb; 247 struct mdchain md, *mdp = &md; 248 struct mbuf *m0; 249 struct timeval tv; 250 struct sockaddr_in sin; 251 u_short port; 252 u_int8_t rpcode; 253 int error, rplen; 254 255 error = mb_init(mbp); 256 if (error) 257 return error; 258 mb_put_uint32le(mbp, 0); 259 nb_put_name(mbp, nbp->nbp_paddr); 260 nb_put_name(mbp, nbp->nbp_laddr); 261 nb_sethdr(mbp->mb_top, NB_SSN_REQUEST, mb_fixhdr(mbp) - 4); 262 error = nb_sosend(nbp->nbp_tso, mbp->mb_top, 0, td); 263 if (!error) { 264 nbp->nbp_state = NBST_RQSENT; 265 } 266 mb_detach(mbp); 267 mb_done(mbp); 268 if (error) 269 return error; 270 TIMESPEC_TO_TIMEVAL(&tv, &nbp->nbp_timo); 271 error = nbssn_rselect(nbp, &tv, POLLIN, td); 272 if (error == EWOULDBLOCK) { /* Timeout */ 273 NBDEBUG("initial request timeout\n"); 274 return ETIMEDOUT; 275 } 276 if (error) /* restart or interrupt */ 277 return error; 278 error = nbssn_recv(nbp, &m0, &rplen, &rpcode, td); 279 if (error) { 280 NBDEBUG("recv() error %d\n", error); 281 return error; 282 } 283 /* 284 * Process NETBIOS reply 285 */ 286 if (m0) 287 md_initm(mdp, m0); 288 error = 0; 289 do { 290 if (rpcode == NB_SSN_POSRESP) { 291 nbp->nbp_state = NBST_SESSION; 292 nbp->nbp_flags |= NBF_CONNECTED; 293 break; 294 } 295 if (rpcode != NB_SSN_RTGRESP) { 296 error = ECONNABORTED; 297 break; 298 } 299 if (rplen != 6) { 300 error = ECONNABORTED; 301 break; 302 } 303 md_get_mem(mdp, (caddr_t)&sin.sin_addr, 4, MB_MSYSTEM); 304 md_get_uint16(mdp, &port); 305 sin.sin_port = port; 306 nbp->nbp_state = NBST_RETARGET; 307 smb_nbst_disconnect(nbp->nbp_vc, td); 308 error = nb_connect_in(nbp, &sin, td); 309 if (!error) 310 error = nbssn_rq_request(nbp, td); 311 if (error) { 312 smb_nbst_disconnect(nbp->nbp_vc, td); 313 break; 314 } 315 } while(0); 316 if (m0) 317 md_done(mdp); 318 return error; 319 } 320 321 static int 322 nbssn_recvhdr(struct nbpcb *nbp, int *lenp, 323 u_int8_t *rpcodep, int flags, struct thread *td) 324 { 325 struct socket *so = nbp->nbp_tso; 326 struct uio auio; 327 struct iovec aio; 328 u_int32_t len; 329 int error; 330 331 aio.iov_base = (caddr_t)&len; 332 aio.iov_len = sizeof(len); 333 auio.uio_iov = &aio; 334 auio.uio_iovcnt = 1; 335 auio.uio_segflg = UIO_SYSSPACE; 336 auio.uio_rw = UIO_READ; 337 auio.uio_offset = 0; 338 auio.uio_resid = sizeof(len); 339 auio.uio_td = td; 340 error = so->so_proto->pr_usrreqs->pru_soreceive 341 (so, (struct sockaddr **)NULL, &auio, 342 (struct mbuf **)NULL, (struct mbuf **)NULL, &flags); 343 if (error) 344 return error; 345 if (auio.uio_resid > 0) { 346 SMBSDEBUG("short reply\n"); 347 return EPIPE; 348 } 349 len = ntohl(len); 350 *rpcodep = (len >> 24) & 0xFF; 351 len &= 0x1ffff; 352 if (len > SMB_MAXPKTLEN) { 353 SMBERROR("packet too long (%d)\n", len); 354 return EFBIG; 355 } 356 *lenp = len; 357 return 0; 358 } 359 360 static int 361 nbssn_recv(struct nbpcb *nbp, struct mbuf **mpp, int *lenp, 362 u_int8_t *rpcodep, struct thread *td) 363 { 364 struct socket *so = nbp->nbp_tso; 365 struct uio auio; 366 struct mbuf *m; 367 u_int8_t rpcode; 368 int len; 369 int error, rcvflg; 370 371 if (so == NULL) 372 return ENOTCONN; 373 374 if (mpp) 375 *mpp = NULL; 376 for(;;) { 377 m = NULL; 378 error = nbssn_recvhdr(nbp, &len, &rpcode, MSG_DONTWAIT, td); 379 if (so->so_state & 380 (SS_ISDISCONNECTING | SS_ISDISCONNECTED | SS_CANTRCVMORE)) { 381 nbp->nbp_state = NBST_CLOSED; 382 NBDEBUG("session closed by peer\n"); 383 return ECONNRESET; 384 } 385 if (error) 386 return error; 387 if (len == 0 && nbp->nbp_state != NBST_SESSION) 388 break; 389 if (rpcode == NB_SSN_KEEPALIVE) 390 continue; 391 bzero(&auio, sizeof(auio)); 392 auio.uio_resid = len; 393 auio.uio_td = td; 394 do { 395 rcvflg = MSG_WAITALL; 396 error = so->so_proto->pr_usrreqs->pru_soreceive 397 (so, (struct sockaddr **)NULL, 398 &auio, &m, (struct mbuf **)NULL, &rcvflg); 399 } while (error == EWOULDBLOCK || error == EINTR || 400 error == ERESTART); 401 if (error) 402 break; 403 if (auio.uio_resid > 0) { 404 SMBERROR("packet is shorter than expected\n"); 405 error = EPIPE; 406 break; 407 } 408 if (nbp->nbp_state == NBST_SESSION && 409 rpcode == NB_SSN_MESSAGE) 410 break; 411 NBDEBUG("non-session packet %x\n", rpcode); 412 if (m) 413 m_freem(m); 414 } 415 if (error) { 416 if (m) 417 m_freem(m); 418 return error; 419 } 420 if (mpp) 421 *mpp = m; 422 else 423 m_freem(m); 424 *lenp = len; 425 *rpcodep = rpcode; 426 return 0; 427 } 428 429 /* 430 * SMB transport interface 431 */ 432 static int 433 smb_nbst_create(struct smb_vc *vcp, struct thread *td) 434 { 435 struct nbpcb *nbp; 436 437 MALLOC(nbp, struct nbpcb *, sizeof *nbp, M_NBDATA, M_WAITOK); 438 bzero(nbp, sizeof *nbp); 439 nbp->nbp_timo.tv_sec = 15; /* XXX: sysctl ? */ 440 nbp->nbp_state = NBST_CLOSED; 441 nbp->nbp_vc = vcp; 442 nbp->nbp_sndbuf = smb_tcpsndbuf; 443 nbp->nbp_rcvbuf = smb_tcprcvbuf; 444 vcp->vc_tdata = nbp; 445 return 0; 446 } 447 448 static int 449 smb_nbst_done(struct smb_vc *vcp, struct thread *td) 450 { 451 struct nbpcb *nbp = vcp->vc_tdata; 452 453 if (nbp == NULL) 454 return ENOTCONN; 455 smb_nbst_disconnect(vcp, td); 456 if (nbp->nbp_laddr) 457 free(nbp->nbp_laddr, M_SONAME); 458 if (nbp->nbp_paddr) 459 free(nbp->nbp_paddr, M_SONAME); 460 free(nbp, M_NBDATA); 461 return 0; 462 } 463 464 static int 465 smb_nbst_bind(struct smb_vc *vcp, struct sockaddr *sap, struct thread *td) 466 { 467 struct nbpcb *nbp = vcp->vc_tdata; 468 struct sockaddr_nb *snb; 469 int error, slen; 470 471 NBDEBUG("\n"); 472 error = EINVAL; 473 do { 474 if (nbp->nbp_flags & NBF_LOCADDR) 475 break; 476 /* 477 * It is possible to create NETBIOS name in the kernel, 478 * but nothing prevents us to do it in the user space. 479 */ 480 if (sap == NULL) 481 break; 482 slen = sap->sa_len; 483 if (slen < NB_MINSALEN) 484 break; 485 snb = (struct sockaddr_nb*)dup_sockaddr(sap, 1); 486 if (snb == NULL) { 487 error = ENOMEM; 488 break; 489 } 490 nbp->nbp_laddr = snb; 491 nbp->nbp_flags |= NBF_LOCADDR; 492 error = 0; 493 } while(0); 494 return error; 495 } 496 497 static int 498 smb_nbst_connect(struct smb_vc *vcp, struct sockaddr *sap, struct thread *td) 499 { 500 struct nbpcb *nbp = vcp->vc_tdata; 501 struct sockaddr_in sin; 502 struct sockaddr_nb *snb; 503 struct timespec ts1, ts2; 504 int error, slen; 505 506 NBDEBUG("\n"); 507 if (nbp->nbp_tso != NULL) 508 return EISCONN; 509 if (nbp->nbp_laddr == NULL) 510 return EINVAL; 511 slen = sap->sa_len; 512 if (slen < NB_MINSALEN) 513 return EINVAL; 514 if (nbp->nbp_paddr) { 515 free(nbp->nbp_paddr, M_SONAME); 516 nbp->nbp_paddr = NULL; 517 } 518 snb = (struct sockaddr_nb*)dup_sockaddr(sap, 1); 519 if (snb == NULL) 520 return ENOMEM; 521 nbp->nbp_paddr = snb; 522 sin = snb->snb_addrin; 523 getnanotime(&ts1); 524 error = nb_connect_in(nbp, &sin, td); 525 if (error) 526 return error; 527 getnanotime(&ts2); 528 timespecsub(&ts2, &ts1); 529 if (ts2.tv_sec == 0 && ts2.tv_sec == 0) 530 ts2.tv_sec = 1; 531 nbp->nbp_timo = ts2; 532 timespecadd(&nbp->nbp_timo, &ts2); 533 timespecadd(&nbp->nbp_timo, &ts2); 534 timespecadd(&nbp->nbp_timo, &ts2); /* * 4 */ 535 error = nbssn_rq_request(nbp, td); 536 if (error) 537 smb_nbst_disconnect(vcp, td); 538 return error; 539 } 540 541 static int 542 smb_nbst_disconnect(struct smb_vc *vcp, struct thread *td) 543 { 544 struct nbpcb *nbp = vcp->vc_tdata; 545 struct socket *so; 546 547 if (nbp == NULL || nbp->nbp_tso == NULL) 548 return ENOTCONN; 549 if ((so = nbp->nbp_tso) != NULL) { 550 nbp->nbp_flags &= ~NBF_CONNECTED; 551 nbp->nbp_tso = (struct socket *)NULL; 552 soshutdown(so, 2); 553 soclose(so); 554 } 555 if (nbp->nbp_state != NBST_RETARGET) { 556 nbp->nbp_state = NBST_CLOSED; 557 } 558 return 0; 559 } 560 561 static int 562 smb_nbst_send(struct smb_vc *vcp, struct mbuf *m0, struct thread *td) 563 { 564 struct nbpcb *nbp = vcp->vc_tdata; 565 int error; 566 567 if (nbp->nbp_state != NBST_SESSION) { 568 error = ENOTCONN; 569 goto abort; 570 } 571 M_PREPEND(m0, 4, M_WAITOK); 572 if (m0 == NULL) 573 return ENOBUFS; 574 nb_sethdr(m0, NB_SSN_MESSAGE, m_fixhdr(m0) - 4); 575 error = nb_sosend(nbp->nbp_tso, m0, 0, td); 576 return error; 577 abort: 578 if (m0) 579 m_freem(m0); 580 return error; 581 } 582 583 584 static int 585 smb_nbst_recv(struct smb_vc *vcp, struct mbuf **mpp, struct thread *td) 586 { 587 struct nbpcb *nbp = vcp->vc_tdata; 588 u_int8_t rpcode; 589 int error, rplen; 590 591 nbp->nbp_flags |= NBF_RECVLOCK; 592 error = nbssn_recv(nbp, mpp, &rplen, &rpcode, td); 593 nbp->nbp_flags &= ~NBF_RECVLOCK; 594 return error; 595 } 596 597 static void 598 smb_nbst_timo(struct smb_vc *vcp) 599 { 600 return; 601 } 602 603 static void 604 smb_nbst_intr(struct smb_vc *vcp) 605 { 606 struct nbpcb *nbp = vcp->vc_tdata; 607 608 if (nbp == NULL || nbp->nbp_tso == NULL) 609 return; 610 sorwakeup(nbp->nbp_tso); 611 sowwakeup(nbp->nbp_tso); 612 } 613 614 static int 615 smb_nbst_getparam(struct smb_vc *vcp, int param, void *data) 616 { 617 struct nbpcb *nbp = vcp->vc_tdata; 618 619 switch (param) { 620 case SMBTP_SNDSZ: 621 *(int*)data = nbp->nbp_sndbuf; 622 break; 623 case SMBTP_RCVSZ: 624 *(int*)data = nbp->nbp_rcvbuf; 625 break; 626 case SMBTP_TIMEOUT: 627 *(struct timespec*)data = nbp->nbp_timo; 628 break; 629 default: 630 return EINVAL; 631 } 632 return 0; 633 } 634 635 static int 636 smb_nbst_setparam(struct smb_vc *vcp, int param, void *data) 637 { 638 struct nbpcb *nbp = vcp->vc_tdata; 639 640 switch (param) { 641 case SMBTP_SELECTID: 642 nbp->nbp_selectid = data; 643 break; 644 default: 645 return EINVAL; 646 } 647 return 0; 648 } 649 650 /* 651 * Check for fatal errors 652 */ 653 static int 654 smb_nbst_fatal(struct smb_vc *vcp, int error) 655 { 656 switch (error) { 657 case ENOTCONN: 658 case ENETRESET: 659 case ECONNABORTED: 660 return 1; 661 } 662 return 0; 663 } 664 665 666 struct smb_tran_desc smb_tran_nbtcp_desc = { 667 SMBT_NBTCP, 668 smb_nbst_create, smb_nbst_done, 669 smb_nbst_bind, smb_nbst_connect, smb_nbst_disconnect, 670 smb_nbst_send, smb_nbst_recv, 671 smb_nbst_timo, smb_nbst_intr, 672 smb_nbst_getparam, smb_nbst_setparam, 673 smb_nbst_fatal 674 }; 675 676