1 /* 2 * Copyright (c) 2004 Jeffrey M. Hsu. All rights reserved. 3 * Copyright (c) 2004 The DragonFly Project. All rights reserved. 4 * 5 * This code is derived from software contributed to The DragonFly Project 6 * by Jeffrey M. Hsu. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. Neither the name of The DragonFly Project nor the names of its 17 * contributors may be used to endorse or promote products derived 18 * from this software without specific, prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 24 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 27 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 30 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 */ 33 34 /* 35 * Copyright (c) 1982, 1986, 1988, 1990, 1993 36 * The Regents of the University of California. All rights reserved. 37 * 38 * Redistribution and use in source and binary forms, with or without 39 * modification, are permitted provided that the following conditions 40 * are met: 41 * 1. Redistributions of source code must retain the above copyright 42 * notice, this list of conditions and the following disclaimer. 43 * 2. Redistributions in binary form must reproduce the above copyright 44 * notice, this list of conditions and the following disclaimer in the 45 * documentation and/or other materials provided with the distribution. 46 * 3. All advertising materials mentioning features or use of this software 47 * must display the following acknowledgement: 48 * This product includes software developed by the University of 49 * California, Berkeley and its contributors. 50 * 4. Neither the name of the University nor the names of its contributors 51 * may be used to endorse or promote products derived from this software 52 * without specific prior written permission. 53 * 54 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 55 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 56 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 57 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 58 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 59 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 60 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 61 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 62 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 63 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 64 * SUCH DAMAGE. 65 * 66 * @(#)uipc_socket.c 8.3 (Berkeley) 4/15/94 67 * $FreeBSD: src/sys/kern/uipc_socket.c,v 1.68.2.24 2003/11/11 17:18:18 silby Exp $ 68 */ 69 70 #include "opt_inet.h" 71 #include "opt_sctp.h" 72 73 #include <sys/param.h> 74 #include <sys/systm.h> 75 #include <sys/fcntl.h> 76 #include <sys/malloc.h> 77 #include <sys/mbuf.h> 78 #include <sys/domain.h> 79 #include <sys/file.h> /* for struct knote */ 80 #include <sys/kernel.h> 81 #include <sys/event.h> 82 #include <sys/proc.h> 83 #include <sys/protosw.h> 84 #include <sys/socket.h> 85 #include <sys/socketvar.h> 86 #include <sys/socketops.h> 87 #include <sys/resourcevar.h> 88 #include <sys/signalvar.h> 89 #include <sys/sysctl.h> 90 #include <sys/uio.h> 91 #include <sys/jail.h> 92 #include <vm/vm_zone.h> 93 #include <vm/pmap.h> 94 #include <net/netmsg2.h> 95 96 #include <sys/thread2.h> 97 #include <sys/socketvar2.h> 98 99 #include <machine/limits.h> 100 101 extern int tcp_sosend_agglim; 102 extern int tcp_sosend_async; 103 extern int udp_sosend_async; 104 105 #ifdef INET 106 static int do_setopt_accept_filter(struct socket *so, struct sockopt *sopt); 107 #endif /* INET */ 108 109 static void filt_sordetach(struct knote *kn); 110 static int filt_soread(struct knote *kn, long hint); 111 static void filt_sowdetach(struct knote *kn); 112 static int filt_sowrite(struct knote *kn, long hint); 113 static int filt_solisten(struct knote *kn, long hint); 114 115 static void sodiscard(struct socket *so); 116 static int soclose_sync(struct socket *so, int fflag); 117 static void soclose_fast(struct socket *so); 118 119 static struct filterops solisten_filtops = 120 { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, filt_sordetach, filt_solisten }; 121 static struct filterops soread_filtops = 122 { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, filt_sordetach, filt_soread }; 123 static struct filterops sowrite_filtops = 124 { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, filt_sowdetach, filt_sowrite }; 125 static struct filterops soexcept_filtops = 126 { FILTEROP_ISFD|FILTEROP_MPSAFE, NULL, filt_sordetach, filt_soread }; 127 128 MALLOC_DEFINE(M_SOCKET, "socket", "socket struct"); 129 MALLOC_DEFINE(M_SONAME, "soname", "socket name"); 130 MALLOC_DEFINE(M_PCB, "pcb", "protocol control block"); 131 132 133 static int somaxconn = SOMAXCONN; 134 SYSCTL_INT(_kern_ipc, KIPC_SOMAXCONN, somaxconn, CTLFLAG_RW, 135 &somaxconn, 0, "Maximum pending socket connection queue size"); 136 137 static int use_soclose_fast = 1; 138 SYSCTL_INT(_kern_ipc, OID_AUTO, soclose_fast, CTLFLAG_RW, 139 &use_soclose_fast, 0, "Fast socket close"); 140 141 int use_soaccept_pred_fast = 1; 142 SYSCTL_INT(_kern_ipc, OID_AUTO, soaccept_pred_fast, CTLFLAG_RW, 143 &use_soaccept_pred_fast, 0, "Fast socket accept predication"); 144 145 int use_sendfile_async = 1; 146 SYSCTL_INT(_kern_ipc, OID_AUTO, sendfile_async, CTLFLAG_RW, 147 &use_sendfile_async, 0, "sendfile uses asynchronized pru_send"); 148 149 /* 150 * Socket operation routines. 151 * These routines are called by the routines in 152 * sys_socket.c or from a system process, and 153 * implement the semantics of socket operations by 154 * switching out to the protocol specific routines. 155 */ 156 157 /* 158 * Get a socket structure, and initialize it. 159 * Note that it would probably be better to allocate socket 160 * and PCB at the same time, but I'm not convinced that all 161 * the protocols can be easily modified to do this. 162 */ 163 struct socket * 164 soalloc(int waitok) 165 { 166 struct socket *so; 167 unsigned waitmask; 168 169 waitmask = waitok ? M_WAITOK : M_NOWAIT; 170 so = kmalloc(sizeof(struct socket), M_SOCKET, M_ZERO|waitmask); 171 if (so) { 172 /* XXX race condition for reentrant kernel */ 173 TAILQ_INIT(&so->so_aiojobq); 174 TAILQ_INIT(&so->so_rcv.ssb_kq.ki_mlist); 175 TAILQ_INIT(&so->so_snd.ssb_kq.ki_mlist); 176 lwkt_token_init(&so->so_rcv.ssb_token, "rcvtok"); 177 lwkt_token_init(&so->so_snd.ssb_token, "sndtok"); 178 so->so_state = SS_NOFDREF; 179 so->so_refs = 1; 180 } 181 return so; 182 } 183 184 int 185 socreate(int dom, struct socket **aso, int type, 186 int proto, struct thread *td) 187 { 188 struct proc *p = td->td_proc; 189 struct protosw *prp; 190 struct socket *so; 191 struct pru_attach_info ai; 192 int error; 193 194 if (proto) 195 prp = pffindproto(dom, proto, type); 196 else 197 prp = pffindtype(dom, type); 198 199 if (prp == NULL || prp->pr_usrreqs->pru_attach == 0) 200 return (EPROTONOSUPPORT); 201 202 if (p->p_ucred->cr_prison && jail_socket_unixiproute_only && 203 prp->pr_domain->dom_family != PF_LOCAL && 204 prp->pr_domain->dom_family != PF_INET && 205 prp->pr_domain->dom_family != PF_INET6 && 206 prp->pr_domain->dom_family != PF_ROUTE) { 207 return (EPROTONOSUPPORT); 208 } 209 210 if (prp->pr_type != type) 211 return (EPROTOTYPE); 212 so = soalloc(p != NULL); 213 if (so == NULL) 214 return (ENOBUFS); 215 216 /* 217 * Callers of socreate() presumably will connect up a descriptor 218 * and call soclose() if they cannot. This represents our so_refs 219 * (which should be 1) from soalloc(). 220 */ 221 soclrstate(so, SS_NOFDREF); 222 223 /* 224 * Set a default port for protocol processing. No action will occur 225 * on the socket on this port until an inpcb is attached to it and 226 * is able to match incoming packets, or until the socket becomes 227 * available to userland. 228 * 229 * We normally default the socket to the protocol thread on cpu 0. 230 * If PR_SYNC_PORT is set (unix domain sockets) there is no protocol 231 * thread and all pr_*()/pru_*() calls are executed synchronously. 232 */ 233 if (prp->pr_flags & PR_SYNC_PORT) 234 so->so_port = &netisr_sync_port; 235 else 236 so->so_port = cpu_portfn(0); 237 238 TAILQ_INIT(&so->so_incomp); 239 TAILQ_INIT(&so->so_comp); 240 so->so_type = type; 241 so->so_cred = crhold(p->p_ucred); 242 so->so_proto = prp; 243 ai.sb_rlimit = &p->p_rlimit[RLIMIT_SBSIZE]; 244 ai.p_ucred = p->p_ucred; 245 ai.fd_rdir = p->p_fd->fd_rdir; 246 247 /* 248 * Auto-sizing of socket buffers is managed by the protocols and 249 * the appropriate flags must be set in the pru_attach function. 250 */ 251 error = so_pru_attach(so, proto, &ai); 252 if (error) { 253 sosetstate(so, SS_NOFDREF); 254 sofree(so); /* from soalloc */ 255 return error; 256 } 257 258 /* 259 * NOTE: Returns referenced socket. 260 */ 261 *aso = so; 262 return (0); 263 } 264 265 int 266 sobind(struct socket *so, struct sockaddr *nam, struct thread *td) 267 { 268 int error; 269 270 error = so_pru_bind(so, nam, td); 271 return (error); 272 } 273 274 static void 275 sodealloc(struct socket *so) 276 { 277 if (so->so_rcv.ssb_hiwat) 278 (void)chgsbsize(so->so_cred->cr_uidinfo, 279 &so->so_rcv.ssb_hiwat, 0, RLIM_INFINITY); 280 if (so->so_snd.ssb_hiwat) 281 (void)chgsbsize(so->so_cred->cr_uidinfo, 282 &so->so_snd.ssb_hiwat, 0, RLIM_INFINITY); 283 #ifdef INET 284 /* remove accept filter if present */ 285 if (so->so_accf != NULL) 286 do_setopt_accept_filter(so, NULL); 287 #endif /* INET */ 288 crfree(so->so_cred); 289 if (so->so_faddr != NULL) 290 kfree(so->so_faddr, M_SONAME); 291 kfree(so, M_SOCKET); 292 } 293 294 int 295 solisten(struct socket *so, int backlog, struct thread *td) 296 { 297 int error; 298 #ifdef SCTP 299 short oldopt, oldqlimit; 300 #endif /* SCTP */ 301 302 if (so->so_state & (SS_ISCONNECTED | SS_ISCONNECTING)) 303 return (EINVAL); 304 305 #ifdef SCTP 306 oldopt = so->so_options; 307 oldqlimit = so->so_qlimit; 308 #endif /* SCTP */ 309 310 lwkt_gettoken(&so->so_rcv.ssb_token); 311 if (TAILQ_EMPTY(&so->so_comp)) 312 so->so_options |= SO_ACCEPTCONN; 313 lwkt_reltoken(&so->so_rcv.ssb_token); 314 if (backlog < 0 || backlog > somaxconn) 315 backlog = somaxconn; 316 so->so_qlimit = backlog; 317 /* SCTP needs to look at tweak both the inbound backlog parameter AND 318 * the so_options (UDP model both connect's and gets inbound 319 * connections .. implicitly). 320 */ 321 error = so_pru_listen(so, td); 322 if (error) { 323 #ifdef SCTP 324 /* Restore the params */ 325 so->so_options = oldopt; 326 so->so_qlimit = oldqlimit; 327 #endif /* SCTP */ 328 return (error); 329 } 330 return (0); 331 } 332 333 /* 334 * Destroy a disconnected socket. This routine is a NOP if entities 335 * still have a reference on the socket: 336 * 337 * so_pcb - The protocol stack still has a reference 338 * SS_NOFDREF - There is no longer a file pointer reference 339 */ 340 void 341 sofree(struct socket *so) 342 { 343 struct socket *head; 344 345 /* 346 * This is a bit hackish at the moment. We need to interlock 347 * any accept queue we are on before we potentially lose the 348 * last reference to avoid races against a re-reference from 349 * someone operating on the queue. 350 */ 351 while ((head = so->so_head) != NULL) { 352 lwkt_getpooltoken(head); 353 if (so->so_head == head) 354 break; 355 lwkt_relpooltoken(head); 356 } 357 358 /* 359 * Arbitrage the last free. 360 */ 361 KKASSERT(so->so_refs > 0); 362 if (atomic_fetchadd_int(&so->so_refs, -1) != 1) { 363 if (head) 364 lwkt_relpooltoken(head); 365 return; 366 } 367 368 KKASSERT(so->so_pcb == NULL && (so->so_state & SS_NOFDREF)); 369 KKASSERT((so->so_state & SS_ASSERTINPROG) == 0); 370 371 /* 372 * We're done, remove ourselves from the accept queue we are 373 * on, if we are on one. 374 */ 375 if (head != NULL) { 376 if (so->so_state & SS_INCOMP) { 377 TAILQ_REMOVE(&head->so_incomp, so, so_list); 378 head->so_incqlen--; 379 } else if (so->so_state & SS_COMP) { 380 /* 381 * We must not decommission a socket that's 382 * on the accept(2) queue. If we do, then 383 * accept(2) may hang after select(2) indicated 384 * that the listening socket was ready. 385 */ 386 lwkt_relpooltoken(head); 387 return; 388 } else { 389 panic("sofree: not queued"); 390 } 391 soclrstate(so, SS_INCOMP); 392 so->so_head = NULL; 393 lwkt_relpooltoken(head); 394 } 395 ssb_release(&so->so_snd, so); 396 sorflush(so); 397 sodealloc(so); 398 } 399 400 /* 401 * Close a socket on last file table reference removal. 402 * Initiate disconnect if connected. 403 * Free socket when disconnect complete. 404 */ 405 int 406 soclose(struct socket *so, int fflag) 407 { 408 int error; 409 410 funsetown(&so->so_sigio); 411 if (!use_soclose_fast || 412 (so->so_proto->pr_flags & PR_SYNC_PORT) || 413 (so->so_options & SO_LINGER)) { 414 error = soclose_sync(so, fflag); 415 } else { 416 soclose_fast(so); 417 error = 0; 418 } 419 return error; 420 } 421 422 static void 423 sodiscard(struct socket *so) 424 { 425 lwkt_getpooltoken(so); 426 if (so->so_options & SO_ACCEPTCONN) { 427 struct socket *sp; 428 429 while ((sp = TAILQ_FIRST(&so->so_incomp)) != NULL) { 430 TAILQ_REMOVE(&so->so_incomp, sp, so_list); 431 soclrstate(sp, SS_INCOMP); 432 sp->so_head = NULL; 433 so->so_incqlen--; 434 soaborta(sp); 435 } 436 while ((sp = TAILQ_FIRST(&so->so_comp)) != NULL) { 437 TAILQ_REMOVE(&so->so_comp, sp, so_list); 438 soclrstate(sp, SS_COMP); 439 sp->so_head = NULL; 440 so->so_qlen--; 441 soaborta(sp); 442 } 443 } 444 lwkt_relpooltoken(so); 445 446 if (so->so_state & SS_NOFDREF) 447 panic("soclose: NOFDREF"); 448 sosetstate(so, SS_NOFDREF); /* take ref */ 449 } 450 451 static int 452 soclose_sync(struct socket *so, int fflag) 453 { 454 int error = 0; 455 456 if (so->so_pcb == NULL) 457 goto discard; 458 if (so->so_state & SS_ISCONNECTED) { 459 if ((so->so_state & SS_ISDISCONNECTING) == 0) { 460 error = sodisconnect(so); 461 if (error) 462 goto drop; 463 } 464 if (so->so_options & SO_LINGER) { 465 if ((so->so_state & SS_ISDISCONNECTING) && 466 (fflag & FNONBLOCK)) 467 goto drop; 468 while (so->so_state & SS_ISCONNECTED) { 469 error = tsleep(&so->so_timeo, PCATCH, 470 "soclos", so->so_linger * hz); 471 if (error) 472 break; 473 } 474 } 475 } 476 drop: 477 if (so->so_pcb) { 478 int error2; 479 480 error2 = so_pru_detach(so); 481 if (error == 0) 482 error = error2; 483 } 484 discard: 485 sodiscard(so); 486 so_pru_sync(so); /* unpend async sending */ 487 sofree(so); /* dispose of ref */ 488 489 return (error); 490 } 491 492 static void 493 soclose_sofree_async_handler(netmsg_t msg) 494 { 495 sofree(msg->base.nm_so); 496 } 497 498 static void 499 soclose_sofree_async(struct socket *so) 500 { 501 struct netmsg_base *base = &so->so_clomsg; 502 503 netmsg_init(base, so, &netisr_apanic_rport, 0, 504 soclose_sofree_async_handler); 505 lwkt_sendmsg(so->so_port, &base->lmsg); 506 } 507 508 static void 509 soclose_disconn_async_handler(netmsg_t msg) 510 { 511 struct socket *so = msg->base.nm_so; 512 513 if ((so->so_state & SS_ISCONNECTED) && 514 (so->so_state & SS_ISDISCONNECTING) == 0) 515 so_pru_disconnect_direct(so); 516 517 if (so->so_pcb) 518 so_pru_detach_direct(so); 519 520 sodiscard(so); 521 sofree(so); 522 } 523 524 static void 525 soclose_disconn_async(struct socket *so) 526 { 527 struct netmsg_base *base = &so->so_clomsg; 528 529 netmsg_init(base, so, &netisr_apanic_rport, 0, 530 soclose_disconn_async_handler); 531 lwkt_sendmsg(so->so_port, &base->lmsg); 532 } 533 534 static void 535 soclose_detach_async_handler(netmsg_t msg) 536 { 537 struct socket *so = msg->base.nm_so; 538 539 if (so->so_pcb) 540 so_pru_detach_direct(so); 541 542 sodiscard(so); 543 sofree(so); 544 } 545 546 static void 547 soclose_detach_async(struct socket *so) 548 { 549 struct netmsg_base *base = &so->so_clomsg; 550 551 netmsg_init(base, so, &netisr_apanic_rport, 0, 552 soclose_detach_async_handler); 553 lwkt_sendmsg(so->so_port, &base->lmsg); 554 } 555 556 static void 557 soclose_fast(struct socket *so) 558 { 559 if (so->so_pcb == NULL) 560 goto discard; 561 562 if ((so->so_state & SS_ISCONNECTED) && 563 (so->so_state & SS_ISDISCONNECTING) == 0) { 564 soclose_disconn_async(so); 565 return; 566 } 567 568 if (so->so_pcb) { 569 soclose_detach_async(so); 570 return; 571 } 572 573 discard: 574 sodiscard(so); 575 soclose_sofree_async(so); 576 } 577 578 /* 579 * Abort and destroy a socket. Only one abort can be in progress 580 * at any given moment. 581 */ 582 void 583 soabort(struct socket *so) 584 { 585 soreference(so); 586 so_pru_abort(so); 587 } 588 589 void 590 soaborta(struct socket *so) 591 { 592 soreference(so); 593 so_pru_aborta(so); 594 } 595 596 void 597 soabort_oncpu(struct socket *so) 598 { 599 soreference(so); 600 so_pru_abort_oncpu(so); 601 } 602 603 /* 604 * so is passed in ref'd, which becomes owned by 605 * the cleared SS_NOFDREF flag. 606 */ 607 void 608 soaccept_generic(struct socket *so) 609 { 610 if ((so->so_state & SS_NOFDREF) == 0) 611 panic("soaccept: !NOFDREF"); 612 soclrstate(so, SS_NOFDREF); /* owned by lack of SS_NOFDREF */ 613 } 614 615 int 616 soaccept(struct socket *so, struct sockaddr **nam) 617 { 618 int error; 619 620 soaccept_generic(so); 621 error = so_pru_accept(so, nam); 622 return (error); 623 } 624 625 int 626 soconnect(struct socket *so, struct sockaddr *nam, struct thread *td) 627 { 628 int error; 629 630 if (so->so_options & SO_ACCEPTCONN) 631 return (EOPNOTSUPP); 632 /* 633 * If protocol is connection-based, can only connect once. 634 * Otherwise, if connected, try to disconnect first. 635 * This allows user to disconnect by connecting to, e.g., 636 * a null address. 637 */ 638 if (so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING) && 639 ((so->so_proto->pr_flags & PR_CONNREQUIRED) || 640 (error = sodisconnect(so)))) { 641 error = EISCONN; 642 } else { 643 /* 644 * Prevent accumulated error from previous connection 645 * from biting us. 646 */ 647 so->so_error = 0; 648 error = so_pru_connect(so, nam, td); 649 } 650 return (error); 651 } 652 653 int 654 soconnect2(struct socket *so1, struct socket *so2) 655 { 656 int error; 657 658 error = so_pru_connect2(so1, so2); 659 return (error); 660 } 661 662 int 663 sodisconnect(struct socket *so) 664 { 665 int error; 666 667 if ((so->so_state & SS_ISCONNECTED) == 0) { 668 error = ENOTCONN; 669 goto bad; 670 } 671 if (so->so_state & SS_ISDISCONNECTING) { 672 error = EALREADY; 673 goto bad; 674 } 675 error = so_pru_disconnect(so); 676 bad: 677 return (error); 678 } 679 680 #define SBLOCKWAIT(f) (((f) & MSG_DONTWAIT) ? M_NOWAIT : M_WAITOK) 681 /* 682 * Send on a socket. 683 * If send must go all at once and message is larger than 684 * send buffering, then hard error. 685 * Lock against other senders. 686 * If must go all at once and not enough room now, then 687 * inform user that this would block and do nothing. 688 * Otherwise, if nonblocking, send as much as possible. 689 * The data to be sent is described by "uio" if nonzero, 690 * otherwise by the mbuf chain "top" (which must be null 691 * if uio is not). Data provided in mbuf chain must be small 692 * enough to send all at once. 693 * 694 * Returns nonzero on error, timeout or signal; callers 695 * must check for short counts if EINTR/ERESTART are returned. 696 * Data and control buffers are freed on return. 697 */ 698 int 699 sosend(struct socket *so, struct sockaddr *addr, struct uio *uio, 700 struct mbuf *top, struct mbuf *control, int flags, 701 struct thread *td) 702 { 703 struct mbuf **mp; 704 struct mbuf *m; 705 size_t resid; 706 int space, len; 707 int clen = 0, error, dontroute, mlen; 708 int atomic = sosendallatonce(so) || top; 709 int pru_flags; 710 711 if (uio) { 712 resid = uio->uio_resid; 713 } else { 714 resid = (size_t)top->m_pkthdr.len; 715 #ifdef INVARIANTS 716 len = 0; 717 for (m = top; m; m = m->m_next) 718 len += m->m_len; 719 KKASSERT(top->m_pkthdr.len == len); 720 #endif 721 } 722 723 /* 724 * WARNING! resid is unsigned, space and len are signed. space 725 * can wind up negative if the sockbuf is overcommitted. 726 * 727 * Also check to make sure that MSG_EOR isn't used on SOCK_STREAM 728 * type sockets since that's an error. 729 */ 730 if (so->so_type == SOCK_STREAM && (flags & MSG_EOR)) { 731 error = EINVAL; 732 goto out; 733 } 734 735 dontroute = 736 (flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 && 737 (so->so_proto->pr_flags & PR_ATOMIC); 738 if (td->td_lwp != NULL) 739 td->td_lwp->lwp_ru.ru_msgsnd++; 740 if (control) 741 clen = control->m_len; 742 #define gotoerr(errcode) { error = errcode; goto release; } 743 744 restart: 745 error = ssb_lock(&so->so_snd, SBLOCKWAIT(flags)); 746 if (error) 747 goto out; 748 749 do { 750 if (so->so_state & SS_CANTSENDMORE) 751 gotoerr(EPIPE); 752 if (so->so_error) { 753 error = so->so_error; 754 so->so_error = 0; 755 goto release; 756 } 757 if ((so->so_state & SS_ISCONNECTED) == 0) { 758 /* 759 * `sendto' and `sendmsg' is allowed on a connection- 760 * based socket if it supports implied connect. 761 * Return ENOTCONN if not connected and no address is 762 * supplied. 763 */ 764 if ((so->so_proto->pr_flags & PR_CONNREQUIRED) && 765 (so->so_proto->pr_flags & PR_IMPLOPCL) == 0) { 766 if ((so->so_state & SS_ISCONFIRMING) == 0 && 767 !(resid == 0 && clen != 0)) 768 gotoerr(ENOTCONN); 769 } else if (addr == NULL) 770 gotoerr(so->so_proto->pr_flags & PR_CONNREQUIRED ? 771 ENOTCONN : EDESTADDRREQ); 772 } 773 if ((atomic && resid > so->so_snd.ssb_hiwat) || 774 clen > so->so_snd.ssb_hiwat) { 775 gotoerr(EMSGSIZE); 776 } 777 space = ssb_space(&so->so_snd); 778 if (flags & MSG_OOB) 779 space += 1024; 780 if ((space < 0 || (size_t)space < resid + clen) && uio && 781 (atomic || space < so->so_snd.ssb_lowat || space < clen)) { 782 if (flags & (MSG_FNONBLOCKING|MSG_DONTWAIT)) 783 gotoerr(EWOULDBLOCK); 784 ssb_unlock(&so->so_snd); 785 error = ssb_wait(&so->so_snd); 786 if (error) 787 goto out; 788 goto restart; 789 } 790 mp = ⊤ 791 space -= clen; 792 do { 793 if (uio == NULL) { 794 /* 795 * Data is prepackaged in "top". 796 */ 797 resid = 0; 798 if (flags & MSG_EOR) 799 top->m_flags |= M_EOR; 800 } else do { 801 if (resid > INT_MAX) 802 resid = INT_MAX; 803 m = m_getl((int)resid, MB_WAIT, MT_DATA, 804 top == NULL ? M_PKTHDR : 0, &mlen); 805 if (top == NULL) { 806 m->m_pkthdr.len = 0; 807 m->m_pkthdr.rcvif = NULL; 808 } 809 len = imin((int)szmin(mlen, resid), space); 810 if (resid < MINCLSIZE) { 811 /* 812 * For datagram protocols, leave room 813 * for protocol headers in first mbuf. 814 */ 815 if (atomic && top == NULL && len < mlen) 816 MH_ALIGN(m, len); 817 } 818 space -= len; 819 error = uiomove(mtod(m, caddr_t), (size_t)len, uio); 820 resid = uio->uio_resid; 821 m->m_len = len; 822 *mp = m; 823 top->m_pkthdr.len += len; 824 if (error) 825 goto release; 826 mp = &m->m_next; 827 if (resid == 0) { 828 if (flags & MSG_EOR) 829 top->m_flags |= M_EOR; 830 break; 831 } 832 } while (space > 0 && atomic); 833 if (dontroute) 834 so->so_options |= SO_DONTROUTE; 835 if (flags & MSG_OOB) { 836 pru_flags = PRUS_OOB; 837 } else if ((flags & MSG_EOF) && 838 (so->so_proto->pr_flags & PR_IMPLOPCL) && 839 (resid == 0)) { 840 /* 841 * If the user set MSG_EOF, the protocol 842 * understands this flag and nothing left to 843 * send then use PRU_SEND_EOF instead of PRU_SEND. 844 */ 845 pru_flags = PRUS_EOF; 846 } else if (resid > 0 && space > 0) { 847 /* If there is more to send, set PRUS_MORETOCOME */ 848 pru_flags = PRUS_MORETOCOME; 849 } else { 850 pru_flags = 0; 851 } 852 /* 853 * XXX all the SS_CANTSENDMORE checks previously 854 * done could be out of date. We could have recieved 855 * a reset packet in an interrupt or maybe we slept 856 * while doing page faults in uiomove() etc. We could 857 * probably recheck again inside the splnet() protection 858 * here, but there are probably other places that this 859 * also happens. We must rethink this. 860 */ 861 error = so_pru_send(so, pru_flags, top, addr, control, td); 862 if (dontroute) 863 so->so_options &= ~SO_DONTROUTE; 864 clen = 0; 865 control = NULL; 866 top = NULL; 867 mp = ⊤ 868 if (error) 869 goto release; 870 } while (resid && space > 0); 871 } while (resid); 872 873 release: 874 ssb_unlock(&so->so_snd); 875 out: 876 if (top) 877 m_freem(top); 878 if (control) 879 m_freem(control); 880 return (error); 881 } 882 883 /* 884 * A specialization of sosend() for UDP based on protocol-specific knowledge: 885 * so->so_proto->pr_flags has the PR_ATOMIC field set. This means that 886 * sosendallatonce() returns true, 887 * the "atomic" variable is true, 888 * and sosendudp() blocks until space is available for the entire send. 889 * so->so_proto->pr_flags does not have the PR_CONNREQUIRED or 890 * PR_IMPLOPCL flags set. 891 * UDP has no out-of-band data. 892 * UDP has no control data. 893 * UDP does not support MSG_EOR. 894 */ 895 int 896 sosendudp(struct socket *so, struct sockaddr *addr, struct uio *uio, 897 struct mbuf *top, struct mbuf *control, int flags, struct thread *td) 898 { 899 size_t resid; 900 int error, pru_flags = 0; 901 int space; 902 903 if (td->td_lwp != NULL) 904 td->td_lwp->lwp_ru.ru_msgsnd++; 905 if (control) 906 m_freem(control); 907 908 KASSERT((uio && !top) || (top && !uio), ("bad arguments to sosendudp")); 909 resid = uio ? uio->uio_resid : (size_t)top->m_pkthdr.len; 910 911 restart: 912 error = ssb_lock(&so->so_snd, SBLOCKWAIT(flags)); 913 if (error) 914 goto out; 915 916 if (so->so_state & SS_CANTSENDMORE) 917 gotoerr(EPIPE); 918 if (so->so_error) { 919 error = so->so_error; 920 so->so_error = 0; 921 goto release; 922 } 923 if (!(so->so_state & SS_ISCONNECTED) && addr == NULL) 924 gotoerr(EDESTADDRREQ); 925 if (resid > so->so_snd.ssb_hiwat) 926 gotoerr(EMSGSIZE); 927 space = ssb_space(&so->so_snd); 928 if (uio && (space < 0 || (size_t)space < resid)) { 929 if (flags & (MSG_FNONBLOCKING|MSG_DONTWAIT)) 930 gotoerr(EWOULDBLOCK); 931 ssb_unlock(&so->so_snd); 932 error = ssb_wait(&so->so_snd); 933 if (error) 934 goto out; 935 goto restart; 936 } 937 938 if (uio) { 939 top = m_uiomove(uio); 940 if (top == NULL) 941 goto release; 942 } 943 944 if (flags & MSG_DONTROUTE) 945 pru_flags |= PRUS_DONTROUTE; 946 947 if (udp_sosend_async && (flags & MSG_SYNC) == 0) { 948 so_pru_send_async(so, pru_flags, top, addr, NULL, td); 949 error = 0; 950 } else { 951 error = so_pru_send(so, pru_flags, top, addr, NULL, td); 952 } 953 top = NULL; /* sent or freed in lower layer */ 954 955 release: 956 ssb_unlock(&so->so_snd); 957 out: 958 if (top) 959 m_freem(top); 960 return (error); 961 } 962 963 int 964 sosendtcp(struct socket *so, struct sockaddr *addr, struct uio *uio, 965 struct mbuf *top, struct mbuf *control, int flags, 966 struct thread *td) 967 { 968 struct mbuf **mp; 969 struct mbuf *m; 970 size_t resid; 971 int space, len; 972 int error, mlen; 973 int allatonce; 974 int pru_flags; 975 976 if (uio) { 977 KKASSERT(top == NULL); 978 allatonce = 0; 979 resid = uio->uio_resid; 980 } else { 981 allatonce = 1; 982 resid = (size_t)top->m_pkthdr.len; 983 #ifdef INVARIANTS 984 len = 0; 985 for (m = top; m; m = m->m_next) 986 len += m->m_len; 987 KKASSERT(top->m_pkthdr.len == len); 988 #endif 989 } 990 991 /* 992 * WARNING! resid is unsigned, space and len are signed. space 993 * can wind up negative if the sockbuf is overcommitted. 994 * 995 * Also check to make sure that MSG_EOR isn't used on TCP 996 */ 997 if (flags & MSG_EOR) { 998 error = EINVAL; 999 goto out; 1000 } 1001 1002 if (control) { 1003 /* TCP doesn't do control messages (rights, creds, etc) */ 1004 if (control->m_len) { 1005 error = EINVAL; 1006 goto out; 1007 } 1008 m_freem(control); /* empty control, just free it */ 1009 control = NULL; 1010 } 1011 1012 if (td->td_lwp != NULL) 1013 td->td_lwp->lwp_ru.ru_msgsnd++; 1014 1015 #define gotoerr(errcode) { error = errcode; goto release; } 1016 1017 restart: 1018 error = ssb_lock(&so->so_snd, SBLOCKWAIT(flags)); 1019 if (error) 1020 goto out; 1021 1022 do { 1023 if (so->so_state & SS_CANTSENDMORE) 1024 gotoerr(EPIPE); 1025 if (so->so_error) { 1026 error = so->so_error; 1027 so->so_error = 0; 1028 goto release; 1029 } 1030 if ((so->so_state & SS_ISCONNECTED) == 0 && 1031 (so->so_state & SS_ISCONFIRMING) == 0) 1032 gotoerr(ENOTCONN); 1033 if (allatonce && resid > so->so_snd.ssb_hiwat) 1034 gotoerr(EMSGSIZE); 1035 1036 space = ssb_space_prealloc(&so->so_snd); 1037 if (flags & MSG_OOB) 1038 space += 1024; 1039 if ((space < 0 || (size_t)space < resid) && !allatonce && 1040 space < so->so_snd.ssb_lowat) { 1041 if (flags & (MSG_FNONBLOCKING|MSG_DONTWAIT)) 1042 gotoerr(EWOULDBLOCK); 1043 ssb_unlock(&so->so_snd); 1044 error = ssb_wait(&so->so_snd); 1045 if (error) 1046 goto out; 1047 goto restart; 1048 } 1049 mp = ⊤ 1050 do { 1051 int cnt = 0, async = 0; 1052 1053 if (uio == NULL) { 1054 /* 1055 * Data is prepackaged in "top". 1056 */ 1057 resid = 0; 1058 } else do { 1059 if (resid > INT_MAX) 1060 resid = INT_MAX; 1061 m = m_getl((int)resid, MB_WAIT, MT_DATA, 1062 top == NULL ? M_PKTHDR : 0, &mlen); 1063 if (top == NULL) { 1064 m->m_pkthdr.len = 0; 1065 m->m_pkthdr.rcvif = NULL; 1066 } 1067 len = imin((int)szmin(mlen, resid), space); 1068 space -= len; 1069 error = uiomove(mtod(m, caddr_t), (size_t)len, uio); 1070 resid = uio->uio_resid; 1071 m->m_len = len; 1072 *mp = m; 1073 top->m_pkthdr.len += len; 1074 if (error) 1075 goto release; 1076 mp = &m->m_next; 1077 if (resid == 0) 1078 break; 1079 ++cnt; 1080 } while (space > 0 && cnt < tcp_sosend_agglim); 1081 1082 if (tcp_sosend_async) 1083 async = 1; 1084 1085 if (flags & MSG_OOB) { 1086 pru_flags = PRUS_OOB; 1087 async = 0; 1088 } else if ((flags & MSG_EOF) && resid == 0) { 1089 pru_flags = PRUS_EOF; 1090 } else if (resid > 0 && space > 0) { 1091 /* If there is more to send, set PRUS_MORETOCOME */ 1092 pru_flags = PRUS_MORETOCOME; 1093 async = 1; 1094 } else { 1095 pru_flags = 0; 1096 } 1097 1098 if (flags & MSG_SYNC) 1099 async = 0; 1100 1101 /* 1102 * XXX all the SS_CANTSENDMORE checks previously 1103 * done could be out of date. We could have recieved 1104 * a reset packet in an interrupt or maybe we slept 1105 * while doing page faults in uiomove() etc. We could 1106 * probably recheck again inside the splnet() protection 1107 * here, but there are probably other places that this 1108 * also happens. We must rethink this. 1109 */ 1110 for (m = top; m; m = m->m_next) 1111 ssb_preallocstream(&so->so_snd, m); 1112 if (!async) { 1113 error = so_pru_send(so, pru_flags, top, 1114 NULL, NULL, td); 1115 } else { 1116 so_pru_send_async(so, pru_flags, top, 1117 NULL, NULL, td); 1118 error = 0; 1119 } 1120 1121 top = NULL; 1122 mp = ⊤ 1123 if (error) 1124 goto release; 1125 } while (resid && space > 0); 1126 } while (resid); 1127 1128 release: 1129 ssb_unlock(&so->so_snd); 1130 out: 1131 if (top) 1132 m_freem(top); 1133 if (control) 1134 m_freem(control); 1135 return (error); 1136 } 1137 1138 /* 1139 * Implement receive operations on a socket. 1140 * 1141 * We depend on the way that records are added to the signalsockbuf 1142 * by sbappend*. In particular, each record (mbufs linked through m_next) 1143 * must begin with an address if the protocol so specifies, 1144 * followed by an optional mbuf or mbufs containing ancillary data, 1145 * and then zero or more mbufs of data. 1146 * 1147 * Although the signalsockbuf is locked, new data may still be appended. 1148 * A token inside the ssb_lock deals with MP issues and still allows 1149 * the network to access the socket if we block in a uio. 1150 * 1151 * The caller may receive the data as a single mbuf chain by supplying 1152 * an mbuf **mp0 for use in returning the chain. The uio is then used 1153 * only for the count in uio_resid. 1154 */ 1155 int 1156 soreceive(struct socket *so, struct sockaddr **psa, struct uio *uio, 1157 struct sockbuf *sio, struct mbuf **controlp, int *flagsp) 1158 { 1159 struct mbuf *m, *n; 1160 struct mbuf *free_chain = NULL; 1161 int flags, len, error, offset; 1162 struct protosw *pr = so->so_proto; 1163 int moff, type = 0; 1164 size_t resid, orig_resid; 1165 1166 if (uio) 1167 resid = uio->uio_resid; 1168 else 1169 resid = (size_t)(sio->sb_climit - sio->sb_cc); 1170 orig_resid = resid; 1171 1172 if (psa) 1173 *psa = NULL; 1174 if (controlp) 1175 *controlp = NULL; 1176 if (flagsp) 1177 flags = *flagsp &~ MSG_EOR; 1178 else 1179 flags = 0; 1180 if (flags & MSG_OOB) { 1181 m = m_get(MB_WAIT, MT_DATA); 1182 if (m == NULL) 1183 return (ENOBUFS); 1184 error = so_pru_rcvoob(so, m, flags & MSG_PEEK); 1185 if (error) 1186 goto bad; 1187 if (sio) { 1188 do { 1189 sbappend(sio, m); 1190 KKASSERT(resid >= (size_t)m->m_len); 1191 resid -= (size_t)m->m_len; 1192 } while (resid > 0 && m); 1193 } else { 1194 do { 1195 uio->uio_resid = resid; 1196 error = uiomove(mtod(m, caddr_t), 1197 (int)szmin(resid, m->m_len), 1198 uio); 1199 resid = uio->uio_resid; 1200 m = m_free(m); 1201 } while (uio->uio_resid && error == 0 && m); 1202 } 1203 bad: 1204 if (m) 1205 m_freem(m); 1206 return (error); 1207 } 1208 if ((so->so_state & SS_ISCONFIRMING) && resid) 1209 so_pru_rcvd(so, 0); 1210 1211 /* 1212 * The token interlocks against the protocol thread while 1213 * ssb_lock is a blocking lock against other userland entities. 1214 */ 1215 lwkt_gettoken(&so->so_rcv.ssb_token); 1216 restart: 1217 error = ssb_lock(&so->so_rcv, SBLOCKWAIT(flags)); 1218 if (error) 1219 goto done; 1220 1221 m = so->so_rcv.ssb_mb; 1222 /* 1223 * If we have less data than requested, block awaiting more 1224 * (subject to any timeout) if: 1225 * 1. the current count is less than the low water mark, or 1226 * 2. MSG_WAITALL is set, and it is possible to do the entire 1227 * receive operation at once if we block (resid <= hiwat). 1228 * 3. MSG_DONTWAIT is not set 1229 * If MSG_WAITALL is set but resid is larger than the receive buffer, 1230 * we have to do the receive in sections, and thus risk returning 1231 * a short count if a timeout or signal occurs after we start. 1232 */ 1233 if (m == NULL || (((flags & MSG_DONTWAIT) == 0 && 1234 (size_t)so->so_rcv.ssb_cc < resid) && 1235 (so->so_rcv.ssb_cc < so->so_rcv.ssb_lowat || 1236 ((flags & MSG_WAITALL) && resid <= (size_t)so->so_rcv.ssb_hiwat)) && 1237 m->m_nextpkt == 0 && (pr->pr_flags & PR_ATOMIC) == 0)) { 1238 KASSERT(m != NULL || !so->so_rcv.ssb_cc, ("receive 1")); 1239 if (so->so_error) { 1240 if (m) 1241 goto dontblock; 1242 error = so->so_error; 1243 if ((flags & MSG_PEEK) == 0) 1244 so->so_error = 0; 1245 goto release; 1246 } 1247 if (so->so_state & SS_CANTRCVMORE) { 1248 if (m) 1249 goto dontblock; 1250 else 1251 goto release; 1252 } 1253 for (; m; m = m->m_next) { 1254 if (m->m_type == MT_OOBDATA || (m->m_flags & M_EOR)) { 1255 m = so->so_rcv.ssb_mb; 1256 goto dontblock; 1257 } 1258 } 1259 if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) == 0 && 1260 (pr->pr_flags & PR_CONNREQUIRED)) { 1261 error = ENOTCONN; 1262 goto release; 1263 } 1264 if (resid == 0) 1265 goto release; 1266 if (flags & (MSG_FNONBLOCKING|MSG_DONTWAIT)) { 1267 error = EWOULDBLOCK; 1268 goto release; 1269 } 1270 ssb_unlock(&so->so_rcv); 1271 error = ssb_wait(&so->so_rcv); 1272 if (error) 1273 goto done; 1274 goto restart; 1275 } 1276 dontblock: 1277 if (uio && uio->uio_td && uio->uio_td->td_proc) 1278 uio->uio_td->td_lwp->lwp_ru.ru_msgrcv++; 1279 1280 /* 1281 * note: m should be == sb_mb here. Cache the next record while 1282 * cleaning up. Note that calling m_free*() will break out critical 1283 * section. 1284 */ 1285 KKASSERT(m == so->so_rcv.ssb_mb); 1286 1287 /* 1288 * Skip any address mbufs prepending the record. 1289 */ 1290 if (pr->pr_flags & PR_ADDR) { 1291 KASSERT(m->m_type == MT_SONAME, ("receive 1a")); 1292 orig_resid = 0; 1293 if (psa) 1294 *psa = dup_sockaddr(mtod(m, struct sockaddr *)); 1295 if (flags & MSG_PEEK) 1296 m = m->m_next; 1297 else 1298 m = sbunlinkmbuf(&so->so_rcv.sb, m, &free_chain); 1299 } 1300 1301 /* 1302 * Skip any control mbufs prepending the record. 1303 */ 1304 #ifdef SCTP 1305 if (pr->pr_flags & PR_ADDR_OPT) { 1306 /* 1307 * For SCTP we may be getting a 1308 * whole message OR a partial delivery. 1309 */ 1310 if (m && m->m_type == MT_SONAME) { 1311 orig_resid = 0; 1312 if (psa) 1313 *psa = dup_sockaddr(mtod(m, struct sockaddr *)); 1314 if (flags & MSG_PEEK) 1315 m = m->m_next; 1316 else 1317 m = sbunlinkmbuf(&so->so_rcv.sb, m, &free_chain); 1318 } 1319 } 1320 #endif /* SCTP */ 1321 while (m && m->m_type == MT_CONTROL && error == 0) { 1322 if (flags & MSG_PEEK) { 1323 if (controlp) 1324 *controlp = m_copy(m, 0, m->m_len); 1325 m = m->m_next; /* XXX race */ 1326 } else { 1327 if (controlp) { 1328 n = sbunlinkmbuf(&so->so_rcv.sb, m, NULL); 1329 if (pr->pr_domain->dom_externalize && 1330 mtod(m, struct cmsghdr *)->cmsg_type == 1331 SCM_RIGHTS) 1332 error = (*pr->pr_domain->dom_externalize)(m); 1333 *controlp = m; 1334 m = n; 1335 } else { 1336 m = sbunlinkmbuf(&so->so_rcv.sb, m, &free_chain); 1337 } 1338 } 1339 if (controlp && *controlp) { 1340 orig_resid = 0; 1341 controlp = &(*controlp)->m_next; 1342 } 1343 } 1344 1345 /* 1346 * flag OOB data. 1347 */ 1348 if (m) { 1349 type = m->m_type; 1350 if (type == MT_OOBDATA) 1351 flags |= MSG_OOB; 1352 } 1353 1354 /* 1355 * Copy to the UIO or mbuf return chain (*mp). 1356 */ 1357 moff = 0; 1358 offset = 0; 1359 while (m && resid > 0 && error == 0) { 1360 if (m->m_type == MT_OOBDATA) { 1361 if (type != MT_OOBDATA) 1362 break; 1363 } else if (type == MT_OOBDATA) 1364 break; 1365 else 1366 KASSERT(m->m_type == MT_DATA || m->m_type == MT_HEADER, 1367 ("receive 3")); 1368 soclrstate(so, SS_RCVATMARK); 1369 len = (resid > INT_MAX) ? INT_MAX : resid; 1370 if (so->so_oobmark && len > so->so_oobmark - offset) 1371 len = so->so_oobmark - offset; 1372 if (len > m->m_len - moff) 1373 len = m->m_len - moff; 1374 1375 /* 1376 * Copy out to the UIO or pass the mbufs back to the SIO. 1377 * The SIO is dealt with when we eat the mbuf, but deal 1378 * with the resid here either way. 1379 */ 1380 if (uio) { 1381 uio->uio_resid = resid; 1382 error = uiomove(mtod(m, caddr_t) + moff, len, uio); 1383 resid = uio->uio_resid; 1384 if (error) 1385 goto release; 1386 } else { 1387 resid -= (size_t)len; 1388 } 1389 1390 /* 1391 * Eat the entire mbuf or just a piece of it 1392 */ 1393 if (len == m->m_len - moff) { 1394 if (m->m_flags & M_EOR) 1395 flags |= MSG_EOR; 1396 #ifdef SCTP 1397 if (m->m_flags & M_NOTIFICATION) 1398 flags |= MSG_NOTIFICATION; 1399 #endif /* SCTP */ 1400 if (flags & MSG_PEEK) { 1401 m = m->m_next; 1402 moff = 0; 1403 } else { 1404 if (sio) { 1405 n = sbunlinkmbuf(&so->so_rcv.sb, m, NULL); 1406 sbappend(sio, m); 1407 m = n; 1408 } else { 1409 m = sbunlinkmbuf(&so->so_rcv.sb, m, &free_chain); 1410 } 1411 } 1412 } else { 1413 if (flags & MSG_PEEK) { 1414 moff += len; 1415 } else { 1416 if (sio) { 1417 n = m_copym(m, 0, len, MB_WAIT); 1418 if (n) 1419 sbappend(sio, n); 1420 } 1421 m->m_data += len; 1422 m->m_len -= len; 1423 so->so_rcv.ssb_cc -= len; 1424 } 1425 } 1426 if (so->so_oobmark) { 1427 if ((flags & MSG_PEEK) == 0) { 1428 so->so_oobmark -= len; 1429 if (so->so_oobmark == 0) { 1430 sosetstate(so, SS_RCVATMARK); 1431 break; 1432 } 1433 } else { 1434 offset += len; 1435 if (offset == so->so_oobmark) 1436 break; 1437 } 1438 } 1439 if (flags & MSG_EOR) 1440 break; 1441 /* 1442 * If the MSG_WAITALL flag is set (for non-atomic socket), 1443 * we must not quit until resid == 0 or an error 1444 * termination. If a signal/timeout occurs, return 1445 * with a short count but without error. 1446 * Keep signalsockbuf locked against other readers. 1447 */ 1448 while ((flags & MSG_WAITALL) && m == NULL && 1449 resid > 0 && !sosendallatonce(so) && 1450 so->so_rcv.ssb_mb == NULL) { 1451 if (so->so_error || so->so_state & SS_CANTRCVMORE) 1452 break; 1453 /* 1454 * The window might have closed to zero, make 1455 * sure we send an ack now that we've drained 1456 * the buffer or we might end up blocking until 1457 * the idle takes over (5 seconds). 1458 */ 1459 if (pr->pr_flags & PR_WANTRCVD && so->so_pcb) 1460 so_pru_rcvd(so, flags); 1461 error = ssb_wait(&so->so_rcv); 1462 if (error) { 1463 ssb_unlock(&so->so_rcv); 1464 error = 0; 1465 goto done; 1466 } 1467 m = so->so_rcv.ssb_mb; 1468 } 1469 } 1470 1471 /* 1472 * If an atomic read was requested but unread data still remains 1473 * in the record, set MSG_TRUNC. 1474 */ 1475 if (m && pr->pr_flags & PR_ATOMIC) 1476 flags |= MSG_TRUNC; 1477 1478 /* 1479 * Cleanup. If an atomic read was requested drop any unread data. 1480 */ 1481 if ((flags & MSG_PEEK) == 0) { 1482 if (m && (pr->pr_flags & PR_ATOMIC)) 1483 sbdroprecord(&so->so_rcv.sb); 1484 if ((pr->pr_flags & PR_WANTRCVD) && so->so_pcb) 1485 so_pru_rcvd(so, flags); 1486 } 1487 1488 if (orig_resid == resid && orig_resid && 1489 (flags & MSG_EOR) == 0 && (so->so_state & SS_CANTRCVMORE) == 0) { 1490 ssb_unlock(&so->so_rcv); 1491 goto restart; 1492 } 1493 1494 if (flagsp) 1495 *flagsp |= flags; 1496 release: 1497 ssb_unlock(&so->so_rcv); 1498 done: 1499 lwkt_reltoken(&so->so_rcv.ssb_token); 1500 if (free_chain) 1501 m_freem(free_chain); 1502 return (error); 1503 } 1504 1505 int 1506 sorecvtcp(struct socket *so, struct sockaddr **psa, struct uio *uio, 1507 struct sockbuf *sio, struct mbuf **controlp, int *flagsp) 1508 { 1509 struct mbuf *m, *n; 1510 struct mbuf *free_chain = NULL; 1511 int flags, len, error, offset; 1512 struct protosw *pr = so->so_proto; 1513 int moff; 1514 size_t resid, orig_resid; 1515 1516 if (uio) 1517 resid = uio->uio_resid; 1518 else 1519 resid = (size_t)(sio->sb_climit - sio->sb_cc); 1520 orig_resid = resid; 1521 1522 if (psa) 1523 *psa = NULL; 1524 if (controlp) 1525 *controlp = NULL; 1526 if (flagsp) 1527 flags = *flagsp &~ MSG_EOR; 1528 else 1529 flags = 0; 1530 if (flags & MSG_OOB) { 1531 m = m_get(MB_WAIT, MT_DATA); 1532 if (m == NULL) 1533 return (ENOBUFS); 1534 error = so_pru_rcvoob(so, m, flags & MSG_PEEK); 1535 if (error) 1536 goto bad; 1537 if (sio) { 1538 do { 1539 sbappend(sio, m); 1540 KKASSERT(resid >= (size_t)m->m_len); 1541 resid -= (size_t)m->m_len; 1542 } while (resid > 0 && m); 1543 } else { 1544 do { 1545 uio->uio_resid = resid; 1546 error = uiomove(mtod(m, caddr_t), 1547 (int)szmin(resid, m->m_len), 1548 uio); 1549 resid = uio->uio_resid; 1550 m = m_free(m); 1551 } while (uio->uio_resid && error == 0 && m); 1552 } 1553 bad: 1554 if (m) 1555 m_freem(m); 1556 return (error); 1557 } 1558 1559 /* 1560 * The token interlocks against the protocol thread while 1561 * ssb_lock is a blocking lock against other userland entities. 1562 */ 1563 lwkt_gettoken(&so->so_rcv.ssb_token); 1564 restart: 1565 error = ssb_lock(&so->so_rcv, SBLOCKWAIT(flags)); 1566 if (error) 1567 goto done; 1568 1569 m = so->so_rcv.ssb_mb; 1570 /* 1571 * If we have less data than requested, block awaiting more 1572 * (subject to any timeout) if: 1573 * 1. the current count is less than the low water mark, or 1574 * 2. MSG_WAITALL is set, and it is possible to do the entire 1575 * receive operation at once if we block (resid <= hiwat). 1576 * 3. MSG_DONTWAIT is not set 1577 * If MSG_WAITALL is set but resid is larger than the receive buffer, 1578 * we have to do the receive in sections, and thus risk returning 1579 * a short count if a timeout or signal occurs after we start. 1580 */ 1581 if (m == NULL || (((flags & MSG_DONTWAIT) == 0 && 1582 (size_t)so->so_rcv.ssb_cc < resid) && 1583 (so->so_rcv.ssb_cc < so->so_rcv.ssb_lowat || 1584 ((flags & MSG_WAITALL) && resid <= (size_t)so->so_rcv.ssb_hiwat)))) { 1585 KASSERT(m != NULL || !so->so_rcv.ssb_cc, ("receive 1")); 1586 if (so->so_error) { 1587 if (m) 1588 goto dontblock; 1589 error = so->so_error; 1590 if ((flags & MSG_PEEK) == 0) 1591 so->so_error = 0; 1592 goto release; 1593 } 1594 if (so->so_state & SS_CANTRCVMORE) { 1595 if (m) 1596 goto dontblock; 1597 else 1598 goto release; 1599 } 1600 if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) == 0 && 1601 (pr->pr_flags & PR_CONNREQUIRED)) { 1602 error = ENOTCONN; 1603 goto release; 1604 } 1605 if (resid == 0) 1606 goto release; 1607 if (flags & (MSG_FNONBLOCKING|MSG_DONTWAIT)) { 1608 error = EWOULDBLOCK; 1609 goto release; 1610 } 1611 ssb_unlock(&so->so_rcv); 1612 error = ssb_wait(&so->so_rcv); 1613 if (error) 1614 goto done; 1615 goto restart; 1616 } 1617 dontblock: 1618 if (uio && uio->uio_td && uio->uio_td->td_proc) 1619 uio->uio_td->td_lwp->lwp_ru.ru_msgrcv++; 1620 1621 /* 1622 * note: m should be == sb_mb here. Cache the next record while 1623 * cleaning up. Note that calling m_free*() will break out critical 1624 * section. 1625 */ 1626 KKASSERT(m == so->so_rcv.ssb_mb); 1627 1628 /* 1629 * Copy to the UIO or mbuf return chain (*mp). 1630 */ 1631 moff = 0; 1632 offset = 0; 1633 while (m && resid > 0 && error == 0) { 1634 KASSERT(m->m_type == MT_DATA || m->m_type == MT_HEADER, 1635 ("receive 3")); 1636 1637 soclrstate(so, SS_RCVATMARK); 1638 len = (resid > INT_MAX) ? INT_MAX : resid; 1639 if (so->so_oobmark && len > so->so_oobmark - offset) 1640 len = so->so_oobmark - offset; 1641 if (len > m->m_len - moff) 1642 len = m->m_len - moff; 1643 1644 /* 1645 * Copy out to the UIO or pass the mbufs back to the SIO. 1646 * The SIO is dealt with when we eat the mbuf, but deal 1647 * with the resid here either way. 1648 */ 1649 if (uio) { 1650 uio->uio_resid = resid; 1651 error = uiomove(mtod(m, caddr_t) + moff, len, uio); 1652 resid = uio->uio_resid; 1653 if (error) 1654 goto release; 1655 } else { 1656 resid -= (size_t)len; 1657 } 1658 1659 /* 1660 * Eat the entire mbuf or just a piece of it 1661 */ 1662 if (len == m->m_len - moff) { 1663 if (flags & MSG_PEEK) { 1664 m = m->m_next; 1665 moff = 0; 1666 } else { 1667 if (sio) { 1668 n = sbunlinkmbuf(&so->so_rcv.sb, m, NULL); 1669 sbappend(sio, m); 1670 m = n; 1671 } else { 1672 m = sbunlinkmbuf(&so->so_rcv.sb, m, &free_chain); 1673 } 1674 } 1675 } else { 1676 if (flags & MSG_PEEK) { 1677 moff += len; 1678 } else { 1679 if (sio) { 1680 n = m_copym(m, 0, len, MB_WAIT); 1681 if (n) 1682 sbappend(sio, n); 1683 } 1684 m->m_data += len; 1685 m->m_len -= len; 1686 so->so_rcv.ssb_cc -= len; 1687 } 1688 } 1689 if (so->so_oobmark) { 1690 if ((flags & MSG_PEEK) == 0) { 1691 so->so_oobmark -= len; 1692 if (so->so_oobmark == 0) { 1693 sosetstate(so, SS_RCVATMARK); 1694 break; 1695 } 1696 } else { 1697 offset += len; 1698 if (offset == so->so_oobmark) 1699 break; 1700 } 1701 } 1702 /* 1703 * If the MSG_WAITALL flag is set (for non-atomic socket), 1704 * we must not quit until resid == 0 or an error 1705 * termination. If a signal/timeout occurs, return 1706 * with a short count but without error. 1707 * Keep signalsockbuf locked against other readers. 1708 */ 1709 while ((flags & MSG_WAITALL) && m == NULL && 1710 resid > 0 && !sosendallatonce(so) && 1711 so->so_rcv.ssb_mb == NULL) { 1712 if (so->so_error || so->so_state & SS_CANTRCVMORE) 1713 break; 1714 /* 1715 * The window might have closed to zero, make 1716 * sure we send an ack now that we've drained 1717 * the buffer or we might end up blocking until 1718 * the idle takes over (5 seconds). 1719 */ 1720 if (so->so_pcb) 1721 so_pru_rcvd(so, flags); 1722 error = ssb_wait(&so->so_rcv); 1723 if (error) { 1724 ssb_unlock(&so->so_rcv); 1725 error = 0; 1726 goto done; 1727 } 1728 m = so->so_rcv.ssb_mb; 1729 } 1730 } 1731 1732 /* 1733 * Cleanup. If an atomic read was requested drop any unread data. 1734 */ 1735 if ((flags & MSG_PEEK) == 0) { 1736 if (so->so_pcb) 1737 so_pru_rcvd(so, flags); 1738 } 1739 1740 if (orig_resid == resid && orig_resid && 1741 (so->so_state & SS_CANTRCVMORE) == 0) { 1742 ssb_unlock(&so->so_rcv); 1743 goto restart; 1744 } 1745 1746 if (flagsp) 1747 *flagsp |= flags; 1748 release: 1749 ssb_unlock(&so->so_rcv); 1750 done: 1751 lwkt_reltoken(&so->so_rcv.ssb_token); 1752 if (free_chain) 1753 m_freem(free_chain); 1754 return (error); 1755 } 1756 1757 /* 1758 * Shut a socket down. Note that we do not get a frontend lock as we 1759 * want to be able to shut the socket down even if another thread is 1760 * blocked in a read(), thus waking it up. 1761 */ 1762 int 1763 soshutdown(struct socket *so, int how) 1764 { 1765 if (!(how == SHUT_RD || how == SHUT_WR || how == SHUT_RDWR)) 1766 return (EINVAL); 1767 1768 if (how != SHUT_WR) { 1769 /*ssb_lock(&so->so_rcv, M_WAITOK);*/ 1770 sorflush(so); 1771 /*ssb_unlock(&so->so_rcv);*/ 1772 } 1773 if (how != SHUT_RD) 1774 return (so_pru_shutdown(so)); 1775 return (0); 1776 } 1777 1778 void 1779 sorflush(struct socket *so) 1780 { 1781 struct signalsockbuf *ssb = &so->so_rcv; 1782 struct protosw *pr = so->so_proto; 1783 struct signalsockbuf asb; 1784 1785 atomic_set_int(&ssb->ssb_flags, SSB_NOINTR); 1786 1787 lwkt_gettoken(&ssb->ssb_token); 1788 socantrcvmore(so); 1789 asb = *ssb; 1790 1791 /* 1792 * Can't just blow up the ssb structure here 1793 */ 1794 bzero(&ssb->sb, sizeof(ssb->sb)); 1795 ssb->ssb_timeo = 0; 1796 ssb->ssb_lowat = 0; 1797 ssb->ssb_hiwat = 0; 1798 ssb->ssb_mbmax = 0; 1799 atomic_clear_int(&ssb->ssb_flags, SSB_CLEAR_MASK); 1800 1801 if ((pr->pr_flags & PR_RIGHTS) && pr->pr_domain->dom_dispose) 1802 (*pr->pr_domain->dom_dispose)(asb.ssb_mb); 1803 ssb_release(&asb, so); 1804 1805 lwkt_reltoken(&ssb->ssb_token); 1806 } 1807 1808 #ifdef INET 1809 static int 1810 do_setopt_accept_filter(struct socket *so, struct sockopt *sopt) 1811 { 1812 struct accept_filter_arg *afap = NULL; 1813 struct accept_filter *afp; 1814 struct so_accf *af = so->so_accf; 1815 int error = 0; 1816 1817 /* do not set/remove accept filters on non listen sockets */ 1818 if ((so->so_options & SO_ACCEPTCONN) == 0) { 1819 error = EINVAL; 1820 goto out; 1821 } 1822 1823 /* removing the filter */ 1824 if (sopt == NULL) { 1825 if (af != NULL) { 1826 if (af->so_accept_filter != NULL && 1827 af->so_accept_filter->accf_destroy != NULL) { 1828 af->so_accept_filter->accf_destroy(so); 1829 } 1830 if (af->so_accept_filter_str != NULL) { 1831 kfree(af->so_accept_filter_str, M_ACCF); 1832 } 1833 kfree(af, M_ACCF); 1834 so->so_accf = NULL; 1835 } 1836 so->so_options &= ~SO_ACCEPTFILTER; 1837 return (0); 1838 } 1839 /* adding a filter */ 1840 /* must remove previous filter first */ 1841 if (af != NULL) { 1842 error = EINVAL; 1843 goto out; 1844 } 1845 /* don't put large objects on the kernel stack */ 1846 afap = kmalloc(sizeof(*afap), M_TEMP, M_WAITOK); 1847 error = sooptcopyin(sopt, afap, sizeof *afap, sizeof *afap); 1848 afap->af_name[sizeof(afap->af_name)-1] = '\0'; 1849 afap->af_arg[sizeof(afap->af_arg)-1] = '\0'; 1850 if (error) 1851 goto out; 1852 afp = accept_filt_get(afap->af_name); 1853 if (afp == NULL) { 1854 error = ENOENT; 1855 goto out; 1856 } 1857 af = kmalloc(sizeof(*af), M_ACCF, M_WAITOK | M_ZERO); 1858 if (afp->accf_create != NULL) { 1859 if (afap->af_name[0] != '\0') { 1860 int len = strlen(afap->af_name) + 1; 1861 1862 af->so_accept_filter_str = kmalloc(len, M_ACCF, 1863 M_WAITOK); 1864 strcpy(af->so_accept_filter_str, afap->af_name); 1865 } 1866 af->so_accept_filter_arg = afp->accf_create(so, afap->af_arg); 1867 if (af->so_accept_filter_arg == NULL) { 1868 kfree(af->so_accept_filter_str, M_ACCF); 1869 kfree(af, M_ACCF); 1870 so->so_accf = NULL; 1871 error = EINVAL; 1872 goto out; 1873 } 1874 } 1875 af->so_accept_filter = afp; 1876 so->so_accf = af; 1877 so->so_options |= SO_ACCEPTFILTER; 1878 out: 1879 if (afap != NULL) 1880 kfree(afap, M_TEMP); 1881 return (error); 1882 } 1883 #endif /* INET */ 1884 1885 /* 1886 * Perhaps this routine, and sooptcopyout(), below, ought to come in 1887 * an additional variant to handle the case where the option value needs 1888 * to be some kind of integer, but not a specific size. 1889 * In addition to their use here, these functions are also called by the 1890 * protocol-level pr_ctloutput() routines. 1891 */ 1892 int 1893 sooptcopyin(struct sockopt *sopt, void *buf, size_t len, size_t minlen) 1894 { 1895 return soopt_to_kbuf(sopt, buf, len, minlen); 1896 } 1897 1898 int 1899 soopt_to_kbuf(struct sockopt *sopt, void *buf, size_t len, size_t minlen) 1900 { 1901 size_t valsize; 1902 1903 KKASSERT(!sopt->sopt_val || kva_p(sopt->sopt_val)); 1904 KKASSERT(kva_p(buf)); 1905 1906 /* 1907 * If the user gives us more than we wanted, we ignore it, 1908 * but if we don't get the minimum length the caller 1909 * wants, we return EINVAL. On success, sopt->sopt_valsize 1910 * is set to however much we actually retrieved. 1911 */ 1912 if ((valsize = sopt->sopt_valsize) < minlen) 1913 return EINVAL; 1914 if (valsize > len) 1915 sopt->sopt_valsize = valsize = len; 1916 1917 bcopy(sopt->sopt_val, buf, valsize); 1918 return 0; 1919 } 1920 1921 1922 int 1923 sosetopt(struct socket *so, struct sockopt *sopt) 1924 { 1925 int error, optval; 1926 struct linger l; 1927 struct timeval tv; 1928 u_long val; 1929 struct signalsockbuf *sotmp; 1930 1931 error = 0; 1932 sopt->sopt_dir = SOPT_SET; 1933 if (sopt->sopt_level != SOL_SOCKET) { 1934 if (so->so_proto && so->so_proto->pr_ctloutput) { 1935 return (so_pr_ctloutput(so, sopt)); 1936 } 1937 error = ENOPROTOOPT; 1938 } else { 1939 switch (sopt->sopt_name) { 1940 #ifdef INET 1941 case SO_ACCEPTFILTER: 1942 error = do_setopt_accept_filter(so, sopt); 1943 if (error) 1944 goto bad; 1945 break; 1946 #endif /* INET */ 1947 case SO_LINGER: 1948 error = sooptcopyin(sopt, &l, sizeof l, sizeof l); 1949 if (error) 1950 goto bad; 1951 1952 so->so_linger = l.l_linger; 1953 if (l.l_onoff) 1954 so->so_options |= SO_LINGER; 1955 else 1956 so->so_options &= ~SO_LINGER; 1957 break; 1958 1959 case SO_DEBUG: 1960 case SO_KEEPALIVE: 1961 case SO_DONTROUTE: 1962 case SO_USELOOPBACK: 1963 case SO_BROADCAST: 1964 case SO_REUSEADDR: 1965 case SO_REUSEPORT: 1966 case SO_OOBINLINE: 1967 case SO_TIMESTAMP: 1968 error = sooptcopyin(sopt, &optval, sizeof optval, 1969 sizeof optval); 1970 if (error) 1971 goto bad; 1972 if (optval) 1973 so->so_options |= sopt->sopt_name; 1974 else 1975 so->so_options &= ~sopt->sopt_name; 1976 break; 1977 1978 case SO_SNDBUF: 1979 case SO_RCVBUF: 1980 case SO_SNDLOWAT: 1981 case SO_RCVLOWAT: 1982 error = sooptcopyin(sopt, &optval, sizeof optval, 1983 sizeof optval); 1984 if (error) 1985 goto bad; 1986 1987 /* 1988 * Values < 1 make no sense for any of these 1989 * options, so disallow them. 1990 */ 1991 if (optval < 1) { 1992 error = EINVAL; 1993 goto bad; 1994 } 1995 1996 switch (sopt->sopt_name) { 1997 case SO_SNDBUF: 1998 case SO_RCVBUF: 1999 if (ssb_reserve(sopt->sopt_name == SO_SNDBUF ? 2000 &so->so_snd : &so->so_rcv, (u_long)optval, 2001 so, 2002 &curproc->p_rlimit[RLIMIT_SBSIZE]) == 0) { 2003 error = ENOBUFS; 2004 goto bad; 2005 } 2006 sotmp = (sopt->sopt_name == SO_SNDBUF) ? 2007 &so->so_snd : &so->so_rcv; 2008 atomic_clear_int(&sotmp->ssb_flags, 2009 SSB_AUTOSIZE); 2010 break; 2011 2012 /* 2013 * Make sure the low-water is never greater than 2014 * the high-water. 2015 */ 2016 case SO_SNDLOWAT: 2017 so->so_snd.ssb_lowat = 2018 (optval > so->so_snd.ssb_hiwat) ? 2019 so->so_snd.ssb_hiwat : optval; 2020 atomic_clear_int(&so->so_snd.ssb_flags, 2021 SSB_AUTOLOWAT); 2022 break; 2023 case SO_RCVLOWAT: 2024 so->so_rcv.ssb_lowat = 2025 (optval > so->so_rcv.ssb_hiwat) ? 2026 so->so_rcv.ssb_hiwat : optval; 2027 atomic_clear_int(&so->so_rcv.ssb_flags, 2028 SSB_AUTOLOWAT); 2029 break; 2030 } 2031 break; 2032 2033 case SO_SNDTIMEO: 2034 case SO_RCVTIMEO: 2035 error = sooptcopyin(sopt, &tv, sizeof tv, 2036 sizeof tv); 2037 if (error) 2038 goto bad; 2039 2040 /* assert(hz > 0); */ 2041 if (tv.tv_sec < 0 || tv.tv_sec > INT_MAX / hz || 2042 tv.tv_usec < 0 || tv.tv_usec >= 1000000) { 2043 error = EDOM; 2044 goto bad; 2045 } 2046 /* assert(tick > 0); */ 2047 /* assert(ULONG_MAX - INT_MAX >= 1000000); */ 2048 val = (u_long)(tv.tv_sec * hz) + tv.tv_usec / ustick; 2049 if (val > INT_MAX) { 2050 error = EDOM; 2051 goto bad; 2052 } 2053 if (val == 0 && tv.tv_usec != 0) 2054 val = 1; 2055 2056 switch (sopt->sopt_name) { 2057 case SO_SNDTIMEO: 2058 so->so_snd.ssb_timeo = val; 2059 break; 2060 case SO_RCVTIMEO: 2061 so->so_rcv.ssb_timeo = val; 2062 break; 2063 } 2064 break; 2065 default: 2066 error = ENOPROTOOPT; 2067 break; 2068 } 2069 if (error == 0 && so->so_proto && so->so_proto->pr_ctloutput) { 2070 (void) so_pr_ctloutput(so, sopt); 2071 } 2072 } 2073 bad: 2074 return (error); 2075 } 2076 2077 /* Helper routine for getsockopt */ 2078 int 2079 sooptcopyout(struct sockopt *sopt, const void *buf, size_t len) 2080 { 2081 soopt_from_kbuf(sopt, buf, len); 2082 return 0; 2083 } 2084 2085 void 2086 soopt_from_kbuf(struct sockopt *sopt, const void *buf, size_t len) 2087 { 2088 size_t valsize; 2089 2090 if (len == 0) { 2091 sopt->sopt_valsize = 0; 2092 return; 2093 } 2094 2095 KKASSERT(!sopt->sopt_val || kva_p(sopt->sopt_val)); 2096 KKASSERT(kva_p(buf)); 2097 2098 /* 2099 * Documented get behavior is that we always return a value, 2100 * possibly truncated to fit in the user's buffer. 2101 * Traditional behavior is that we always tell the user 2102 * precisely how much we copied, rather than something useful 2103 * like the total amount we had available for her. 2104 * Note that this interface is not idempotent; the entire answer must 2105 * generated ahead of time. 2106 */ 2107 valsize = szmin(len, sopt->sopt_valsize); 2108 sopt->sopt_valsize = valsize; 2109 if (sopt->sopt_val != 0) { 2110 bcopy(buf, sopt->sopt_val, valsize); 2111 } 2112 } 2113 2114 int 2115 sogetopt(struct socket *so, struct sockopt *sopt) 2116 { 2117 int error, optval; 2118 long optval_l; 2119 struct linger l; 2120 struct timeval tv; 2121 #ifdef INET 2122 struct accept_filter_arg *afap; 2123 #endif 2124 2125 error = 0; 2126 sopt->sopt_dir = SOPT_GET; 2127 if (sopt->sopt_level != SOL_SOCKET) { 2128 if (so->so_proto && so->so_proto->pr_ctloutput) { 2129 return (so_pr_ctloutput(so, sopt)); 2130 } else 2131 return (ENOPROTOOPT); 2132 } else { 2133 switch (sopt->sopt_name) { 2134 #ifdef INET 2135 case SO_ACCEPTFILTER: 2136 if ((so->so_options & SO_ACCEPTCONN) == 0) 2137 return (EINVAL); 2138 afap = kmalloc(sizeof(*afap), M_TEMP, 2139 M_WAITOK | M_ZERO); 2140 if ((so->so_options & SO_ACCEPTFILTER) != 0) { 2141 strcpy(afap->af_name, so->so_accf->so_accept_filter->accf_name); 2142 if (so->so_accf->so_accept_filter_str != NULL) 2143 strcpy(afap->af_arg, so->so_accf->so_accept_filter_str); 2144 } 2145 error = sooptcopyout(sopt, afap, sizeof(*afap)); 2146 kfree(afap, M_TEMP); 2147 break; 2148 #endif /* INET */ 2149 2150 case SO_LINGER: 2151 l.l_onoff = so->so_options & SO_LINGER; 2152 l.l_linger = so->so_linger; 2153 error = sooptcopyout(sopt, &l, sizeof l); 2154 break; 2155 2156 case SO_USELOOPBACK: 2157 case SO_DONTROUTE: 2158 case SO_DEBUG: 2159 case SO_KEEPALIVE: 2160 case SO_REUSEADDR: 2161 case SO_REUSEPORT: 2162 case SO_BROADCAST: 2163 case SO_OOBINLINE: 2164 case SO_TIMESTAMP: 2165 optval = so->so_options & sopt->sopt_name; 2166 integer: 2167 error = sooptcopyout(sopt, &optval, sizeof optval); 2168 break; 2169 2170 case SO_TYPE: 2171 optval = so->so_type; 2172 goto integer; 2173 2174 case SO_ERROR: 2175 optval = so->so_error; 2176 so->so_error = 0; 2177 goto integer; 2178 2179 case SO_SNDBUF: 2180 optval = so->so_snd.ssb_hiwat; 2181 goto integer; 2182 2183 case SO_RCVBUF: 2184 optval = so->so_rcv.ssb_hiwat; 2185 goto integer; 2186 2187 case SO_SNDLOWAT: 2188 optval = so->so_snd.ssb_lowat; 2189 goto integer; 2190 2191 case SO_RCVLOWAT: 2192 optval = so->so_rcv.ssb_lowat; 2193 goto integer; 2194 2195 case SO_SNDTIMEO: 2196 case SO_RCVTIMEO: 2197 optval = (sopt->sopt_name == SO_SNDTIMEO ? 2198 so->so_snd.ssb_timeo : so->so_rcv.ssb_timeo); 2199 2200 tv.tv_sec = optval / hz; 2201 tv.tv_usec = (optval % hz) * ustick; 2202 error = sooptcopyout(sopt, &tv, sizeof tv); 2203 break; 2204 2205 case SO_SNDSPACE: 2206 optval_l = ssb_space(&so->so_snd); 2207 error = sooptcopyout(sopt, &optval_l, sizeof(optval_l)); 2208 break; 2209 2210 default: 2211 error = ENOPROTOOPT; 2212 break; 2213 } 2214 return (error); 2215 } 2216 } 2217 2218 /* XXX; prepare mbuf for (__FreeBSD__ < 3) routines. */ 2219 int 2220 soopt_getm(struct sockopt *sopt, struct mbuf **mp) 2221 { 2222 struct mbuf *m, *m_prev; 2223 int sopt_size = sopt->sopt_valsize, msize; 2224 2225 m = m_getl(sopt_size, sopt->sopt_td ? MB_WAIT : MB_DONTWAIT, MT_DATA, 2226 0, &msize); 2227 if (m == NULL) 2228 return (ENOBUFS); 2229 m->m_len = min(msize, sopt_size); 2230 sopt_size -= m->m_len; 2231 *mp = m; 2232 m_prev = m; 2233 2234 while (sopt_size > 0) { 2235 m = m_getl(sopt_size, sopt->sopt_td ? MB_WAIT : MB_DONTWAIT, 2236 MT_DATA, 0, &msize); 2237 if (m == NULL) { 2238 m_freem(*mp); 2239 return (ENOBUFS); 2240 } 2241 m->m_len = min(msize, sopt_size); 2242 sopt_size -= m->m_len; 2243 m_prev->m_next = m; 2244 m_prev = m; 2245 } 2246 return (0); 2247 } 2248 2249 /* XXX; copyin sopt data into mbuf chain for (__FreeBSD__ < 3) routines. */ 2250 int 2251 soopt_mcopyin(struct sockopt *sopt, struct mbuf *m) 2252 { 2253 soopt_to_mbuf(sopt, m); 2254 return 0; 2255 } 2256 2257 void 2258 soopt_to_mbuf(struct sockopt *sopt, struct mbuf *m) 2259 { 2260 size_t valsize; 2261 void *val; 2262 2263 KKASSERT(!sopt->sopt_val || kva_p(sopt->sopt_val)); 2264 KKASSERT(kva_p(m)); 2265 if (sopt->sopt_val == NULL) 2266 return; 2267 val = sopt->sopt_val; 2268 valsize = sopt->sopt_valsize; 2269 while (m != NULL && valsize >= m->m_len) { 2270 bcopy(val, mtod(m, char *), m->m_len); 2271 valsize -= m->m_len; 2272 val = (caddr_t)val + m->m_len; 2273 m = m->m_next; 2274 } 2275 if (m != NULL) /* should be allocated enoughly at ip6_sooptmcopyin() */ 2276 panic("ip6_sooptmcopyin"); 2277 } 2278 2279 /* XXX; copyout mbuf chain data into soopt for (__FreeBSD__ < 3) routines. */ 2280 int 2281 soopt_mcopyout(struct sockopt *sopt, struct mbuf *m) 2282 { 2283 return soopt_from_mbuf(sopt, m); 2284 } 2285 2286 int 2287 soopt_from_mbuf(struct sockopt *sopt, struct mbuf *m) 2288 { 2289 struct mbuf *m0 = m; 2290 size_t valsize = 0; 2291 size_t maxsize; 2292 void *val; 2293 2294 KKASSERT(!sopt->sopt_val || kva_p(sopt->sopt_val)); 2295 KKASSERT(kva_p(m)); 2296 if (sopt->sopt_val == NULL) 2297 return 0; 2298 val = sopt->sopt_val; 2299 maxsize = sopt->sopt_valsize; 2300 while (m != NULL && maxsize >= m->m_len) { 2301 bcopy(mtod(m, char *), val, m->m_len); 2302 maxsize -= m->m_len; 2303 val = (caddr_t)val + m->m_len; 2304 valsize += m->m_len; 2305 m = m->m_next; 2306 } 2307 if (m != NULL) { 2308 /* enough soopt buffer should be given from user-land */ 2309 m_freem(m0); 2310 return (EINVAL); 2311 } 2312 sopt->sopt_valsize = valsize; 2313 return 0; 2314 } 2315 2316 void 2317 sohasoutofband(struct socket *so) 2318 { 2319 if (so->so_sigio != NULL) 2320 pgsigio(so->so_sigio, SIGURG, 0); 2321 KNOTE(&so->so_rcv.ssb_kq.ki_note, NOTE_OOB); 2322 } 2323 2324 int 2325 sokqfilter(struct file *fp, struct knote *kn) 2326 { 2327 struct socket *so = (struct socket *)kn->kn_fp->f_data; 2328 struct signalsockbuf *ssb; 2329 2330 switch (kn->kn_filter) { 2331 case EVFILT_READ: 2332 if (so->so_options & SO_ACCEPTCONN) 2333 kn->kn_fop = &solisten_filtops; 2334 else 2335 kn->kn_fop = &soread_filtops; 2336 ssb = &so->so_rcv; 2337 break; 2338 case EVFILT_WRITE: 2339 kn->kn_fop = &sowrite_filtops; 2340 ssb = &so->so_snd; 2341 break; 2342 case EVFILT_EXCEPT: 2343 kn->kn_fop = &soexcept_filtops; 2344 ssb = &so->so_rcv; 2345 break; 2346 default: 2347 return (EOPNOTSUPP); 2348 } 2349 2350 knote_insert(&ssb->ssb_kq.ki_note, kn); 2351 atomic_set_int(&ssb->ssb_flags, SSB_KNOTE); 2352 return (0); 2353 } 2354 2355 static void 2356 filt_sordetach(struct knote *kn) 2357 { 2358 struct socket *so = (struct socket *)kn->kn_fp->f_data; 2359 2360 knote_remove(&so->so_rcv.ssb_kq.ki_note, kn); 2361 if (SLIST_EMPTY(&so->so_rcv.ssb_kq.ki_note)) 2362 atomic_clear_int(&so->so_rcv.ssb_flags, SSB_KNOTE); 2363 } 2364 2365 /*ARGSUSED*/ 2366 static int 2367 filt_soread(struct knote *kn, long hint) 2368 { 2369 struct socket *so = (struct socket *)kn->kn_fp->f_data; 2370 2371 if (kn->kn_sfflags & NOTE_OOB) { 2372 if ((so->so_oobmark || (so->so_state & SS_RCVATMARK))) { 2373 kn->kn_fflags |= NOTE_OOB; 2374 return (1); 2375 } 2376 return (0); 2377 } 2378 kn->kn_data = so->so_rcv.ssb_cc; 2379 2380 if (so->so_state & SS_CANTRCVMORE) { 2381 /* 2382 * Only set NODATA if all data has been exhausted. 2383 */ 2384 if (kn->kn_data == 0) 2385 kn->kn_flags |= EV_NODATA; 2386 kn->kn_flags |= EV_EOF; 2387 kn->kn_fflags = so->so_error; 2388 return (1); 2389 } 2390 if (so->so_error) /* temporary udp error */ 2391 return (1); 2392 if (kn->kn_sfflags & NOTE_LOWAT) 2393 return (kn->kn_data >= kn->kn_sdata); 2394 return ((kn->kn_data >= so->so_rcv.ssb_lowat) || 2395 !TAILQ_EMPTY(&so->so_comp)); 2396 } 2397 2398 static void 2399 filt_sowdetach(struct knote *kn) 2400 { 2401 struct socket *so = (struct socket *)kn->kn_fp->f_data; 2402 2403 knote_remove(&so->so_snd.ssb_kq.ki_note, kn); 2404 if (SLIST_EMPTY(&so->so_snd.ssb_kq.ki_note)) 2405 atomic_clear_int(&so->so_snd.ssb_flags, SSB_KNOTE); 2406 } 2407 2408 /*ARGSUSED*/ 2409 static int 2410 filt_sowrite(struct knote *kn, long hint) 2411 { 2412 struct socket *so = (struct socket *)kn->kn_fp->f_data; 2413 2414 kn->kn_data = ssb_space(&so->so_snd); 2415 if (so->so_state & SS_CANTSENDMORE) { 2416 kn->kn_flags |= (EV_EOF | EV_NODATA); 2417 kn->kn_fflags = so->so_error; 2418 return (1); 2419 } 2420 if (so->so_error) /* temporary udp error */ 2421 return (1); 2422 if (((so->so_state & SS_ISCONNECTED) == 0) && 2423 (so->so_proto->pr_flags & PR_CONNREQUIRED)) 2424 return (0); 2425 if (kn->kn_sfflags & NOTE_LOWAT) 2426 return (kn->kn_data >= kn->kn_sdata); 2427 return (kn->kn_data >= so->so_snd.ssb_lowat); 2428 } 2429 2430 /*ARGSUSED*/ 2431 static int 2432 filt_solisten(struct knote *kn, long hint) 2433 { 2434 struct socket *so = (struct socket *)kn->kn_fp->f_data; 2435 2436 kn->kn_data = so->so_qlen; 2437 return (! TAILQ_EMPTY(&so->so_comp)); 2438 } 2439