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.12 2005/06/10 22:44:02 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/resourcevar.h> 43 #include <sys/socket.h> 44 #include <sys/socketvar.h> 45 #include <sys/socketops.h> 46 #include <sys/poll.h> 47 #include <sys/uio.h> 48 #include <sys/sysctl.h> 49 #include <sys/thread2.h> 50 51 #include <net/if.h> 52 #include <net/route.h> 53 54 #include <netinet/in.h> 55 #include <netinet/tcp.h> 56 57 #include <sys/mchain.h> 58 59 #include "netbios.h" 60 61 #include "smb.h" 62 #include "smb_conn.h" 63 #include "smb_tran.h" 64 #include "smb_trantcp.h" 65 #include "smb_subr.h" 66 67 #define M_NBDATA M_PCB 68 69 static int smb_tcpsndbuf = 10 * 1024; 70 static int smb_tcprcvbuf = 10 * 1024; 71 72 SYSCTL_DECL(_net_smb); 73 SYSCTL_INT(_net_smb, OID_AUTO, tcpsndbuf, CTLFLAG_RW, &smb_tcpsndbuf, 0, ""); 74 SYSCTL_INT(_net_smb, OID_AUTO, tcprcvbuf, CTLFLAG_RW, &smb_tcprcvbuf, 0, ""); 75 76 #define nb_sosend(so,m,flags,p) \ 77 so_pru_sosend(so, NULL, NULL, m, NULL, flags, td) 78 79 static int nbssn_recv(struct nbpcb *nbp, struct mbuf **mpp, int *lenp, 80 u_int8_t *rpcodep, struct thread *td); 81 static int smb_nbst_disconnect(struct smb_vc *vcp, struct thread *td); 82 83 static int 84 nb_setsockopt_int(struct socket *so, int level, int name, int val) 85 { 86 struct sockopt sopt; 87 88 bzero(&sopt, sizeof(sopt)); 89 sopt.sopt_level = level; 90 sopt.sopt_name = name; 91 sopt.sopt_val = &val; 92 sopt.sopt_valsize = sizeof(val); 93 return sosetopt(so, &sopt); 94 } 95 96 static __inline int 97 nb_poll(struct nbpcb *nbp, int events, struct thread *td) 98 { 99 return so_pru_sopoll(nbp->nbp_tso, events, NULL, td); 100 } 101 102 static int 103 nbssn_rselect(struct nbpcb *nbp, struct timeval *tv, int events, struct thread *td) 104 { 105 struct proc *p = td->td_proc; 106 struct timeval atv, rtv, ttv; 107 int timo, error; 108 109 if (tv) { 110 atv = *tv; 111 if (itimerfix(&atv)) { 112 error = EINVAL; 113 goto done; 114 } 115 getmicrouptime(&rtv); 116 timevaladd(&atv, &rtv); 117 } 118 timo = 0; 119 KKASSERT(p); 120 retry: 121 p->p_flag |= P_SELECT; 122 error = nb_poll(nbp, events, td); 123 if (error) { 124 error = 0; 125 goto done; 126 } 127 if (tv) { 128 getmicrouptime(&rtv); 129 if (timevalcmp(&rtv, &atv, >=)) 130 goto done; 131 ttv = atv; 132 timevalsub(&ttv, &rtv); 133 timo = tvtohz_high(&ttv); 134 } 135 crit_enter(); 136 if ((p->p_flag & P_SELECT) == 0) { 137 crit_exit(); 138 goto retry; 139 } 140 p->p_flag &= ~P_SELECT; 141 error = tsleep((caddr_t)&selwait, 0, "nbsel", timo); 142 crit_exit(); 143 done: 144 p->p_flag &= ~P_SELECT; 145 if (error == ERESTART) 146 return 0; 147 return error; 148 } 149 150 static int 151 nb_intr(struct nbpcb *nbp, struct thread *td) 152 { 153 return 0; 154 } 155 156 static void 157 nb_upcall(struct socket *so, void *arg, int waitflag) 158 { 159 struct nbpcb *nbp = arg; 160 161 if (arg == NULL || nbp->nbp_selectid == NULL) 162 return; 163 wakeup(nbp->nbp_selectid); 164 } 165 166 static int 167 nb_sethdr(struct mbuf *m, u_int8_t type, u_int32_t len) 168 { 169 u_int32_t *p = mtod(m, u_int32_t *); 170 171 *p = htonl((len & 0x1FFFF) | (type << 24)); 172 return 0; 173 } 174 175 static int 176 nb_put_name(struct mbchain *mbp, struct sockaddr_nb *snb) 177 { 178 int error; 179 u_char seglen, *cp; 180 181 cp = snb->snb_name; 182 if (*cp == 0) 183 return EINVAL; 184 NBDEBUG("[%s]\n", cp); 185 for (;;) { 186 seglen = (*cp) + 1; 187 error = mb_put_mem(mbp, cp, seglen, MB_MSYSTEM); 188 if (error) 189 return error; 190 if (seglen == 1) 191 break; 192 cp += seglen; 193 } 194 return 0; 195 } 196 197 static int 198 nb_connect_in(struct nbpcb *nbp, struct sockaddr_in *to, struct thread *td) 199 { 200 struct socket *so; 201 int error; 202 203 error = socreate(AF_INET, &so, SOCK_STREAM, IPPROTO_TCP, td); 204 if (error) 205 return error; 206 nbp->nbp_tso = so; 207 so->so_upcallarg = (caddr_t)nbp; 208 so->so_upcall = nb_upcall; 209 so->so_rcv.sb_flags |= SB_UPCALL; 210 so->so_rcv.sb_timeo = (5 * hz); 211 so->so_snd.sb_timeo = (5 * hz); 212 error = soreserve(so, nbp->nbp_sndbuf, nbp->nbp_rcvbuf, 213 &td->td_proc->p_rlimit[RLIMIT_SBSIZE]); 214 if (error) 215 goto bad; 216 nb_setsockopt_int(so, SOL_SOCKET, SO_KEEPALIVE, 1); 217 nb_setsockopt_int(so, IPPROTO_TCP, TCP_NODELAY, 1); 218 so->so_rcv.sb_flags &= ~SB_NOINTR; 219 so->so_snd.sb_flags &= ~SB_NOINTR; 220 error = soconnect(so, (struct sockaddr*)to, td); 221 if (error) 222 goto bad; 223 crit_enter(); 224 while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) { 225 tsleep(&so->so_timeo, 0, "nbcon", 2 * hz); 226 if ((so->so_state & SS_ISCONNECTING) && so->so_error == 0 && 227 (error = nb_intr(nbp, td)) != 0) { 228 so->so_state &= ~SS_ISCONNECTING; 229 crit_exit(); 230 goto bad; 231 } 232 } 233 if (so->so_error) { 234 error = so->so_error; 235 so->so_error = 0; 236 crit_exit(); 237 goto bad; 238 } 239 crit_exit(); 240 return 0; 241 bad: 242 smb_nbst_disconnect(nbp->nbp_vc, td); 243 return error; 244 } 245 246 static int 247 nbssn_rq_request(struct nbpcb *nbp, struct thread *td) 248 { 249 struct mbchain mb, *mbp = &mb; 250 struct mdchain md, *mdp = &md; 251 struct mbuf *m0; 252 struct timeval tv; 253 struct sockaddr_in sin; 254 u_short port; 255 u_int8_t rpcode; 256 int error, rplen; 257 258 error = mb_init(mbp); 259 if (error) 260 return error; 261 mb_put_uint32le(mbp, 0); 262 nb_put_name(mbp, nbp->nbp_paddr); 263 nb_put_name(mbp, nbp->nbp_laddr); 264 nb_sethdr(mbp->mb_top, NB_SSN_REQUEST, mb_fixhdr(mbp) - 4); 265 error = nb_sosend(nbp->nbp_tso, mbp->mb_top, 0, td); 266 if (!error) { 267 nbp->nbp_state = NBST_RQSENT; 268 } 269 mb_detach(mbp); 270 mb_done(mbp); 271 if (error) 272 return error; 273 TIMESPEC_TO_TIMEVAL(&tv, &nbp->nbp_timo); 274 error = nbssn_rselect(nbp, &tv, POLLIN, td); 275 if (error == EWOULDBLOCK) { /* Timeout */ 276 NBDEBUG("initial request timeout\n"); 277 return ETIMEDOUT; 278 } 279 if (error) /* restart or interrupt */ 280 return error; 281 error = nbssn_recv(nbp, &m0, &rplen, &rpcode, td); 282 if (error) { 283 NBDEBUG("recv() error %d\n", error); 284 return error; 285 } 286 /* 287 * Process NETBIOS reply 288 */ 289 if (m0) 290 md_initm(mdp, m0); 291 error = 0; 292 do { 293 if (rpcode == NB_SSN_POSRESP) { 294 nbp->nbp_state = NBST_SESSION; 295 nbp->nbp_flags |= NBF_CONNECTED; 296 break; 297 } 298 if (rpcode != NB_SSN_RTGRESP) { 299 error = ECONNABORTED; 300 break; 301 } 302 if (rplen != 6) { 303 error = ECONNABORTED; 304 break; 305 } 306 md_get_mem(mdp, (caddr_t)&sin.sin_addr, 4, MB_MSYSTEM); 307 md_get_uint16(mdp, &port); 308 sin.sin_port = port; 309 nbp->nbp_state = NBST_RETARGET; 310 smb_nbst_disconnect(nbp->nbp_vc, td); 311 error = nb_connect_in(nbp, &sin, td); 312 if (!error) 313 error = nbssn_rq_request(nbp, td); 314 if (error) { 315 smb_nbst_disconnect(nbp->nbp_vc, td); 316 break; 317 } 318 } while(0); 319 if (m0) 320 md_done(mdp); 321 return error; 322 } 323 324 static int 325 nbssn_recvhdr(struct nbpcb *nbp, int *lenp, 326 u_int8_t *rpcodep, int flags, struct thread *td) 327 { 328 struct socket *so = nbp->nbp_tso; 329 struct uio auio; 330 struct iovec aio; 331 u_int32_t len; 332 int error; 333 334 aio.iov_base = (caddr_t)&len; 335 aio.iov_len = sizeof(len); 336 auio.uio_iov = &aio; 337 auio.uio_iovcnt = 1; 338 auio.uio_segflg = UIO_SYSSPACE; 339 auio.uio_rw = UIO_READ; 340 auio.uio_offset = 0; 341 auio.uio_resid = sizeof(len); 342 auio.uio_td = td; 343 error = so_pru_soreceive(so, NULL, &auio, NULL, NULL, &flags); 344 if (error) 345 return error; 346 if (auio.uio_resid > 0) { 347 SMBSDEBUG("short reply\n"); 348 return EPIPE; 349 } 350 len = ntohl(len); 351 *rpcodep = (len >> 24) & 0xFF; 352 len &= 0x1ffff; 353 if (len > SMB_MAXPKTLEN) { 354 SMBERROR("packet too long (%d)\n", len); 355 return EFBIG; 356 } 357 *lenp = len; 358 return 0; 359 } 360 361 static int 362 nbssn_recv(struct nbpcb *nbp, struct mbuf **mpp, int *lenp, 363 u_int8_t *rpcodep, struct thread *td) 364 { 365 struct socket *so = nbp->nbp_tso; 366 struct uio auio; 367 struct mbuf *m; 368 u_int8_t rpcode; 369 int len; 370 int error, rcvflg; 371 372 if (so == NULL) 373 return ENOTCONN; 374 375 if (mpp) 376 *mpp = NULL; 377 for(;;) { 378 m = NULL; 379 error = nbssn_recvhdr(nbp, &len, &rpcode, MSG_DONTWAIT, td); 380 if (so->so_state & 381 (SS_ISDISCONNECTING | SS_ISDISCONNECTED | SS_CANTRCVMORE)) { 382 nbp->nbp_state = NBST_CLOSED; 383 NBDEBUG("session closed by peer\n"); 384 return ECONNRESET; 385 } 386 if (error) 387 return error; 388 if (len == 0 && nbp->nbp_state != NBST_SESSION) 389 break; 390 if (rpcode == NB_SSN_KEEPALIVE) 391 continue; 392 bzero(&auio, sizeof(auio)); 393 auio.uio_resid = len; 394 auio.uio_td = td; 395 do { 396 rcvflg = MSG_WAITALL; 397 error = so_pru_soreceive(so, NULL, &auio, &m, NULL, 398 &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); 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); 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, MB_TRYWAIT); 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