sys/kern/uipc_socket.c

   1 /*
   2  * Copyright (c) 1982, 1986, 1988, 1990, 1993
   3  *      The Regents of the University of California.  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 the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  *      @(#)uipc_socket.c       8.3 (Berkeley) 4/15/94
  34  * $FreeBSD$
  35  */
  36
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/fcntl.h>
  40 #include <sys/malloc.h>
  41 #include <sys/mbuf.h>
  42 #include <sys/domain.h>
  43 #include <sys/kernel.h>
  44 #include <sys/malloc.h>
  45 #include <sys/poll.h>
  46 #include <sys/proc.h>
  47 #include <sys/protosw.h>
  48 #include <sys/socket.h>
  49 #include <sys/socketvar.h>
  50 #include <sys/resourcevar.h>
  51 #include <sys/signalvar.h>
  52 #include <sys/sysctl.h>
  53 #include <sys/uio.h>
  54 #include <vm/vm_zone.h>
  55
  56 #include <machine/limits.h>
  57
  58 struct  vm_zone *socket_zone;
  59 so_gen_t        so_gencnt;      /* generation count for sockets */
  60
  61 MALLOC_DEFINE(M_SONAME, "soname", "socket name");
  62 MALLOC_DEFINE(M_PCB, "pcb", "protocol control block");
  63
  64 SYSCTL_DECL(_kern_ipc);
  65
  66 static int somaxconn = SOMAXCONN;
  67 SYSCTL_INT(_kern_ipc, KIPC_SOMAXCONN, somaxconn, CTLFLAG_RW,
  68     &somaxconn, 0, "Maximum pending socket connection queue size");
  69
  70 /*
  71  * Socket operation routines.
  72  * These routines are called by the routines in
  73  * sys_socket.c or from a system process, and
  74  * implement the semantics of socket operations by
  75  * switching out to the protocol specific routines.
  76  */
  77
  78 /*
  79  * Get a socket structure from our zone, and initialize it.
  80  * We don't implement `waitok' yet (see comments in uipc_domain.c).
  81  * Note that it would probably be better to allocate socket
  82  * and PCB at the same time, but I'm not convinced that all
  83  * the protocols can be easily modified to do this.
  84  */
  85 struct socket *
  86 soalloc(waitok)
  87         int waitok;
  88 {
  89         struct socket *so;
  90
  91         so = zalloci(socket_zone);
  92         if (so) {
  93                 /* XXX race condition for reentrant kernel */
  94                 bzero(so, sizeof *so);
  95                 so->so_gencnt = ++so_gencnt;
  96                 so->so_zone = socket_zone;
  97         }
  98         return so;
  99 }
 100
 101 int
 102 socreate(dom, aso, type, proto, p)
 103         int dom;
 104         struct socket **aso;
 105         register int type;
 106         int proto;
 107         struct proc *p;
 108 {
 109         register struct protosw *prp;
 110         register struct socket *so;
 111         register int error;
 112
 113         if (proto)
 114                 prp = pffindproto(dom, proto, type);
 115         else
 116                 prp = pffindtype(dom, type);
 117         if (prp == 0 || prp->pr_usrreqs->pru_attach == 0)
 118                 return (EPROTONOSUPPORT);
 119         if (prp->pr_type != type)
 120                 return (EPROTOTYPE);
 121         so = soalloc(p != 0);
 122         if (so == 0)
 123                 return (ENOBUFS);
 124
 125         TAILQ_INIT(&so->so_incomp);
 126         TAILQ_INIT(&so->so_comp);
 127         so->so_type = type;
 128         so->so_cred = p->p_ucred;
 129         crhold(so->so_cred);
 130         so->so_proto = prp;
 131         error = (*prp->pr_usrreqs->pru_attach)(so, proto, p);
 132         if (error) {
 133                 so->so_state |= SS_NOFDREF;
 134                 sofree(so);
 135                 return (error);
 136         }
 137         *aso = so;
 138         return (0);
 139 }
 140
 141 int
 142 sobind(so, nam, p)
 143         struct socket *so;
 144         struct sockaddr *nam;
 145         struct proc *p;
 146 {
 147         int s = splnet();
 148         int error;
 149
 150         error = (*so->so_proto->pr_usrreqs->pru_bind)(so, nam, p);
 151         splx(s);
 152         return (error);
 153 }
 154
 155 void
 156 sodealloc(so)
 157         struct socket *so;
 158 {
 159
 160         so->so_gencnt = ++so_gencnt;
 161         crfree(so->so_cred);
 162         zfreei(so->so_zone, so);
 163 }
 164
 165 int
 166 solisten(so, backlog, p)
 167         register struct socket *so;
 168         int backlog;
 169         struct proc *p;
 170 {
 171         int s, error;
 172
 173         s = splnet();
 174         error = (*so->so_proto->pr_usrreqs->pru_listen)(so, p);
 175         if (error) {
 176                 splx(s);
 177                 return (error);
 178         }
 179         if (so->so_comp.tqh_first == NULL)
 180                 so->so_options |= SO_ACCEPTCONN;
 181         if (backlog < 0 || backlog > somaxconn)
 182                 backlog = somaxconn;
 183         so->so_qlimit = backlog;
 184         splx(s);
 185         return (0);
 186 }
 187
 188 void
 189 sofree(so)
 190         register struct socket *so;
 191 {
 192         struct socket *head = so->so_head;
 193
 194         if (so->so_pcb || (so->so_state & SS_NOFDREF) == 0)
 195                 return;
 196         if (head != NULL) {
 197                 if (so->so_state & SS_INCOMP) {
 198                         TAILQ_REMOVE(&head->so_incomp, so, so_list);
 199                         head->so_incqlen--;
 200                 } else if (so->so_state & SS_COMP) {
 201                         /*
 202                          * We must not decommission a socket that's
 203                          * on the accept(2) queue.  If we do, then
 204                          * accept(2) may hang after select(2) indicated
 205                          * that the listening socket was ready.
 206                          */
 207                         return;
 208                 } else {
 209                         panic("sofree: not queued");
 210                 }
 211                 head->so_qlen--;
 212                 so->so_state &= ~SS_INCOMP;
 213                 so->so_head = NULL;
 214         }
 215         sbrelease(&so->so_snd);
 216         sorflush(so);
 217         sodealloc(so);
 218 }
 219
 220 /*
 221  * Close a socket on last file table reference removal.
 222  * Initiate disconnect if connected.
 223  * Free socket when disconnect complete.
 224  */
 225 int
 226 soclose(so)
 227         register struct socket *so;
 228 {
 229         int s = splnet();               /* conservative */
 230         int error = 0;
 231
 232         funsetown(so->so_sigio);
 233         if (so->so_options & SO_ACCEPTCONN) {
 234                 struct socket *sp, *sonext;
 235
 236                 for (sp = so->so_incomp.tqh_first; sp != NULL; sp = sonext) {
 237                         sonext = sp->so_list.tqe_next;
 238                         (void) soabort(sp);
 239                 }
 240                 for (sp = so->so_comp.tqh_first; sp != NULL; sp = sonext) {
 241                         sonext = sp->so_list.tqe_next;
 242                         /* Dequeue from so_comp since sofree() won't do it */
 243                         TAILQ_REMOVE(&so->so_comp, sp, so_list);
 244                         so->so_qlen--;
 245                         sp->so_state &= ~SS_COMP;
 246                         sp->so_head = NULL;
 247                         (void) soabort(sp);
 248                 }
 249         }
 250         if (so->so_pcb == 0)
 251                 goto discard;
 252         if (so->so_state & SS_ISCONNECTED) {
 253                 if ((so->so_state & SS_ISDISCONNECTING) == 0) {
 254                         error = sodisconnect(so);
 255                         if (error)
 256                                 goto drop;
 257                 }
 258                 if (so->so_options & SO_LINGER) {
 259                         if ((so->so_state & SS_ISDISCONNECTING) &&
 260                             (so->so_state & SS_NBIO))
 261                                 goto drop;
 262                         while (so->so_state & SS_ISCONNECTED) {
 263                                 error = tsleep((caddr_t)&so->so_timeo,
 264                                     PSOCK | PCATCH, "soclos", so->so_linger * hz);
 265                                 if (error)
 266                                         break;
 267                         }
 268                 }
 269         }
 270 drop:
 271         if (so->so_pcb) {
 272                 int error2 = (*so->so_proto->pr_usrreqs->pru_detach)(so);
 273                 if (error == 0)
 274                         error = error2;
 275         }
 276 discard:
 277         if (so->so_state & SS_NOFDREF)
 278                 panic("soclose: NOFDREF");
 279         so->so_state |= SS_NOFDREF;
 280         sofree(so);
 281         splx(s);
 282         return (error);
 283 }
 284
 285 /*
 286  * Must be called at splnet...
 287  */
 288 int
 289 soabort(so)
 290         struct socket *so;
 291 {
 292
 293         return (*so->so_proto->pr_usrreqs->pru_abort)(so);
 294 }
 295
 296 int
 297 soaccept(so, nam)
 298         register struct socket *so;
 299         struct sockaddr **nam;
 300 {
 301         int s = splnet();
 302         int error;
 303
 304         if ((so->so_state & SS_NOFDREF) == 0)
 305                 panic("soaccept: !NOFDREF");
 306         so->so_state &= ~SS_NOFDREF;
 307         if ((so->so_state & SS_ISDISCONNECTED) == 0)
 308                 error = (*so->so_proto->pr_usrreqs->pru_accept)(so, nam);
 309         else {
 310                 if (nam)
 311                         *nam = 0;
 312                 error = 0;
 313         }
 314         splx(s);
 315         return (error);
 316 }
 317
 318 int
 319 soconnect(so, nam, p)
 320         register struct socket *so;
 321         struct sockaddr *nam;
 322         struct proc *p;
 323 {
 324         int s;
 325         int error;
 326
 327         if (so->so_options & SO_ACCEPTCONN)
 328                 return (EOPNOTSUPP);
 329         s = splnet();
 330         /*
 331          * If protocol is connection-based, can only connect once.
 332          * Otherwise, if connected, try to disconnect first.
 333          * This allows user to disconnect by connecting to, e.g.,
 334          * a null address.
 335          */
 336         if (so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING) &&
 337             ((so->so_proto->pr_flags & PR_CONNREQUIRED) ||
 338             (error = sodisconnect(so))))
 339                 error = EISCONN;
 340         else
 341                 error = (*so->so_proto->pr_usrreqs->pru_connect)(so, nam, p);
 342         splx(s);
 343         return (error);
 344 }
 345
 346 int
 347 soconnect2(so1, so2)
 348         register struct socket *so1;
 349         struct socket *so2;
 350 {
 351         int s = splnet();
 352         int error;
 353
 354         error = (*so1->so_proto->pr_usrreqs->pru_connect2)(so1, so2);
 355         splx(s);
 356         return (error);
 357 }
 358
 359 int
 360 sodisconnect(so)
 361         register struct socket *so;
 362 {
 363         int s = splnet();
 364         int error;
 365
 366         if ((so->so_state & SS_ISCONNECTED) == 0) {
 367                 error = ENOTCONN;
 368                 goto bad;
 369         }
 370         if (so->so_state & SS_ISDISCONNECTING) {
 371                 error = EALREADY;
 372                 goto bad;
 373         }
 374         error = (*so->so_proto->pr_usrreqs->pru_disconnect)(so);
 375 bad:
 376         splx(s);
 377         return (error);
 378 }
 379
 380 #define SBLOCKWAIT(f)   (((f) & MSG_DONTWAIT) ? M_NOWAIT : M_WAITOK)
 381 /*
 382  * Send on a socket.
 383  * If send must go all at once and message is larger than
 384  * send buffering, then hard error.
 385  * Lock against other senders.
 386  * If must go all at once and not enough room now, then
 387  * inform user that this would block and do nothing.
 388  * Otherwise, if nonblocking, send as much as possible.
 389  * The data to be sent is described by "uio" if nonzero,
 390  * otherwise by the mbuf chain "top" (which must be null
 391  * if uio is not).  Data provided in mbuf chain must be small
 392  * enough to send all at once.
 393  *
 394  * Returns nonzero on error, timeout or signal; callers
 395  * must check for short counts if EINTR/ERESTART are returned.
 396  * Data and control buffers are freed on return.
 397  */
 398 int
 399 sosend(so, addr, uio, top, control, flags, p)
 400         register struct socket *so;
 401         struct sockaddr *addr;
 402         struct uio *uio;
 403         struct mbuf *top;
 404         struct mbuf *control;
 405         int flags;
 406         struct proc *p;
 407 {
 408         struct mbuf **mp;
 409         register struct mbuf *m;
 410         register long space, len, resid;
 411         int clen = 0, error, s, dontroute, mlen;
 412         int atomic = sosendallatonce(so) || top;
 413
 414         if (uio)
 415                 resid = uio->uio_resid;
 416         else
 417                 resid = top->m_pkthdr.len;
 418         /*
 419          * In theory resid should be unsigned.
 420          * However, space must be signed, as it might be less than 0
 421          * if we over-committed, and we must use a signed comparison
 422          * of space and resid.  On the other hand, a negative resid
 423          * causes us to loop sending 0-length segments to the protocol.
 424          *
 425          * Also check to make sure that MSG_EOR isn't used on SOCK_STREAM
 426          * type sockets since that's an error.
 427          */
 428         if (resid < 0 || (so->so_type == SOCK_STREAM && (flags & MSG_EOR))) {
 429                 error = EINVAL;
 430                 goto out;
 431         }
 432
 433         dontroute =
 434             (flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 &&
 435             (so->so_proto->pr_flags & PR_ATOMIC);
 436         if (p)
 437                 p->p_stats->p_ru.ru_msgsnd++;
 438         if (control)
 439                 clen = control->m_len;
 440 #define snderr(errno)   { error = errno; splx(s); goto release; }
 441
 442 restart:
 443         error = sblock(&so->so_snd, SBLOCKWAIT(flags));
 444         if (error)
 445                 goto out;
 446         do {
 447                 s = splnet();
 448                 if (so->so_state & SS_CANTSENDMORE)
 449                         snderr(EPIPE);
 450                 if (so->so_error) {
 451                         error = so->so_error;
 452                         so->so_error = 0;
 453                         splx(s);
 454                         goto release;
 455                 }
 456                 if ((so->so_state & SS_ISCONNECTED) == 0) {
 457                         /*
 458                          * `sendto' and `sendmsg' is allowed on a connection-
 459                          * based socket if it supports implied connect.
 460                          * Return ENOTCONN if not connected and no address is
 461                          * supplied.
 462                          */
 463                         if ((so->so_proto->pr_flags & PR_CONNREQUIRED) &&
 464                             (so->so_proto->pr_flags & PR_IMPLOPCL) == 0) {
 465                                 if ((so->so_state & SS_ISCONFIRMING) == 0 &&
 466                                     !(resid == 0 && clen != 0))
 467                                         snderr(ENOTCONN);
 468                         } else if (addr == 0)
 469                             snderr(so->so_proto->pr_flags & PR_CONNREQUIRED ?
 470                                    ENOTCONN : EDESTADDRREQ);
 471                 }
 472                 space = sbspace(&so->so_snd);
 473                 if (flags & MSG_OOB)
 474                         space += 1024;
 475                 if ((atomic && resid > so->so_snd.sb_hiwat) ||
 476                     clen > so->so_snd.sb_hiwat)
 477                         snderr(EMSGSIZE);
 478                 if (space < resid + clen && uio &&
 479                     (atomic || space < so->so_snd.sb_lowat || space < clen)) {
 480                         if (so->so_state & SS_NBIO)
 481                                 snderr(EWOULDBLOCK);
 482                         sbunlock(&so->so_snd);
 483                         error = sbwait(&so->so_snd);
 484                         splx(s);
 485                         if (error)
 486                                 goto out;
 487                         goto restart;
 488                 }
 489                 splx(s);
 490                 mp = &top;
 491                 space -= clen;
 492                 do {
 493                     if (uio == NULL) {
 494                         /*
 495                          * Data is prepackaged in "top".
 496                          */
 497                         resid = 0;
 498                         if (flags & MSG_EOR)
 499                                 top->m_flags |= M_EOR;
 500                     } else do {
 501                         if (top == 0) {
 502                                 MGETHDR(m, M_WAIT, MT_DATA);
 503                                 mlen = MHLEN;
 504                                 m->m_pkthdr.len = 0;
 505                                 m->m_pkthdr.rcvif = (struct ifnet *)0;
 506                         } else {
 507                                 MGET(m, M_WAIT, MT_DATA);
 508                                 mlen = MLEN;
 509                         }
 510                         if (resid >= MINCLSIZE) {
 511                                 MCLGET(m, M_WAIT);
 512                                 if ((m->m_flags & M_EXT) == 0)
 513                                         goto nopages;
 514                                 mlen = MCLBYTES;
 515                                 len = min(min(mlen, resid), space);
 516                         } else {
 517 nopages:
 518                                 len = min(min(mlen, resid), space);
 519                                 /*
 520                                  * For datagram protocols, leave room
 521                                  * for protocol headers in first mbuf.
 522                                  */
 523                                 if (atomic && top == 0 && len < mlen)
 524                                         MH_ALIGN(m, len);
 525                         }
 526                         space -= len;
 527                         error = uiomove(mtod(m, caddr_t), (int)len, uio);
 528                         resid = uio->uio_resid;
 529                         m->m_len = len;
 530                         *mp = m;
 531                         top->m_pkthdr.len += len;
 532                         if (error)
 533                                 goto release;
 534                         mp = &m->m_next;
 535                         if (resid <= 0) {
 536                                 if (flags & MSG_EOR)
 537                                         top->m_flags |= M_EOR;
 538                                 break;
 539                         }
 540                     } while (space > 0 && atomic);
 541                     if (dontroute)
 542                             so->so_options |= SO_DONTROUTE;
 543                     s = splnet();                               /* XXX */
 544                     /*
 545                      * XXX all the SS_CANTSENDMORE checks previously
 546                      * done could be out of date.  We could have recieved
 547                      * a reset packet in an interrupt or maybe we slept
 548                      * while doing page faults in uiomove() etc. We could
 549                      * probably recheck again inside the splnet() protection
 550                      * here, but there are probably other places that this
 551                      * also happens.  We must rethink this.
 552                      */
 553                     error = (*so->so_proto->pr_usrreqs->pru_send)(so,
 554                         (flags & MSG_OOB) ? PRUS_OOB :
 555                         /*
 556                          * If the user set MSG_EOF, the protocol
 557                          * understands this flag and nothing left to
 558                          * send then use PRU_SEND_EOF instead of PRU_SEND.
 559                          */
 560                         ((flags & MSG_EOF) &&
 561                          (so->so_proto->pr_flags & PR_IMPLOPCL) &&
 562                          (resid <= 0)) ?
 563                                 PRUS_EOF :
 564                         /* If there is more to send set PRUS_MORETOCOME */
 565                         (resid > 0 && space > 0) ? PRUS_MORETOCOME : 0,
 566                         top, addr, control, p);
 567                     splx(s);
 568                     if (dontroute)
 569                             so->so_options &= ~SO_DONTROUTE;
 570                     clen = 0;
 571                     control = 0;
 572                     top = 0;
 573                     mp = &top;
 574                     if (error)
 575                         goto release;
 576                 } while (resid && space > 0);
 577         } while (resid);
 578
 579 release:
 580         sbunlock(&so->so_snd);
 581 out:
 582         if (top)
 583                 m_freem(top);
 584         if (control)
 585                 m_freem(control);
 586         return (error);
 587 }
 588
 589 /*
 590  * Implement receive operations on a socket.
 591  * We depend on the way that records are added to the sockbuf
 592  * by sbappend*.  In particular, each record (mbufs linked through m_next)
 593  * must begin with an address if the protocol so specifies,
 594  * followed by an optional mbuf or mbufs containing ancillary data,
 595  * and then zero or more mbufs of data.
 596  * In order to avoid blocking network interrupts for the entire time here,
 597  * we splx() while doing the actual copy to user space.
 598  * Although the sockbuf is locked, new data may still be appended,
 599  * and thus we must maintain consistency of the sockbuf during that time.
 600  *
 601  * The caller may receive the data as a single mbuf chain by supplying
 602  * an mbuf **mp0 for use in returning the chain.  The uio is then used
 603  * only for the count in uio_resid.
 604  */
 605 int
 606 soreceive(so, psa, uio, mp0, controlp, flagsp)
 607         register struct socket *so;
 608         struct sockaddr **psa;
 609         struct uio *uio;
 610         struct mbuf **mp0;
 611         struct mbuf **controlp;
 612         int *flagsp;
 613 {
 614         register struct mbuf *m, **mp;
 615         register int flags, len, error, s, offset;
 616         struct protosw *pr = so->so_proto;
 617         struct mbuf *nextrecord;
 618         int moff, type = 0;
 619         int orig_resid = uio->uio_resid;
 620
 621         mp = mp0;
 622         if (psa)
 623                 *psa = 0;
 624         if (controlp)
 625                 *controlp = 0;
 626         if (flagsp)
 627                 flags = *flagsp &~ MSG_EOR;
 628         else
 629                 flags = 0;
 630         if (flags & MSG_OOB) {
 631                 m = m_get(M_WAIT, MT_DATA);
 632                 error = (*pr->pr_usrreqs->pru_rcvoob)(so, m, flags & MSG_PEEK);
 633                 if (error)
 634                         goto bad;
 635                 do {
 636                         error = uiomove(mtod(m, caddr_t),
 637                             (int) min(uio->uio_resid, m->m_len), uio);
 638                         m = m_free(m);
 639                 } while (uio->uio_resid && error == 0 && m);
 640 bad:
 641                 if (m)
 642                         m_freem(m);
 643                 return (error);
 644         }
 645         if (mp)
 646                 *mp = (struct mbuf *)0;
 647         if (so->so_state & SS_ISCONFIRMING && uio->uio_resid)
 648                 (*pr->pr_usrreqs->pru_rcvd)(so, 0);
 649
 650 restart:
 651         error = sblock(&so->so_rcv, SBLOCKWAIT(flags));
 652         if (error)
 653                 return (error);
 654         s = splnet();
 655
 656         m = so->so_rcv.sb_mb;
 657         /*
 658          * If we have less data than requested, block awaiting more
 659          * (subject to any timeout) if:
 660          *   1. the current count is less than the low water mark, or
 661          *   2. MSG_WAITALL is set, and it is possible to do the entire
 662          *      receive operation at once if we block (resid <= hiwat).
 663          *   3. MSG_DONTWAIT is not set
 664          * If MSG_WAITALL is set but resid is larger than the receive buffer,
 665          * we have to do the receive in sections, and thus risk returning
 666          * a short count if a timeout or signal occurs after we start.
 667          */
 668         if (m == 0 || (((flags & MSG_DONTWAIT) == 0 &&
 669             so->so_rcv.sb_cc < uio->uio_resid) &&
 670             (so->so_rcv.sb_cc < so->so_rcv.sb_lowat ||
 671             ((flags & MSG_WAITALL) && uio->uio_resid <= so->so_rcv.sb_hiwat)) &&
 672             m->m_nextpkt == 0 && (pr->pr_flags & PR_ATOMIC) == 0)) {
 673                 KASSERT(m != 0 || !so->so_rcv.sb_cc, ("receive 1"));
 674                 if (so->so_error) {
 675                         if (m)
 676                                 goto dontblock;
 677                         error = so->so_error;
 678                         if ((flags & MSG_PEEK) == 0)
 679                                 so->so_error = 0;
 680                         goto release;
 681                 }
 682                 if (so->so_state & SS_CANTRCVMORE) {
 683                         if (m)
 684                                 goto dontblock;
 685                         else
 686                                 goto release;
 687                 }
 688                 for (; m; m = m->m_next)
 689                         if (m->m_type == MT_OOBDATA  || (m->m_flags & M_EOR)) {
 690                                 m = so->so_rcv.sb_mb;
 691                                 goto dontblock;
 692                         }
 693                 if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) == 0 &&
 694                     (so->so_proto->pr_flags & PR_CONNREQUIRED)) {
 695                         error = ENOTCONN;
 696                         goto release;
 697                 }
 698                 if (uio->uio_resid == 0)
 699                         goto release;
 700                 if ((so->so_state & SS_NBIO) || (flags & MSG_DONTWAIT)) {
 701                         error = EWOULDBLOCK;
 702                         goto release;
 703                 }
 704                 sbunlock(&so->so_rcv);
 705                 error = sbwait(&so->so_rcv);
 706                 splx(s);
 707                 if (error)
 708                         return (error);
 709                 goto restart;
 710         }
 711 dontblock:
 712         if (uio->uio_procp)
 713                 uio->uio_procp->p_stats->p_ru.ru_msgrcv++;
 714         nextrecord = m->m_nextpkt;
 715         if (pr->pr_flags & PR_ADDR) {
 716                 KASSERT(m->m_type == MT_SONAME, ("receive 1a"));
 717                 orig_resid = 0;
 718                 if (psa)
 719                         *psa = dup_sockaddr(mtod(m, struct sockaddr *),
 720                                             mp0 == 0);
 721                 if (flags & MSG_PEEK) {
 722                         m = m->m_next;
 723                 } else {
 724                         sbfree(&so->so_rcv, m);
 725                         MFREE(m, so->so_rcv.sb_mb);
 726                         m = so->so_rcv.sb_mb;
 727                 }
 728         }
 729         while (m && m->m_type == MT_CONTROL && error == 0) {
 730                 if (flags & MSG_PEEK) {
 731                         if (controlp)
 732                                 *controlp = m_copy(m, 0, m->m_len);
 733                         m = m->m_next;
 734                 } else {
 735                         sbfree(&so->so_rcv, m);
 736                         if (controlp) {
 737                                 if (pr->pr_domain->dom_externalize &&
 738                                     mtod(m, struct cmsghdr *)->cmsg_type ==
 739                                     SCM_RIGHTS)
 740                                    error = (*pr->pr_domain->dom_externalize)(m);
 741                                 *controlp = m;
 742                                 so->so_rcv.sb_mb = m->m_next;
 743                                 m->m_next = 0;
 744                                 m = so->so_rcv.sb_mb;
 745                         } else {
 746                                 MFREE(m, so->so_rcv.sb_mb);
 747                                 m = so->so_rcv.sb_mb;
 748                         }
 749                 }
 750                 if (controlp) {
 751                         orig_resid = 0;
 752                         controlp = &(*controlp)->m_next;
 753                 }
 754         }
 755         if (m) {
 756                 if ((flags & MSG_PEEK) == 0)
 757                         m->m_nextpkt = nextrecord;
 758                 type = m->m_type;
 759                 if (type == MT_OOBDATA)
 760                         flags |= MSG_OOB;
 761         }
 762         moff = 0;
 763         offset = 0;
 764         while (m && uio->uio_resid > 0 && error == 0) {
 765                 if (m->m_type == MT_OOBDATA) {
 766                         if (type != MT_OOBDATA)
 767                                 break;
 768                 } else if (type == MT_OOBDATA)
 769                         break;
 770                 else
 771                     KASSERT(m->m_type == MT_DATA || m->m_type == MT_HEADER,
 772                         ("receive 3"));
 773                 so->so_state &= ~SS_RCVATMARK;
 774                 len = uio->uio_resid;
 775                 if (so->so_oobmark && len > so->so_oobmark - offset)
 776                         len = so->so_oobmark - offset;
 777                 if (len > m->m_len - moff)
 778                         len = m->m_len - moff;
 779                 /*
 780                  * If mp is set, just pass back the mbufs.
 781                  * Otherwise copy them out via the uio, then free.
 782                  * Sockbuf must be consistent here (points to current mbuf,
 783                  * it points to next record) when we drop priority;
 784                  * we must note any additions to the sockbuf when we
 785                  * block interrupts again.
 786                  */
 787                 if (mp == 0) {
 788                         splx(s);
 789                         error = uiomove(mtod(m, caddr_t) + moff, (int)len, uio);
 790                         s = splnet();
 791                         if (error)
 792                                 goto release;
 793                 } else
 794                         uio->uio_resid -= len;
 795                 if (len == m->m_len - moff) {
 796                         if (m->m_flags & M_EOR)
 797                                 flags |= MSG_EOR;
 798                         if (flags & MSG_PEEK) {
 799                                 m = m->m_next;
 800                                 moff = 0;
 801                         } else {
 802                                 nextrecord = m->m_nextpkt;
 803                                 sbfree(&so->so_rcv, m);
 804                                 if (mp) {
 805                                         *mp = m;
 806                                         mp = &m->m_next;
 807                                         so->so_rcv.sb_mb = m = m->m_next;
 808                                         *mp = (struct mbuf *)0;
 809                                 } else {
 810                                         MFREE(m, so->so_rcv.sb_mb);
 811                                         m = so->so_rcv.sb_mb;
 812                                 }
 813                                 if (m)
 814                                         m->m_nextpkt = nextrecord;
 815                         }
 816                 } else {
 817                         if (flags & MSG_PEEK)
 818                                 moff += len;
 819                         else {
 820                                 if (mp)
 821                                         *mp = m_copym(m, 0, len, M_WAIT);
 822                                 m->m_data += len;
 823                                 m->m_len -= len;
 824                                 so->so_rcv.sb_cc -= len;
 825                         }
 826                 }
 827                 if (so->so_oobmark) {
 828                         if ((flags & MSG_PEEK) == 0) {
 829                                 so->so_oobmark -= len;
 830                                 if (so->so_oobmark == 0) {
 831                                         so->so_state |= SS_RCVATMARK;
 832                                         break;
 833                                 }
 834                         } else {
 835                                 offset += len;
 836                                 if (offset == so->so_oobmark)
 837                                         break;
 838                         }
 839                 }
 840                 if (flags & MSG_EOR)
 841                         break;
 842                 /*
 843                  * If the MSG_WAITALL flag is set (for non-atomic socket),
 844                  * we must not quit until "uio->uio_resid == 0" or an error
 845                  * termination.  If a signal/timeout occurs, return
 846                  * with a short count but without error.
 847                  * Keep sockbuf locked against other readers.
 848                  */
 849                 while (flags & MSG_WAITALL && m == 0 && uio->uio_resid > 0 &&
 850                     !sosendallatonce(so) && !nextrecord) {
 851                         if (so->so_error || so->so_state & SS_CANTRCVMORE)
 852                                 break;
 853                         error = sbwait(&so->so_rcv);
 854                         if (error) {
 855                                 sbunlock(&so->so_rcv);
 856                                 splx(s);
 857                                 return (0);
 858                         }
 859                         m = so->so_rcv.sb_mb;
 860                         if (m)
 861                                 nextrecord = m->m_nextpkt;
 862                 }
 863         }
 864
 865         if (m && pr->pr_flags & PR_ATOMIC) {
 866                 flags |= MSG_TRUNC;
 867                 if ((flags & MSG_PEEK) == 0)
 868                         (void) sbdroprecord(&so->so_rcv);
 869         }
 870         if ((flags & MSG_PEEK) == 0) {
 871                 if (m == 0)
 872                         so->so_rcv.sb_mb = nextrecord;
 873                 if (pr->pr_flags & PR_WANTRCVD && so->so_pcb)
 874                         (*pr->pr_usrreqs->pru_rcvd)(so, flags);
 875         }
 876         if (orig_resid == uio->uio_resid && orig_resid &&
 877             (flags & MSG_EOR) == 0 && (so->so_state & SS_CANTRCVMORE) == 0) {
 878                 sbunlock(&so->so_rcv);
 879                 splx(s);
 880                 goto restart;
 881         }
 882
 883         if (flagsp)
 884                 *flagsp |= flags;
 885 release:
 886         sbunlock(&so->so_rcv);
 887         splx(s);
 888         return (error);
 889 }
 890
 891 int
 892 soshutdown(so, how)
 893         register struct socket *so;
 894         register int how;
 895 {
 896         register struct protosw *pr = so->so_proto;
 897
 898         how++;
 899         if (how & FREAD)
 900                 sorflush(so);
 901         if (how & FWRITE)
 902                 return ((*pr->pr_usrreqs->pru_shutdown)(so));
 903         return (0);
 904 }
 905
 906 void
 907 sorflush(so)
 908         register struct socket *so;
 909 {
 910         register struct sockbuf *sb = &so->so_rcv;
 911         register struct protosw *pr = so->so_proto;
 912         register int s;
 913         struct sockbuf asb;
 914
 915         sb->sb_flags |= SB_NOINTR;
 916         (void) sblock(sb, M_WAITOK);
 917         s = splimp();
 918         socantrcvmore(so);
 919         sbunlock(sb);
 920         asb = *sb;
 921         bzero((caddr_t)sb, sizeof (*sb));
 922         splx(s);
 923         if (pr->pr_flags & PR_RIGHTS && pr->pr_domain->dom_dispose)
 924                 (*pr->pr_domain->dom_dispose)(asb.sb_mb);
 925         sbrelease(&asb);
 926 }
 927
 928 /*
 929  * Perhaps this routine, and sooptcopyout(), below, ought to come in
 930  * an additional variant to handle the case where the option value needs
 931  * to be some kind of integer, but not a specific size.
 932  * In addition to their use here, these functions are also called by the
 933  * protocol-level pr_ctloutput() routines.
 934  */
 935 int
 936 sooptcopyin(sopt, buf, len, minlen)
 937         struct  sockopt *sopt;
 938         void    *buf;
 939         size_t  len;
 940         size_t  minlen;
 941 {
 942         size_t  valsize;
 943
 944         /*
 945          * If the user gives us more than we wanted, we ignore it,
 946          * but if we don't get the minimum length the caller
 947          * wants, we return EINVAL.  On success, sopt->sopt_valsize
 948          * is set to however much we actually retrieved.
 949          */
 950         if ((valsize = sopt->sopt_valsize) < minlen)
 951                 return EINVAL;
 952         if (valsize > len)
 953                 sopt->sopt_valsize = valsize = len;
 954
 955         if (sopt->sopt_p != 0)
 956                 return (copyin(sopt->sopt_val, buf, valsize));
 957
 958         bcopy(sopt->sopt_val, buf, valsize);
 959         return 0;
 960 }
 961
 962 int
 963 sosetopt(so, sopt)
 964         struct socket *so;
 965         struct sockopt *sopt;
 966 {
 967         int     error, optval;
 968         struct  linger l;
 969         struct  timeval tv;
 970         u_long  val;
 971
 972         error = 0;
 973         if (sopt->sopt_level != SOL_SOCKET) {
 974                 if (so->so_proto && so->so_proto->pr_ctloutput)
 975                         return ((*so->so_proto->pr_ctloutput)
 976                                   (so, sopt));
 977                 error = ENOPROTOOPT;
 978         } else {
 979                 switch (sopt->sopt_name) {
 980                 case SO_LINGER:
 981                         error = sooptcopyin(sopt, &l, sizeof l, sizeof l);
 982                         if (error)
 983                                 goto bad;
 984
 985                         so->so_linger = l.l_linger;
 986                         if (l.l_onoff)
 987                                 so->so_options |= SO_LINGER;
 988                         else
 989                                 so->so_options &= ~SO_LINGER;
 990                         break;
 991
 992                 case SO_DEBUG:
 993                 case SO_KEEPALIVE:
 994                 case SO_DONTROUTE:
 995                 case SO_USELOOPBACK:
 996                 case SO_BROADCAST:
 997                 case SO_REUSEADDR:
 998                 case SO_REUSEPORT:
 999                 case SO_OOBINLINE:
1000                 case SO_TIMESTAMP:
1001                         error = sooptcopyin(sopt, &optval, sizeof optval,
1002                                             sizeof optval);
1003                         if (error)
1004                                 goto bad;
1005                         if (optval)
1006                                 so->so_options |= sopt->sopt_name;
1007                         else
1008                                 so->so_options &= ~sopt->sopt_name;
1009                         break;
1010
1011                 case SO_SNDBUF:
1012                 case SO_RCVBUF:
1013                 case SO_SNDLOWAT:
1014                 case SO_RCVLOWAT:
1015                         error = sooptcopyin(sopt, &optval, sizeof optval,
1016                                             sizeof optval);
1017                         if (error)
1018                                 goto bad;
1019
1020                         /*
1021                          * Values < 1 make no sense for any of these
1022                          * options, so disallow them.
1023                          */
1024                         if (optval < 1) {
1025                                 error = EINVAL;
1026                                 goto bad;
1027                         }
1028
1029                         switch (sopt->sopt_name) {
1030                         case SO_SNDBUF:
1031                         case SO_RCVBUF:
1032                                 if (sbreserve(sopt->sopt_name == SO_SNDBUF ?
1033                                               &so->so_snd : &so->so_rcv,
1034                                               (u_long) optval) == 0) {
1035                                         error = ENOBUFS;
1036                                         goto bad;
1037                                 }
1038                                 break;
1039
1040                         /*
1041                          * Make sure the low-water is never greater than
1042                          * the high-water.
1043                          */
1044                         case SO_SNDLOWAT:
1045                                 so->so_snd.sb_lowat =
1046                                     (optval > so->so_snd.sb_hiwat) ?
1047                                     so->so_snd.sb_hiwat : optval;
1048                                 break;
1049                         case SO_RCVLOWAT:
1050                                 so->so_rcv.sb_lowat =
1051                                     (optval > so->so_rcv.sb_hiwat) ?
1052                                     so->so_rcv.sb_hiwat : optval;
1053                                 break;
1054                         }
1055                         break;
1056
1057                 case SO_SNDTIMEO:
1058                 case SO_RCVTIMEO:
1059                         error = sooptcopyin(sopt, &tv, sizeof tv,
1060                                             sizeof tv);
1061                         if (error)
1062                                 goto bad;
1063
1064                         /* assert(hz > 0); */
1065                         if (tv.tv_sec < 0 || tv.tv_sec > SHRT_MAX / hz ||
1066                             tv.tv_usec < 0 || tv.tv_usec >= 1000000) {
1067                                 error = EDOM;
1068                                 goto bad;
1069                         }
1070                         /* assert(tick > 0); */
1071                         /* assert(ULONG_MAX - SHRT_MAX >= 1000000); */
1072                         val = (u_long)(tv.tv_sec * hz) + tv.tv_usec / tick;
1073                         if (val > SHRT_MAX) {
1074                                 error = EDOM;
1075                                 goto bad;
1076                         }
1077
1078                         switch (sopt->sopt_name) {
1079                         case SO_SNDTIMEO:
1080                                 so->so_snd.sb_timeo = val;
1081                                 break;
1082                         case SO_RCVTIMEO:
1083                                 so->so_rcv.sb_timeo = val;
1084                                 break;
1085                         }
1086                         break;
1087
1088                 default:
1089                         error = ENOPROTOOPT;
1090                         break;
1091                 }
1092                 if (error == 0 && so->so_proto && so->so_proto->pr_ctloutput) {
1093                         (void) ((*so->so_proto->pr_ctloutput)
1094                                   (so, sopt));
1095                 }
1096         }
1097 bad:
1098         return (error);
1099 }
1100
1101 /* Helper routine for getsockopt */
1102 int
1103 sooptcopyout(sopt, buf, len)
1104         struct  sockopt *sopt;
1105         void    *buf;
1106         size_t  len;
1107 {
1108         int     error;
1109         size_t  valsize;
1110
1111         error = 0;
1112
1113         /*
1114          * Documented get behavior is that we always return a value,
1115          * possibly truncated to fit in the user's buffer.
1116          * Traditional behavior is that we always tell the user
1117          * precisely how much we copied, rather than something useful
1118          * like the total amount we had available for her.
1119          * Note that this interface is not idempotent; the entire answer must
1120          * generated ahead of time.
1121          */
1122         valsize = min(len, sopt->sopt_valsize);
1123         sopt->sopt_valsize = valsize;
1124         if (sopt->sopt_val != 0) {
1125                 if (sopt->sopt_p != 0)
1126                         error = copyout(buf, sopt->sopt_val, valsize);
1127                 else
1128                         bcopy(buf, sopt->sopt_val, valsize);
1129         }
1130         return error;
1131 }
1132
1133 int
1134 sogetopt(so, sopt)
1135         struct socket *so;
1136         struct sockopt *sopt;
1137 {
1138         int     error, optval;
1139         struct  linger l;
1140         struct  timeval tv;
1141
1142         error = 0;
1143         if (sopt->sopt_level != SOL_SOCKET) {
1144                 if (so->so_proto && so->so_proto->pr_ctloutput) {
1145                         return ((*so->so_proto->pr_ctloutput)
1146                                   (so, sopt));
1147                 } else
1148                         return (ENOPROTOOPT);
1149         } else {
1150                 switch (sopt->sopt_name) {
1151                 case SO_LINGER:
1152                         l.l_onoff = so->so_options & SO_LINGER;
1153                         l.l_linger = so->so_linger;
1154                         error = sooptcopyout(sopt, &l, sizeof l);
1155                         break;
1156
1157                 case SO_USELOOPBACK:
1158                 case SO_DONTROUTE:
1159                 case SO_DEBUG:
1160                 case SO_KEEPALIVE:
1161                 case SO_REUSEADDR:
1162                 case SO_REUSEPORT:
1163                 case SO_BROADCAST:
1164                 case SO_OOBINLINE:
1165                 case SO_TIMESTAMP:
1166                         optval = so->so_options & sopt->sopt_name;
1167 integer:
1168                         error = sooptcopyout(sopt, &optval, sizeof optval);
1169                         break;
1170
1171                 case SO_TYPE:
1172                         optval = so->so_type;
1173                         goto integer;
1174
1175                 case SO_ERROR:
1176                         optval = so->so_error;
1177                         so->so_error = 0;
1178                         goto integer;
1179
1180                 case SO_SNDBUF:
1181                         optval = so->so_snd.sb_hiwat;
1182                         goto integer;
1183
1184                 case SO_RCVBUF:
1185                         optval = so->so_rcv.sb_hiwat;
1186                         goto integer;
1187
1188                 case SO_SNDLOWAT:
1189                         optval = so->so_snd.sb_lowat;
1190                         goto integer;
1191
1192                 case SO_RCVLOWAT:
1193                         optval = so->so_rcv.sb_lowat;
1194                         goto integer;
1195
1196                 case SO_SNDTIMEO:
1197                 case SO_RCVTIMEO:
1198                         optval = (sopt->sopt_name == SO_SNDTIMEO ?
1199                                   so->so_snd.sb_timeo : so->so_rcv.sb_timeo);
1200
1201                         tv.tv_sec = optval / hz;
1202                         tv.tv_usec = (optval % hz) * tick;
1203                         error = sooptcopyout(sopt, &tv, sizeof tv);
1204                         break;
1205
1206                 default:
1207                         error = ENOPROTOOPT;
1208                         break;
1209                 }
1210                 return (error);
1211         }
1212 }
1213
1214 void
1215 sohasoutofband(so)
1216         register struct socket *so;
1217 {
1218         if (so->so_sigio != NULL)
1219                 pgsigio(so->so_sigio, SIGURG, 0);
1220         selwakeup(&so->so_rcv.sb_sel);
1221 }
1222
1223 int
1224 sopoll(struct socket *so, int events, struct ucred *cred, struct proc *p)
1225 {
1226         int revents = 0;
1227         int s = splnet();
1228
1229         if (events & (POLLIN | POLLRDNORM))
1230                 if (soreadable(so))
1231                         revents |= events & (POLLIN | POLLRDNORM);
1232
1233         if (events & (POLLOUT | POLLWRNORM))
1234                 if (sowriteable(so))
1235                         revents |= events & (POLLOUT | POLLWRNORM);
1236
1237         if (events & (POLLPRI | POLLRDBAND))
1238                 if (so->so_oobmark || (so->so_state & SS_RCVATMARK))
1239                         revents |= events & (POLLPRI | POLLRDBAND);
1240
1241         if (revents == 0) {
1242                 if (events & (POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND)) {
1243                         selrecord(p, &so->so_rcv.sb_sel);
1244                         so->so_rcv.sb_flags |= SB_SEL;
1245                 }
1246
1247                 if (events & (POLLOUT | POLLWRNORM)) {
1248                         selrecord(p, &so->so_snd.sb_sel);
1249                         so->so_snd.sb_flags |= SB_SEL;
1250                 }
1251         }
1252
1253         splx(s);
1254         return (revents);
1255 }