sys/kern/uipc_syscalls.c

   1 /*-
   2  * Copyright (c) 1982, 1986, 1989, 1990, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * sendfile(2) and related extensions:
   6  * Copyright (c) 1998, David Greenman. All rights reserved.
   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  * 4. Neither the name of the University nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  *      @(#)uipc_syscalls.c     8.4 (Berkeley) 2/21/94
  33  */
  34
  35 #include <sys/cdefs.h>
  36 __FBSDID("$FreeBSD$");
  37
  38 #include "opt_capsicum.h"
  39 #include "opt_inet.h"
  40 #include "opt_inet6.h"
  41 #include "opt_sctp.h"
  42 #include "opt_compat.h"
  43 #include "opt_ktrace.h"
  44
  45 #include <sys/param.h>
  46 #include <sys/systm.h>
  47 #include <sys/capability.h>
  48 #include <sys/kernel.h>
  49 #include <sys/lock.h>
  50 #include <sys/mutex.h>
  51 #include <sys/sysproto.h>
  52 #include <sys/malloc.h>
  53 #include <sys/filedesc.h>
  54 #include <sys/event.h>
  55 #include <sys/proc.h>
  56 #include <sys/fcntl.h>
  57 #include <sys/file.h>
  58 #include <sys/filio.h>
  59 #include <sys/jail.h>
  60 #include <sys/mount.h>
  61 #include <sys/mbuf.h>
  62 #include <sys/protosw.h>
  63 #include <sys/sf_buf.h>
  64 #include <sys/sysent.h>
  65 #include <sys/socket.h>
  66 #include <sys/socketvar.h>
  67 #include <sys/signalvar.h>
  68 #include <sys/syscallsubr.h>
  69 #include <sys/sysctl.h>
  70 #include <sys/uio.h>
  71 #include <sys/vnode.h>
  72 #ifdef KTRACE
  73 #include <sys/ktrace.h>
  74 #endif
  75 #ifdef COMPAT_FREEBSD32
  76 #include <compat/freebsd32/freebsd32_util.h>
  77 #endif
  78
  79 #include <net/vnet.h>
  80
  81 #include <security/audit/audit.h>
  82 #include <security/mac/mac_framework.h>
  83
  84 #include <vm/vm.h>
  85 #include <vm/vm_param.h>
  86 #include <vm/vm_object.h>
  87 #include <vm/vm_page.h>
  88 #include <vm/vm_pageout.h>
  89 #include <vm/vm_kern.h>
  90 #include <vm/vm_extern.h>
  91
  92 #if defined(INET) || defined(INET6)
  93 #ifdef SCTP
  94 #include <netinet/sctp.h>
  95 #include <netinet/sctp_peeloff.h>
  96 #endif /* SCTP */
  97 #endif /* INET || INET6 */
  98
  99 static int sendit(struct thread *td, int s, struct msghdr *mp, int flags);
 100 static int recvit(struct thread *td, int s, struct msghdr *mp, void *namelenp);
 101
 102 static int accept1(struct thread *td, struct accept_args *uap, int compat);
 103 static int do_sendfile(struct thread *td, struct sendfile_args *uap, int compat);
 104 static int getsockname1(struct thread *td, struct getsockname_args *uap,
 105                         int compat);
 106 static int getpeername1(struct thread *td, struct getpeername_args *uap,
 107                         int compat);
 108
 109 /*
 110  * NSFBUFS-related variables and associated sysctls
 111  */
 112 int nsfbufs;
 113 int nsfbufspeak;
 114 int nsfbufsused;
 115
 116 SYSCTL_INT(_kern_ipc, OID_AUTO, nsfbufs, CTLFLAG_RDTUN, &nsfbufs, 0,
 117     "Maximum number of sendfile(2) sf_bufs available");
 118 SYSCTL_INT(_kern_ipc, OID_AUTO, nsfbufspeak, CTLFLAG_RD, &nsfbufspeak, 0,
 119     "Number of sendfile(2) sf_bufs at peak usage");
 120 SYSCTL_INT(_kern_ipc, OID_AUTO, nsfbufsused, CTLFLAG_RD, &nsfbufsused, 0,
 121     "Number of sendfile(2) sf_bufs in use");
 122
 123 /*
 124  * Convert a user file descriptor to a kernel file entry and check that, if
 125  * it is a capability, the right rights are present. A reference on the file
 126  * entry is held upon returning.
 127  */
 128 static int
 129 getsock_cap(struct filedesc *fdp, int fd, cap_rights_t rights,
 130     struct file **fpp, u_int *fflagp)
 131 {
 132         struct file *fp;
 133 #ifdef CAPABILITIES
 134         struct file *fp_fromcap;
 135         int error;
 136 #endif
 137
 138         if (fdp == NULL || (fp = fget_unlocked(fdp, fd)) == NULL)
 139                 return (EBADF);
 140 #ifdef CAPABILITIES
 141         /*
 142          * If the file descriptor is for a capability, test rights and use
 143          * the file descriptor referenced by the capability.
 144          */
 145         error = cap_funwrap(fp, rights, &fp_fromcap);
 146         if (error) {
 147                 fdrop(fp, curthread);
 148                 return (error);
 149         }
 150         if (fp != fp_fromcap) {
 151                 fhold(fp_fromcap);
 152                 fdrop(fp, curthread);
 153                 fp = fp_fromcap;
 154         }
 155 #endif /* CAPABILITIES */
 156         if (fp->f_type != DTYPE_SOCKET) {
 157                 fdrop(fp, curthread);
 158                 return (ENOTSOCK);
 159         }
 160         if (fflagp != NULL)
 161                 *fflagp = fp->f_flag;
 162         *fpp = fp;
 163         return (0);
 164 }
 165
 166 /*
 167  * System call interface to the socket abstraction.
 168  */
 169 #if defined(COMPAT_43)
 170 #define COMPAT_OLDSOCK
 171 #endif
 172
 173 int
 174 sys_socket(td, uap)
 175         struct thread *td;
 176         struct socket_args /* {
 177                 int     domain;
 178                 int     type;
 179                 int     protocol;
 180         } */ *uap;
 181 {
 182         struct socket *so;
 183         struct file *fp;
 184         int fd, error;
 185
 186         AUDIT_ARG_SOCKET(uap->domain, uap->type, uap->protocol);
 187 #ifdef MAC
 188         error = mac_socket_check_create(td->td_ucred, uap->domain, uap->type,
 189             uap->protocol);
 190         if (error)
 191                 return (error);
 192 #endif
 193         error = falloc(td, &fp, &fd, 0);
 194         if (error)
 195                 return (error);
 196         /* An extra reference on `fp' has been held for us by falloc(). */
 197         error = socreate(uap->domain, &so, uap->type, uap->protocol,
 198             td->td_ucred, td);
 199         if (error) {
 200                 fdclose(td->td_proc->p_fd, fp, fd, td);
 201         } else {
 202                 finit(fp, FREAD | FWRITE, DTYPE_SOCKET, so, &socketops);
 203                 td->td_retval[0] = fd;
 204         }
 205         fdrop(fp, td);
 206         return (error);
 207 }
 208
 209 /* ARGSUSED */
 210 int
 211 sys_bind(td, uap)
 212         struct thread *td;
 213         struct bind_args /* {
 214                 int     s;
 215                 caddr_t name;
 216                 int     namelen;
 217         } */ *uap;
 218 {
 219         struct sockaddr *sa;
 220         int error;
 221
 222         if ((error = getsockaddr(&sa, uap->name, uap->namelen)) != 0)
 223                 return (error);
 224
 225         error = kern_bind(td, uap->s, sa);
 226         free(sa, M_SONAME);
 227         return (error);
 228 }
 229
 230 int
 231 kern_bind(td, fd, sa)
 232         struct thread *td;
 233         int fd;
 234         struct sockaddr *sa;
 235 {
 236         struct socket *so;
 237         struct file *fp;
 238         int error;
 239
 240         AUDIT_ARG_FD(fd);
 241         error = getsock_cap(td->td_proc->p_fd, fd, CAP_BIND, &fp, NULL);
 242         if (error)
 243                 return (error);
 244         so = fp->f_data;
 245 #ifdef KTRACE
 246         if (KTRPOINT(td, KTR_STRUCT))
 247                 ktrsockaddr(sa);
 248 #endif
 249 #ifdef MAC
 250         error = mac_socket_check_bind(td->td_ucred, so, sa);
 251         if (error == 0)
 252 #endif
 253                 error = sobind(so, sa, td);
 254         fdrop(fp, td);
 255         return (error);
 256 }
 257
 258 /* ARGSUSED */
 259 int
 260 sys_listen(td, uap)
 261         struct thread *td;
 262         struct listen_args /* {
 263                 int     s;
 264                 int     backlog;
 265         } */ *uap;
 266 {
 267         struct socket *so;
 268         struct file *fp;
 269         int error;
 270
 271         AUDIT_ARG_FD(uap->s);
 272         error = getsock_cap(td->td_proc->p_fd, uap->s, CAP_LISTEN, &fp, NULL);
 273         if (error == 0) {
 274                 so = fp->f_data;
 275 #ifdef MAC
 276                 error = mac_socket_check_listen(td->td_ucred, so);
 277                 if (error == 0)
 278 #endif
 279                         error = solisten(so, uap->backlog, td);
 280                 fdrop(fp, td);
 281         }
 282         return(error);
 283 }
 284
 285 /*
 286  * accept1()
 287  */
 288 static int
 289 accept1(td, uap, compat)
 290         struct thread *td;
 291         struct accept_args /* {
 292                 int     s;
 293                 struct sockaddr * __restrict name;
 294                 socklen_t       * __restrict anamelen;
 295         } */ *uap;
 296         int compat;
 297 {
 298         struct sockaddr *name;
 299         socklen_t namelen;
 300         struct file *fp;
 301         int error;
 302
 303         if (uap->name == NULL)
 304                 return (kern_accept(td, uap->s, NULL, NULL, NULL));
 305
 306         error = copyin(uap->anamelen, &namelen, sizeof (namelen));
 307         if (error)
 308                 return (error);
 309
 310         error = kern_accept(td, uap->s, &name, &namelen, &fp);
 311
 312         /*
 313          * return a namelen of zero for older code which might
 314          * ignore the return value from accept.
 315          */
 316         if (error) {
 317                 (void) copyout(&namelen,
 318                     uap->anamelen, sizeof(*uap->anamelen));
 319                 return (error);
 320         }
 321
 322         if (error == 0 && name != NULL) {
 323 #ifdef COMPAT_OLDSOCK
 324                 if (compat)
 325                         ((struct osockaddr *)name)->sa_family =
 326                             name->sa_family;
 327 #endif
 328                 error = copyout(name, uap->name, namelen);
 329         }
 330         if (error == 0)
 331                 error = copyout(&namelen, uap->anamelen,
 332                     sizeof(namelen));
 333         if (error)
 334                 fdclose(td->td_proc->p_fd, fp, td->td_retval[0], td);
 335         fdrop(fp, td);
 336         free(name, M_SONAME);
 337         return (error);
 338 }
 339
 340 int
 341 kern_accept(struct thread *td, int s, struct sockaddr **name,
 342     socklen_t *namelen, struct file **fp)
 343 {
 344         struct filedesc *fdp;
 345         struct file *headfp, *nfp = NULL;
 346         struct sockaddr *sa = NULL;
 347         int error;
 348         struct socket *head, *so;
 349         int fd;
 350         u_int fflag;
 351         pid_t pgid;
 352         int tmp;
 353
 354         if (name) {
 355                 *name = NULL;
 356                 if (*namelen < 0)
 357                         return (EINVAL);
 358         }
 359
 360         AUDIT_ARG_FD(s);
 361         fdp = td->td_proc->p_fd;
 362         error = getsock_cap(fdp, s, CAP_ACCEPT, &headfp, &fflag);
 363         if (error)
 364                 return (error);
 365         head = headfp->f_data;
 366         if ((head->so_options & SO_ACCEPTCONN) == 0) {
 367                 error = EINVAL;
 368                 goto done;
 369         }
 370 #ifdef MAC
 371         error = mac_socket_check_accept(td->td_ucred, head);
 372         if (error != 0)
 373                 goto done;
 374 #endif
 375         error = falloc(td, &nfp, &fd, 0);
 376         if (error)
 377                 goto done;
 378         ACCEPT_LOCK();
 379         if ((head->so_state & SS_NBIO) && TAILQ_EMPTY(&head->so_comp)) {
 380                 ACCEPT_UNLOCK();
 381                 error = EWOULDBLOCK;
 382                 goto noconnection;
 383         }
 384         while (TAILQ_EMPTY(&head->so_comp) && head->so_error == 0) {
 385                 if (head->so_rcv.sb_state & SBS_CANTRCVMORE) {
 386                         head->so_error = ECONNABORTED;
 387                         break;
 388                 }
 389                 error = msleep(&head->so_timeo, &accept_mtx, PSOCK | PCATCH,
 390                     "accept", 0);
 391                 if (error) {
 392                         ACCEPT_UNLOCK();
 393                         goto noconnection;
 394                 }
 395         }
 396         if (head->so_error) {
 397                 error = head->so_error;
 398                 head->so_error = 0;
 399                 ACCEPT_UNLOCK();
 400                 goto noconnection;
 401         }
 402         so = TAILQ_FIRST(&head->so_comp);
 403         KASSERT(!(so->so_qstate & SQ_INCOMP), ("accept1: so SQ_INCOMP"));
 404         KASSERT(so->so_qstate & SQ_COMP, ("accept1: so not SQ_COMP"));
 405
 406         /*
 407          * Before changing the flags on the socket, we have to bump the
 408          * reference count.  Otherwise, if the protocol calls sofree(),
 409          * the socket will be released due to a zero refcount.
 410          */
 411         SOCK_LOCK(so);                  /* soref() and so_state update */
 412         soref(so);                      /* file descriptor reference */
 413
 414         TAILQ_REMOVE(&head->so_comp, so, so_list);
 415         head->so_qlen--;
 416         so->so_state |= (head->so_state & SS_NBIO);
 417         so->so_qstate &= ~SQ_COMP;
 418         so->so_head = NULL;
 419
 420         SOCK_UNLOCK(so);
 421         ACCEPT_UNLOCK();
 422
 423         /* An extra reference on `nfp' has been held for us by falloc(). */
 424         td->td_retval[0] = fd;
 425
 426         /* connection has been removed from the listen queue */
 427         KNOTE_UNLOCKED(&head->so_rcv.sb_sel.si_note, 0);
 428
 429         pgid = fgetown(&head->so_sigio);
 430         if (pgid != 0)
 431                 fsetown(pgid, &so->so_sigio);
 432
 433         finit(nfp, fflag, DTYPE_SOCKET, so, &socketops);
 434         /* Sync socket nonblocking/async state with file flags */
 435         tmp = fflag & FNONBLOCK;
 436         (void) fo_ioctl(nfp, FIONBIO, &tmp, td->td_ucred, td);
 437         tmp = fflag & FASYNC;
 438         (void) fo_ioctl(nfp, FIOASYNC, &tmp, td->td_ucred, td);
 439         sa = 0;
 440         error = soaccept(so, &sa);
 441         if (error) {
 442                 /*
 443                  * return a namelen of zero for older code which might
 444                  * ignore the return value from accept.
 445                  */
 446                 if (name)
 447                         *namelen = 0;
 448                 goto noconnection;
 449         }
 450         if (sa == NULL) {
 451                 if (name)
 452                         *namelen = 0;
 453                 goto done;
 454         }
 455         if (name) {
 456                 /* check sa_len before it is destroyed */
 457                 if (*namelen > sa->sa_len)
 458                         *namelen = sa->sa_len;
 459 #ifdef KTRACE
 460                 if (KTRPOINT(td, KTR_STRUCT))
 461                         ktrsockaddr(sa);
 462 #endif
 463                 *name = sa;
 464                 sa = NULL;
 465         }
 466 noconnection:
 467         if (sa)
 468                 free(sa, M_SONAME);
 469
 470         /*
 471          * close the new descriptor, assuming someone hasn't ripped it
 472          * out from under us.
 473          */
 474         if (error)
 475                 fdclose(fdp, nfp, fd, td);
 476
 477         /*
 478          * Release explicitly held references before returning.  We return
 479          * a reference on nfp to the caller on success if they request it.
 480          */
 481 done:
 482         if (fp != NULL) {
 483                 if (error == 0) {
 484                         *fp = nfp;
 485                         nfp = NULL;
 486                 } else
 487                         *fp = NULL;
 488         }
 489         if (nfp != NULL)
 490                 fdrop(nfp, td);
 491         fdrop(headfp, td);
 492         return (error);
 493 }
 494
 495 int
 496 sys_accept(td, uap)
 497         struct thread *td;
 498         struct accept_args *uap;
 499 {
 500
 501         return (accept1(td, uap, 0));
 502 }
 503
 504 #ifdef COMPAT_OLDSOCK
 505 int
 506 oaccept(td, uap)
 507         struct thread *td;
 508         struct accept_args *uap;
 509 {
 510
 511         return (accept1(td, uap, 1));
 512 }
 513 #endif /* COMPAT_OLDSOCK */
 514
 515 /* ARGSUSED */
 516 int
 517 sys_connect(td, uap)
 518         struct thread *td;
 519         struct connect_args /* {
 520                 int     s;
 521                 caddr_t name;
 522                 int     namelen;
 523         } */ *uap;
 524 {
 525         struct sockaddr *sa;
 526         int error;
 527
 528         error = getsockaddr(&sa, uap->name, uap->namelen);
 529         if (error)
 530                 return (error);
 531
 532         error = kern_connect(td, uap->s, sa);
 533         free(sa, M_SONAME);
 534         return (error);
 535 }
 536
 537
 538 int
 539 kern_connect(td, fd, sa)
 540         struct thread *td;
 541         int fd;
 542         struct sockaddr *sa;
 543 {
 544         struct socket *so;
 545         struct file *fp;
 546         int error;
 547         int interrupted = 0;
 548
 549         AUDIT_ARG_FD(fd);
 550         error = getsock_cap(td->td_proc->p_fd, fd, CAP_CONNECT, &fp, NULL);
 551         if (error)
 552                 return (error);
 553         so = fp->f_data;
 554         if (so->so_state & SS_ISCONNECTING) {
 555                 error = EALREADY;
 556                 goto done1;
 557         }
 558 #ifdef KTRACE
 559         if (KTRPOINT(td, KTR_STRUCT))
 560                 ktrsockaddr(sa);
 561 #endif
 562 #ifdef MAC
 563         error = mac_socket_check_connect(td->td_ucred, so, sa);
 564         if (error)
 565                 goto bad;
 566 #endif
 567         error = soconnect(so, sa, td);
 568         if (error)
 569                 goto bad;
 570         if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) {
 571                 error = EINPROGRESS;
 572                 goto done1;
 573         }
 574         SOCK_LOCK(so);
 575         while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
 576                 error = msleep(&so->so_timeo, SOCK_MTX(so), PSOCK | PCATCH,
 577                     "connec", 0);
 578                 if (error) {
 579                         if (error == EINTR || error == ERESTART)
 580                                 interrupted = 1;
 581                         break;
 582                 }
 583         }
 584         if (error == 0) {
 585                 error = so->so_error;
 586                 so->so_error = 0;
 587         }
 588         SOCK_UNLOCK(so);
 589 bad:
 590         if (!interrupted)
 591                 so->so_state &= ~SS_ISCONNECTING;
 592         if (error == ERESTART)
 593                 error = EINTR;
 594 done1:
 595         fdrop(fp, td);
 596         return (error);
 597 }
 598
 599 int
 600 kern_socketpair(struct thread *td, int domain, int type, int protocol,
 601     int *rsv)
 602 {
 603         struct filedesc *fdp = td->td_proc->p_fd;
 604         struct file *fp1, *fp2;
 605         struct socket *so1, *so2;
 606         int fd, error;
 607
 608         AUDIT_ARG_SOCKET(domain, type, protocol);
 609 #ifdef MAC
 610         /* We might want to have a separate check for socket pairs. */
 611         error = mac_socket_check_create(td->td_ucred, domain, type,
 612             protocol);
 613         if (error)
 614                 return (error);
 615 #endif
 616         error = socreate(domain, &so1, type, protocol, td->td_ucred, td);
 617         if (error)
 618                 return (error);
 619         error = socreate(domain, &so2, type, protocol, td->td_ucred, td);
 620         if (error)
 621                 goto free1;
 622         /* On success extra reference to `fp1' and 'fp2' is set by falloc. */
 623         error = falloc(td, &fp1, &fd, 0);
 624         if (error)
 625                 goto free2;
 626         rsv[0] = fd;
 627         fp1->f_data = so1;      /* so1 already has ref count */
 628         error = falloc(td, &fp2, &fd, 0);
 629         if (error)
 630                 goto free3;
 631         fp2->f_data = so2;      /* so2 already has ref count */
 632         rsv[1] = fd;
 633         error = soconnect2(so1, so2);
 634         if (error)
 635                 goto free4;
 636         if (type == SOCK_DGRAM) {
 637                 /*
 638                  * Datagram socket connection is asymmetric.
 639                  */
 640                  error = soconnect2(so2, so1);
 641                  if (error)
 642                         goto free4;
 643         }
 644         finit(fp1, FREAD | FWRITE, DTYPE_SOCKET, fp1->f_data, &socketops);
 645         finit(fp2, FREAD | FWRITE, DTYPE_SOCKET, fp2->f_data, &socketops);
 646         fdrop(fp1, td);
 647         fdrop(fp2, td);
 648         return (0);
 649 free4:
 650         fdclose(fdp, fp2, rsv[1], td);
 651         fdrop(fp2, td);
 652 free3:
 653         fdclose(fdp, fp1, rsv[0], td);
 654         fdrop(fp1, td);
 655 free2:
 656         if (so2 != NULL)
 657                 (void)soclose(so2);
 658 free1:
 659         if (so1 != NULL)
 660                 (void)soclose(so1);
 661         return (error);
 662 }
 663
 664 int
 665 sys_socketpair(struct thread *td, struct socketpair_args *uap)
 666 {
 667         int error, sv[2];
 668
 669         error = kern_socketpair(td, uap->domain, uap->type,
 670             uap->protocol, sv);
 671         if (error)
 672                 return (error);
 673         error = copyout(sv, uap->rsv, 2 * sizeof(int));
 674         if (error) {
 675                 (void)kern_close(td, sv[0]);
 676                 (void)kern_close(td, sv[1]);
 677         }
 678         return (error);
 679 }
 680
 681 static int
 682 sendit(td, s, mp, flags)
 683         struct thread *td;
 684         int s;
 685         struct msghdr *mp;
 686         int flags;
 687 {
 688         struct mbuf *control;
 689         struct sockaddr *to;
 690         int error;
 691
 692 #ifdef CAPABILITY_MODE
 693         if (IN_CAPABILITY_MODE(td) && (mp->msg_name != NULL))
 694                 return (ECAPMODE);
 695 #endif
 696
 697         if (mp->msg_name != NULL) {
 698                 error = getsockaddr(&to, mp->msg_name, mp->msg_namelen);
 699                 if (error) {
 700                         to = NULL;
 701                         goto bad;
 702                 }
 703                 mp->msg_name = to;
 704         } else {
 705                 to = NULL;
 706         }
 707
 708         if (mp->msg_control) {
 709                 if (mp->msg_controllen < sizeof(struct cmsghdr)
 710 #ifdef COMPAT_OLDSOCK
 711                     && mp->msg_flags != MSG_COMPAT
 712 #endif
 713                 ) {
 714                         error = EINVAL;
 715                         goto bad;
 716                 }
 717                 error = sockargs(&control, mp->msg_control,
 718                     mp->msg_controllen, MT_CONTROL);
 719                 if (error)
 720                         goto bad;
 721 #ifdef COMPAT_OLDSOCK
 722                 if (mp->msg_flags == MSG_COMPAT) {
 723                         struct cmsghdr *cm;
 724
 725                         M_PREPEND(control, sizeof(*cm), M_WAITOK);
 726                         cm = mtod(control, struct cmsghdr *);
 727                         cm->cmsg_len = control->m_len;
 728                         cm->cmsg_level = SOL_SOCKET;
 729                         cm->cmsg_type = SCM_RIGHTS;
 730                 }
 731 #endif
 732         } else {
 733                 control = NULL;
 734         }
 735
 736         error = kern_sendit(td, s, mp, flags, control, UIO_USERSPACE);
 737
 738 bad:
 739         if (to)
 740                 free(to, M_SONAME);
 741         return (error);
 742 }
 743
 744 int
 745 kern_sendit(td, s, mp, flags, control, segflg)
 746         struct thread *td;
 747         int s;
 748         struct msghdr *mp;
 749         int flags;
 750         struct mbuf *control;
 751         enum uio_seg segflg;
 752 {
 753         struct file *fp;
 754         struct uio auio;
 755         struct iovec *iov;
 756         struct socket *so;
 757         int i, error;
 758         ssize_t len;
 759         cap_rights_t rights;
 760 #ifdef KTRACE
 761         struct uio *ktruio = NULL;
 762 #endif
 763
 764         AUDIT_ARG_FD(s);
 765         rights = CAP_WRITE;
 766         if (mp->msg_name != NULL)
 767                 rights |= CAP_CONNECT;
 768         error = getsock_cap(td->td_proc->p_fd, s, rights, &fp, NULL);
 769         if (error)
 770                 return (error);
 771         so = (struct socket *)fp->f_data;
 772
 773 #ifdef KTRACE
 774         if (mp->msg_name != NULL && KTRPOINT(td, KTR_STRUCT))
 775                 ktrsockaddr(mp->msg_name);
 776 #endif
 777 #ifdef MAC
 778         if (mp->msg_name != NULL) {
 779                 error = mac_socket_check_connect(td->td_ucred, so,
 780                     mp->msg_name);
 781                 if (error)
 782                         goto bad;
 783         }
 784         error = mac_socket_check_send(td->td_ucred, so);
 785         if (error)
 786                 goto bad;
 787 #endif
 788
 789         auio.uio_iov = mp->msg_iov;
 790         auio.uio_iovcnt = mp->msg_iovlen;
 791         auio.uio_segflg = segflg;
 792         auio.uio_rw = UIO_WRITE;
 793         auio.uio_td = td;
 794         auio.uio_offset = 0;                    /* XXX */
 795         auio.uio_resid = 0;
 796         iov = mp->msg_iov;
 797         for (i = 0; i < mp->msg_iovlen; i++, iov++) {
 798                 if ((auio.uio_resid += iov->iov_len) < 0) {
 799                         error = EINVAL;
 800                         goto bad;
 801                 }
 802         }
 803 #ifdef KTRACE
 804         if (KTRPOINT(td, KTR_GENIO))
 805                 ktruio = cloneuio(&auio);
 806 #endif
 807         len = auio.uio_resid;
 808         error = sosend(so, mp->msg_name, &auio, 0, control, flags, td);
 809         if (error) {
 810                 if (auio.uio_resid != len && (error == ERESTART ||
 811                     error == EINTR || error == EWOULDBLOCK))
 812                         error = 0;
 813                 /* Generation of SIGPIPE can be controlled per socket */
 814                 if (error == EPIPE && !(so->so_options & SO_NOSIGPIPE) &&
 815                     !(flags & MSG_NOSIGNAL)) {
 816                         PROC_LOCK(td->td_proc);
 817                         tdsignal(td, SIGPIPE);
 818                         PROC_UNLOCK(td->td_proc);
 819                 }
 820         }
 821         if (error == 0)
 822                 td->td_retval[0] = len - auio.uio_resid;
 823 #ifdef KTRACE
 824         if (ktruio != NULL) {
 825                 ktruio->uio_resid = td->td_retval[0];
 826                 ktrgenio(s, UIO_WRITE, ktruio, error);
 827         }
 828 #endif
 829 bad:
 830         fdrop(fp, td);
 831         return (error);
 832 }
 833
 834 int
 835 sys_sendto(td, uap)
 836         struct thread *td;
 837         struct sendto_args /* {
 838                 int     s;
 839                 caddr_t buf;
 840                 size_t  len;
 841                 int     flags;
 842                 caddr_t to;
 843                 int     tolen;
 844         } */ *uap;
 845 {
 846         struct msghdr msg;
 847         struct iovec aiov;
 848         int error;
 849
 850         msg.msg_name = uap->to;
 851         msg.msg_namelen = uap->tolen;
 852         msg.msg_iov = &aiov;
 853         msg.msg_iovlen = 1;
 854         msg.msg_control = 0;
 855 #ifdef COMPAT_OLDSOCK
 856         msg.msg_flags = 0;
 857 #endif
 858         aiov.iov_base = uap->buf;
 859         aiov.iov_len = uap->len;
 860         error = sendit(td, uap->s, &msg, uap->flags);
 861         return (error);
 862 }
 863
 864 #ifdef COMPAT_OLDSOCK
 865 int
 866 osend(td, uap)
 867         struct thread *td;
 868         struct osend_args /* {
 869                 int     s;
 870                 caddr_t buf;
 871                 int     len;
 872                 int     flags;
 873         } */ *uap;
 874 {
 875         struct msghdr msg;
 876         struct iovec aiov;
 877         int error;
 878
 879         msg.msg_name = 0;
 880         msg.msg_namelen = 0;
 881         msg.msg_iov = &aiov;
 882         msg.msg_iovlen = 1;
 883         aiov.iov_base = uap->buf;
 884         aiov.iov_len = uap->len;
 885         msg.msg_control = 0;
 886         msg.msg_flags = 0;
 887         error = sendit(td, uap->s, &msg, uap->flags);
 888         return (error);
 889 }
 890
 891 int
 892 osendmsg(td, uap)
 893         struct thread *td;
 894         struct osendmsg_args /* {
 895                 int     s;
 896                 caddr_t msg;
 897                 int     flags;
 898         } */ *uap;
 899 {
 900         struct msghdr msg;
 901         struct iovec *iov;
 902         int error;
 903
 904         error = copyin(uap->msg, &msg, sizeof (struct omsghdr));
 905         if (error)
 906                 return (error);
 907         error = copyiniov(msg.msg_iov, msg.msg_iovlen, &iov, EMSGSIZE);
 908         if (error)
 909                 return (error);
 910         msg.msg_iov = iov;
 911         msg.msg_flags = MSG_COMPAT;
 912         error = sendit(td, uap->s, &msg, uap->flags);
 913         free(iov, M_IOV);
 914         return (error);
 915 }
 916 #endif
 917
 918 int
 919 sys_sendmsg(td, uap)
 920         struct thread *td;
 921         struct sendmsg_args /* {
 922                 int     s;
 923                 caddr_t msg;
 924                 int     flags;
 925         } */ *uap;
 926 {
 927         struct msghdr msg;
 928         struct iovec *iov;
 929         int error;
 930
 931         error = copyin(uap->msg, &msg, sizeof (msg));
 932         if (error)
 933                 return (error);
 934         error = copyiniov(msg.msg_iov, msg.msg_iovlen, &iov, EMSGSIZE);
 935         if (error)
 936                 return (error);
 937         msg.msg_iov = iov;
 938 #ifdef COMPAT_OLDSOCK
 939         msg.msg_flags = 0;
 940 #endif
 941         error = sendit(td, uap->s, &msg, uap->flags);
 942         free(iov, M_IOV);
 943         return (error);
 944 }
 945
 946 int
 947 kern_recvit(td, s, mp, fromseg, controlp)
 948         struct thread *td;
 949         int s;
 950         struct msghdr *mp;
 951         enum uio_seg fromseg;
 952         struct mbuf **controlp;
 953 {
 954         struct uio auio;
 955         struct iovec *iov;
 956         int i;
 957         ssize_t len;
 958         int error;
 959         struct mbuf *m, *control = 0;
 960         caddr_t ctlbuf;
 961         struct file *fp;
 962         struct socket *so;
 963         struct sockaddr *fromsa = 0;
 964 #ifdef KTRACE
 965         struct uio *ktruio = NULL;
 966 #endif
 967
 968         if (controlp != NULL)
 969                 *controlp = NULL;
 970
 971         AUDIT_ARG_FD(s);
 972         error = getsock_cap(td->td_proc->p_fd, s, CAP_READ, &fp, NULL);
 973         if (error)
 974                 return (error);
 975         so = fp->f_data;
 976
 977 #ifdef MAC
 978         error = mac_socket_check_receive(td->td_ucred, so);
 979         if (error) {
 980                 fdrop(fp, td);
 981                 return (error);
 982         }
 983 #endif
 984
 985         auio.uio_iov = mp->msg_iov;
 986         auio.uio_iovcnt = mp->msg_iovlen;
 987         auio.uio_segflg = UIO_USERSPACE;
 988         auio.uio_rw = UIO_READ;
 989         auio.uio_td = td;
 990         auio.uio_offset = 0;                    /* XXX */
 991         auio.uio_resid = 0;
 992         iov = mp->msg_iov;
 993         for (i = 0; i < mp->msg_iovlen; i++, iov++) {
 994                 if ((auio.uio_resid += iov->iov_len) < 0) {
 995                         fdrop(fp, td);
 996                         return (EINVAL);
 997                 }
 998         }
 999 #ifdef KTRACE
1000         if (KTRPOINT(td, KTR_GENIO))
1001                 ktruio = cloneuio(&auio);
1002 #endif
1003         len = auio.uio_resid;
1004         error = soreceive(so, &fromsa, &auio, (struct mbuf **)0,
1005             (mp->msg_control || controlp) ? &control : (struct mbuf **)0,
1006             &mp->msg_flags);
1007         if (error) {
1008                 if (auio.uio_resid != len && (error == ERESTART ||
1009                     error == EINTR || error == EWOULDBLOCK))
1010                         error = 0;
1011         }
1012 #ifdef KTRACE
1013         if (ktruio != NULL) {
1014                 ktruio->uio_resid = len - auio.uio_resid;
1015                 ktrgenio(s, UIO_READ, ktruio, error);
1016         }
1017 #endif
1018         if (error)
1019                 goto out;
1020         td->td_retval[0] = len - auio.uio_resid;
1021         if (mp->msg_name) {
1022                 len = mp->msg_namelen;
1023                 if (len <= 0 || fromsa == 0)
1024                         len = 0;
1025                 else {
1026                         /* save sa_len before it is destroyed by MSG_COMPAT */
1027                         len = MIN(len, fromsa->sa_len);
1028 #ifdef COMPAT_OLDSOCK
1029                         if (mp->msg_flags & MSG_COMPAT)
1030                                 ((struct osockaddr *)fromsa)->sa_family =
1031                                     fromsa->sa_family;
1032 #endif
1033                         if (fromseg == UIO_USERSPACE) {
1034                                 error = copyout(fromsa, mp->msg_name,
1035                                     (unsigned)len);
1036                                 if (error)
1037                                         goto out;
1038                         } else
1039                                 bcopy(fromsa, mp->msg_name, len);
1040                 }
1041                 mp->msg_namelen = len;
1042         }
1043         if (mp->msg_control && controlp == NULL) {
1044 #ifdef COMPAT_OLDSOCK
1045                 /*
1046                  * We assume that old recvmsg calls won't receive access
1047                  * rights and other control info, esp. as control info
1048                  * is always optional and those options didn't exist in 4.3.
1049                  * If we receive rights, trim the cmsghdr; anything else
1050                  * is tossed.
1051                  */
1052                 if (control && mp->msg_flags & MSG_COMPAT) {
1053                         if (mtod(control, struct cmsghdr *)->cmsg_level !=
1054                             SOL_SOCKET ||
1055                             mtod(control, struct cmsghdr *)->cmsg_type !=
1056                             SCM_RIGHTS) {
1057                                 mp->msg_controllen = 0;
1058                                 goto out;
1059                         }
1060                         control->m_len -= sizeof (struct cmsghdr);
1061                         control->m_data += sizeof (struct cmsghdr);
1062                 }
1063 #endif
1064                 len = mp->msg_controllen;
1065                 m = control;
1066                 mp->msg_controllen = 0;
1067                 ctlbuf = mp->msg_control;
1068
1069                 while (m && len > 0) {
1070                         unsigned int tocopy;
1071
1072                         if (len >= m->m_len)
1073                                 tocopy = m->m_len;
1074                         else {
1075                                 mp->msg_flags |= MSG_CTRUNC;
1076                                 tocopy = len;
1077                         }
1078
1079                         if ((error = copyout(mtod(m, caddr_t),
1080                                         ctlbuf, tocopy)) != 0)
1081                                 goto out;
1082
1083                         ctlbuf += tocopy;
1084                         len -= tocopy;
1085                         m = m->m_next;
1086                 }
1087                 mp->msg_controllen = ctlbuf - (caddr_t)mp->msg_control;
1088         }
1089 out:
1090         fdrop(fp, td);
1091 #ifdef KTRACE
1092         if (fromsa && KTRPOINT(td, KTR_STRUCT))
1093                 ktrsockaddr(fromsa);
1094 #endif
1095         if (fromsa)
1096                 free(fromsa, M_SONAME);
1097
1098         if (error == 0 && controlp != NULL)
1099                 *controlp = control;
1100         else  if (control)
1101                 m_freem(control);
1102
1103         return (error);
1104 }
1105
1106 static int
1107 recvit(td, s, mp, namelenp)
1108         struct thread *td;
1109         int s;
1110         struct msghdr *mp;
1111         void *namelenp;
1112 {
1113         int error;
1114
1115         error = kern_recvit(td, s, mp, UIO_USERSPACE, NULL);
1116         if (error)
1117                 return (error);
1118         if (namelenp) {
1119                 error = copyout(&mp->msg_namelen, namelenp, sizeof (socklen_t));
1120 #ifdef COMPAT_OLDSOCK
1121                 if (mp->msg_flags & MSG_COMPAT)
1122                         error = 0;      /* old recvfrom didn't check */
1123 #endif
1124         }
1125         return (error);
1126 }
1127
1128 int
1129 sys_recvfrom(td, uap)
1130         struct thread *td;
1131         struct recvfrom_args /* {
1132                 int     s;
1133                 caddr_t buf;
1134                 size_t  len;
1135                 int     flags;
1136                 struct sockaddr * __restrict    from;
1137                 socklen_t * __restrict fromlenaddr;
1138         } */ *uap;
1139 {
1140         struct msghdr msg;
1141         struct iovec aiov;
1142         int error;
1143
1144         if (uap->fromlenaddr) {
1145                 error = copyin(uap->fromlenaddr,
1146                     &msg.msg_namelen, sizeof (msg.msg_namelen));
1147                 if (error)
1148                         goto done2;
1149         } else {
1150                 msg.msg_namelen = 0;
1151         }
1152         msg.msg_name = uap->from;
1153         msg.msg_iov = &aiov;
1154         msg.msg_iovlen = 1;
1155         aiov.iov_base = uap->buf;
1156         aiov.iov_len = uap->len;
1157         msg.msg_control = 0;
1158         msg.msg_flags = uap->flags;
1159         error = recvit(td, uap->s, &msg, uap->fromlenaddr);
1160 done2:
1161         return(error);
1162 }
1163
1164 #ifdef COMPAT_OLDSOCK
1165 int
1166 orecvfrom(td, uap)
1167         struct thread *td;
1168         struct recvfrom_args *uap;
1169 {
1170
1171         uap->flags |= MSG_COMPAT;
1172         return (sys_recvfrom(td, uap));
1173 }
1174 #endif
1175
1176 #ifdef COMPAT_OLDSOCK
1177 int
1178 orecv(td, uap)
1179         struct thread *td;
1180         struct orecv_args /* {
1181                 int     s;
1182                 caddr_t buf;
1183                 int     len;
1184                 int     flags;
1185         } */ *uap;
1186 {
1187         struct msghdr msg;
1188         struct iovec aiov;
1189         int error;
1190
1191         msg.msg_name = 0;
1192         msg.msg_namelen = 0;
1193         msg.msg_iov = &aiov;
1194         msg.msg_iovlen = 1;
1195         aiov.iov_base = uap->buf;
1196         aiov.iov_len = uap->len;
1197         msg.msg_control = 0;
1198         msg.msg_flags = uap->flags;
1199         error = recvit(td, uap->s, &msg, NULL);
1200         return (error);
1201 }
1202
1203 /*
1204  * Old recvmsg.  This code takes advantage of the fact that the old msghdr
1205  * overlays the new one, missing only the flags, and with the (old) access
1206  * rights where the control fields are now.
1207  */
1208 int
1209 orecvmsg(td, uap)
1210         struct thread *td;
1211         struct orecvmsg_args /* {
1212                 int     s;
1213                 struct  omsghdr *msg;
1214                 int     flags;
1215         } */ *uap;
1216 {
1217         struct msghdr msg;
1218         struct iovec *iov;
1219         int error;
1220
1221         error = copyin(uap->msg, &msg, sizeof (struct omsghdr));
1222         if (error)
1223                 return (error);
1224         error = copyiniov(msg.msg_iov, msg.msg_iovlen, &iov, EMSGSIZE);
1225         if (error)
1226                 return (error);
1227         msg.msg_flags = uap->flags | MSG_COMPAT;
1228         msg.msg_iov = iov;
1229         error = recvit(td, uap->s, &msg, &uap->msg->msg_namelen);
1230         if (msg.msg_controllen && error == 0)
1231                 error = copyout(&msg.msg_controllen,
1232                     &uap->msg->msg_accrightslen, sizeof (int));
1233         free(iov, M_IOV);
1234         return (error);
1235 }
1236 #endif
1237
1238 int
1239 sys_recvmsg(td, uap)
1240         struct thread *td;
1241         struct recvmsg_args /* {
1242                 int     s;
1243                 struct  msghdr *msg;
1244                 int     flags;
1245         } */ *uap;
1246 {
1247         struct msghdr msg;
1248         struct iovec *uiov, *iov;
1249         int error;
1250
1251         error = copyin(uap->msg, &msg, sizeof (msg));
1252         if (error)
1253                 return (error);
1254         error = copyiniov(msg.msg_iov, msg.msg_iovlen, &iov, EMSGSIZE);
1255         if (error)
1256                 return (error);
1257         msg.msg_flags = uap->flags;
1258 #ifdef COMPAT_OLDSOCK
1259         msg.msg_flags &= ~MSG_COMPAT;
1260 #endif
1261         uiov = msg.msg_iov;
1262         msg.msg_iov = iov;
1263         error = recvit(td, uap->s, &msg, NULL);
1264         if (error == 0) {
1265                 msg.msg_iov = uiov;
1266                 error = copyout(&msg, uap->msg, sizeof(msg));
1267         }
1268         free(iov, M_IOV);
1269         return (error);
1270 }
1271
1272 /* ARGSUSED */
1273 int
1274 sys_shutdown(td, uap)
1275         struct thread *td;
1276         struct shutdown_args /* {
1277                 int     s;
1278                 int     how;
1279         } */ *uap;
1280 {
1281         struct socket *so;
1282         struct file *fp;
1283         int error;
1284
1285         AUDIT_ARG_FD(uap->s);
1286         error = getsock_cap(td->td_proc->p_fd, uap->s, CAP_SHUTDOWN, &fp,
1287             NULL);
1288         if (error == 0) {
1289                 so = fp->f_data;
1290                 error = soshutdown(so, uap->how);
1291                 fdrop(fp, td);
1292         }
1293         return (error);
1294 }
1295
1296 /* ARGSUSED */
1297 int
1298 sys_setsockopt(td, uap)
1299         struct thread *td;
1300         struct setsockopt_args /* {
1301                 int     s;
1302                 int     level;
1303                 int     name;
1304                 caddr_t val;
1305                 int     valsize;
1306         } */ *uap;
1307 {
1308
1309         return (kern_setsockopt(td, uap->s, uap->level, uap->name,
1310             uap->val, UIO_USERSPACE, uap->valsize));
1311 }
1312
1313 int
1314 kern_setsockopt(td, s, level, name, val, valseg, valsize)
1315         struct thread *td;
1316         int s;
1317         int level;
1318         int name;
1319         void *val;
1320         enum uio_seg valseg;
1321         socklen_t valsize;
1322 {
1323         int error;
1324         struct socket *so;
1325         struct file *fp;
1326         struct sockopt sopt;
1327
1328         if (val == NULL && valsize != 0)
1329                 return (EFAULT);
1330         if ((int)valsize < 0)
1331                 return (EINVAL);
1332
1333         sopt.sopt_dir = SOPT_SET;
1334         sopt.sopt_level = level;
1335         sopt.sopt_name = name;
1336         sopt.sopt_val = val;
1337         sopt.sopt_valsize = valsize;
1338         switch (valseg) {
1339         case UIO_USERSPACE:
1340                 sopt.sopt_td = td;
1341                 break;
1342         case UIO_SYSSPACE:
1343                 sopt.sopt_td = NULL;
1344                 break;
1345         default:
1346                 panic("kern_setsockopt called with bad valseg");
1347         }
1348
1349         AUDIT_ARG_FD(s);
1350         error = getsock_cap(td->td_proc->p_fd, s, CAP_SETSOCKOPT, &fp, NULL);
1351         if (error == 0) {
1352                 so = fp->f_data;
1353                 error = sosetopt(so, &sopt);
1354                 fdrop(fp, td);
1355         }
1356         return(error);
1357 }
1358
1359 /* ARGSUSED */
1360 int
1361 sys_getsockopt(td, uap)
1362         struct thread *td;
1363         struct getsockopt_args /* {
1364                 int     s;
1365                 int     level;
1366                 int     name;
1367                 void * __restrict       val;
1368                 socklen_t * __restrict avalsize;
1369         } */ *uap;
1370 {
1371         socklen_t valsize;
1372         int     error;
1373
1374         if (uap->val) {
1375                 error = copyin(uap->avalsize, &valsize, sizeof (valsize));
1376                 if (error)
1377                         return (error);
1378         }
1379
1380         error = kern_getsockopt(td, uap->s, uap->level, uap->name,
1381             uap->val, UIO_USERSPACE, &valsize);
1382
1383         if (error == 0)
1384                 error = copyout(&valsize, uap->avalsize, sizeof (valsize));
1385         return (error);
1386 }
1387
1388 /*
1389  * Kernel version of getsockopt.
1390  * optval can be a userland or userspace. optlen is always a kernel pointer.
1391  */
1392 int
1393 kern_getsockopt(td, s, level, name, val, valseg, valsize)
1394         struct thread *td;
1395         int s;
1396         int level;
1397         int name;
1398         void *val;
1399         enum uio_seg valseg;
1400         socklen_t *valsize;
1401 {
1402         int error;
1403         struct  socket *so;
1404         struct file *fp;
1405         struct  sockopt sopt;
1406
1407         if (val == NULL)
1408                 *valsize = 0;
1409         if ((int)*valsize < 0)
1410                 return (EINVAL);
1411
1412         sopt.sopt_dir = SOPT_GET;
1413         sopt.sopt_level = level;
1414         sopt.sopt_name = name;
1415         sopt.sopt_val = val;
1416         sopt.sopt_valsize = (size_t)*valsize; /* checked non-negative above */
1417         switch (valseg) {
1418         case UIO_USERSPACE:
1419                 sopt.sopt_td = td;
1420                 break;
1421         case UIO_SYSSPACE:
1422                 sopt.sopt_td = NULL;
1423                 break;
1424         default:
1425                 panic("kern_getsockopt called with bad valseg");
1426         }
1427
1428         AUDIT_ARG_FD(s);
1429         error = getsock_cap(td->td_proc->p_fd, s, CAP_GETSOCKOPT, &fp, NULL);
1430         if (error == 0) {
1431                 so = fp->f_data;
1432                 error = sogetopt(so, &sopt);
1433                 *valsize = sopt.sopt_valsize;
1434                 fdrop(fp, td);
1435         }
1436         return (error);
1437 }
1438
1439 /*
1440  * getsockname1() - Get socket name.
1441  */
1442 /* ARGSUSED */
1443 static int
1444 getsockname1(td, uap, compat)
1445         struct thread *td;
1446         struct getsockname_args /* {
1447                 int     fdes;
1448                 struct sockaddr * __restrict asa;
1449                 socklen_t * __restrict alen;
1450         } */ *uap;
1451         int compat;
1452 {
1453         struct sockaddr *sa;
1454         socklen_t len;
1455         int error;
1456
1457         error = copyin(uap->alen, &len, sizeof(len));
1458         if (error)
1459                 return (error);
1460
1461         error = kern_getsockname(td, uap->fdes, &sa, &len);
1462         if (error)
1463                 return (error);
1464
1465         if (len != 0) {
1466 #ifdef COMPAT_OLDSOCK
1467                 if (compat)
1468                         ((struct osockaddr *)sa)->sa_family = sa->sa_family;
1469 #endif
1470                 error = copyout(sa, uap->asa, (u_int)len);
1471         }
1472         free(sa, M_SONAME);
1473         if (error == 0)
1474                 error = copyout(&len, uap->alen, sizeof(len));
1475         return (error);
1476 }
1477
1478 int
1479 kern_getsockname(struct thread *td, int fd, struct sockaddr **sa,
1480     socklen_t *alen)
1481 {
1482         struct socket *so;
1483         struct file *fp;
1484         socklen_t len;
1485         int error;
1486
1487         if (*alen < 0)
1488                 return (EINVAL);
1489
1490         AUDIT_ARG_FD(fd);
1491         error = getsock_cap(td->td_proc->p_fd, fd, CAP_GETSOCKNAME, &fp, NULL);
1492         if (error)
1493                 return (error);
1494         so = fp->f_data;
1495         *sa = NULL;
1496         CURVNET_SET(so->so_vnet);
1497         error = (*so->so_proto->pr_usrreqs->pru_sockaddr)(so, sa);
1498         CURVNET_RESTORE();
1499         if (error)
1500                 goto bad;
1501         if (*sa == NULL)
1502                 len = 0;
1503         else
1504                 len = MIN(*alen, (*sa)->sa_len);
1505         *alen = len;
1506 #ifdef KTRACE
1507         if (KTRPOINT(td, KTR_STRUCT))
1508                 ktrsockaddr(*sa);
1509 #endif
1510 bad:
1511         fdrop(fp, td);
1512         if (error && *sa) {
1513                 free(*sa, M_SONAME);
1514                 *sa = NULL;
1515         }
1516         return (error);
1517 }
1518
1519 int
1520 sys_getsockname(td, uap)
1521         struct thread *td;
1522         struct getsockname_args *uap;
1523 {
1524
1525         return (getsockname1(td, uap, 0));
1526 }
1527
1528 #ifdef COMPAT_OLDSOCK
1529 int
1530 ogetsockname(td, uap)
1531         struct thread *td;
1532         struct getsockname_args *uap;
1533 {
1534
1535         return (getsockname1(td, uap, 1));
1536 }
1537 #endif /* COMPAT_OLDSOCK */
1538
1539 /*
1540  * getpeername1() - Get name of peer for connected socket.
1541  */
1542 /* ARGSUSED */
1543 static int
1544 getpeername1(td, uap, compat)
1545         struct thread *td;
1546         struct getpeername_args /* {
1547                 int     fdes;
1548                 struct sockaddr * __restrict    asa;
1549                 socklen_t * __restrict  alen;
1550         } */ *uap;
1551         int compat;
1552 {
1553         struct sockaddr *sa;
1554         socklen_t len;
1555         int error;
1556
1557         error = copyin(uap->alen, &len, sizeof (len));
1558         if (error)
1559                 return (error);
1560
1561         error = kern_getpeername(td, uap->fdes, &sa, &len);
1562         if (error)
1563                 return (error);
1564
1565         if (len != 0) {
1566 #ifdef COMPAT_OLDSOCK
1567                 if (compat)
1568                         ((struct osockaddr *)sa)->sa_family = sa->sa_family;
1569 #endif
1570                 error = copyout(sa, uap->asa, (u_int)len);
1571         }
1572         free(sa, M_SONAME);
1573         if (error == 0)
1574                 error = copyout(&len, uap->alen, sizeof(len));
1575         return (error);
1576 }
1577
1578 int
1579 kern_getpeername(struct thread *td, int fd, struct sockaddr **sa,
1580     socklen_t *alen)
1581 {
1582         struct socket *so;
1583         struct file *fp;
1584         socklen_t len;
1585         int error;
1586
1587         if (*alen < 0)
1588                 return (EINVAL);
1589
1590         AUDIT_ARG_FD(fd);
1591         error = getsock_cap(td->td_proc->p_fd, fd, CAP_GETPEERNAME, &fp, NULL);
1592         if (error)
1593                 return (error);
1594         so = fp->f_data;
1595         if ((so->so_state & (SS_ISCONNECTED|SS_ISCONFIRMING)) == 0) {
1596                 error = ENOTCONN;
1597                 goto done;
1598         }
1599         *sa = NULL;
1600         CURVNET_SET(so->so_vnet);
1601         error = (*so->so_proto->pr_usrreqs->pru_peeraddr)(so, sa);
1602         CURVNET_RESTORE();
1603         if (error)
1604                 goto bad;
1605         if (*sa == NULL)
1606                 len = 0;
1607         else
1608                 len = MIN(*alen, (*sa)->sa_len);
1609         *alen = len;
1610 #ifdef KTRACE
1611         if (KTRPOINT(td, KTR_STRUCT))
1612                 ktrsockaddr(*sa);
1613 #endif
1614 bad:
1615         if (error && *sa) {
1616                 free(*sa, M_SONAME);
1617                 *sa = NULL;
1618         }
1619 done:
1620         fdrop(fp, td);
1621         return (error);
1622 }
1623
1624 int
1625 sys_getpeername(td, uap)
1626         struct thread *td;
1627         struct getpeername_args *uap;
1628 {
1629
1630         return (getpeername1(td, uap, 0));
1631 }
1632
1633 #ifdef COMPAT_OLDSOCK
1634 int
1635 ogetpeername(td, uap)
1636         struct thread *td;
1637         struct ogetpeername_args *uap;
1638 {
1639
1640         /* XXX uap should have type `getpeername_args *' to begin with. */
1641         return (getpeername1(td, (struct getpeername_args *)uap, 1));
1642 }
1643 #endif /* COMPAT_OLDSOCK */
1644
1645 int
1646 sockargs(mp, buf, buflen, type)
1647         struct mbuf **mp;
1648         caddr_t buf;
1649         int buflen, type;
1650 {
1651         struct sockaddr *sa;
1652         struct mbuf *m;
1653         int error;
1654
1655         if ((u_int)buflen > MLEN) {
1656 #ifdef COMPAT_OLDSOCK
1657                 if (type == MT_SONAME && (u_int)buflen <= 112)
1658                         buflen = MLEN;          /* unix domain compat. hack */
1659                 else
1660 #endif
1661                         if ((u_int)buflen > MCLBYTES)
1662                                 return (EINVAL);
1663         }
1664         m = m_get(M_WAITOK, type);
1665         if ((u_int)buflen > MLEN)
1666                 MCLGET(m, M_WAITOK);
1667         m->m_len = buflen;
1668         error = copyin(buf, mtod(m, caddr_t), (u_int)buflen);
1669         if (error)
1670                 (void) m_free(m);
1671         else {
1672                 *mp = m;
1673                 if (type == MT_SONAME) {
1674                         sa = mtod(m, struct sockaddr *);
1675
1676 #if defined(COMPAT_OLDSOCK) && BYTE_ORDER != BIG_ENDIAN
1677                         if (sa->sa_family == 0 && sa->sa_len < AF_MAX)
1678                                 sa->sa_family = sa->sa_len;
1679 #endif
1680                         sa->sa_len = buflen;
1681                 }
1682         }
1683         return (error);
1684 }
1685
1686 int
1687 getsockaddr(namp, uaddr, len)
1688         struct sockaddr **namp;
1689         caddr_t uaddr;
1690         size_t len;
1691 {
1692         struct sockaddr *sa;
1693         int error;
1694
1695         if (len > SOCK_MAXADDRLEN)
1696                 return (ENAMETOOLONG);
1697         if (len < offsetof(struct sockaddr, sa_data[0]))
1698                 return (EINVAL);
1699         sa = malloc(len, M_SONAME, M_WAITOK);
1700         error = copyin(uaddr, sa, len);
1701         if (error) {
1702                 free(sa, M_SONAME);
1703         } else {
1704 #if defined(COMPAT_OLDSOCK) && BYTE_ORDER != BIG_ENDIAN
1705                 if (sa->sa_family == 0 && sa->sa_len < AF_MAX)
1706                         sa->sa_family = sa->sa_len;
1707 #endif
1708                 sa->sa_len = len;
1709                 *namp = sa;
1710         }
1711         return (error);
1712 }
1713
1714 #include <sys/condvar.h>
1715
1716 struct sendfile_sync {
1717         struct mtx      mtx;
1718         struct cv       cv;
1719         unsigned        count;
1720 };
1721
1722 /*
1723  * Detach mapped page and release resources back to the system.
1724  */
1725 void
1726 sf_buf_mext(void *addr, void *args)
1727 {
1728         vm_page_t m;
1729         struct sendfile_sync *sfs;
1730
1731         m = sf_buf_page(args);
1732         sf_buf_free(args);
1733         vm_page_lock(m);
1734         vm_page_unwire(m, 0);
1735         /*
1736          * Check for the object going away on us. This can
1737          * happen since we don't hold a reference to it.
1738          * If so, we're responsible for freeing the page.
1739          */
1740         if (m->wire_count == 0 && m->object == NULL)
1741                 vm_page_free(m);
1742         vm_page_unlock(m);
1743         if (addr == NULL)
1744                 return;
1745         sfs = addr;
1746         mtx_lock(&sfs->mtx);
1747         KASSERT(sfs->count> 0, ("Sendfile sync botchup count == 0"));
1748         if (--sfs->count == 0)
1749                 cv_signal(&sfs->cv);
1750         mtx_unlock(&sfs->mtx);
1751 }
1752
1753 /*
1754  * sendfile(2)
1755  *
1756  * int sendfile(int fd, int s, off_t offset, size_t nbytes,
1757  *       struct sf_hdtr *hdtr, off_t *sbytes, int flags)
1758  *
1759  * Send a file specified by 'fd' and starting at 'offset' to a socket
1760  * specified by 's'. Send only 'nbytes' of the file or until EOF if nbytes ==
1761  * 0.  Optionally add a header and/or trailer to the socket output.  If
1762  * specified, write the total number of bytes sent into *sbytes.
1763  */
1764 int
1765 sys_sendfile(struct thread *td, struct sendfile_args *uap)
1766 {
1767
1768         return (do_sendfile(td, uap, 0));
1769 }
1770
1771 static int
1772 do_sendfile(struct thread *td, struct sendfile_args *uap, int compat)
1773 {
1774         struct sf_hdtr hdtr;
1775         struct uio *hdr_uio, *trl_uio;
1776         int error;
1777
1778         hdr_uio = trl_uio = NULL;
1779
1780         if (uap->hdtr != NULL) {
1781                 error = copyin(uap->hdtr, &hdtr, sizeof(hdtr));
1782                 if (error)
1783                         goto out;
1784                 if (hdtr.headers != NULL) {
1785                         error = copyinuio(hdtr.headers, hdtr.hdr_cnt, &hdr_uio);
1786                         if (error)
1787                                 goto out;
1788                 }
1789                 if (hdtr.trailers != NULL) {
1790                         error = copyinuio(hdtr.trailers, hdtr.trl_cnt, &trl_uio);
1791                         if (error)
1792                                 goto out;
1793
1794                 }
1795         }
1796
1797         error = kern_sendfile(td, uap, hdr_uio, trl_uio, compat);
1798 out:
1799         if (hdr_uio)
1800                 free(hdr_uio, M_IOV);
1801         if (trl_uio)
1802                 free(trl_uio, M_IOV);
1803         return (error);
1804 }
1805
1806 #ifdef COMPAT_FREEBSD4
1807 int
1808 freebsd4_sendfile(struct thread *td, struct freebsd4_sendfile_args *uap)
1809 {
1810         struct sendfile_args args;
1811
1812         args.fd = uap->fd;
1813         args.s = uap->s;
1814         args.offset = uap->offset;
1815         args.nbytes = uap->nbytes;
1816         args.hdtr = uap->hdtr;
1817         args.sbytes = uap->sbytes;
1818         args.flags = uap->flags;
1819
1820         return (do_sendfile(td, &args, 1));
1821 }
1822 #endif /* COMPAT_FREEBSD4 */
1823
1824 int
1825 kern_sendfile(struct thread *td, struct sendfile_args *uap,
1826     struct uio *hdr_uio, struct uio *trl_uio, int compat)
1827 {
1828         struct file *sock_fp;
1829         struct vnode *vp;
1830         struct vm_object *obj = NULL;
1831         struct socket *so = NULL;
1832         struct mbuf *m = NULL;
1833         struct sf_buf *sf;
1834         struct vm_page *pg;
1835         off_t off, xfsize, fsbytes = 0, sbytes = 0, rem = 0;
1836         int error, hdrlen = 0, mnw = 0;
1837         struct sendfile_sync *sfs = NULL;
1838
1839         /*
1840          * The file descriptor must be a regular file and have a
1841          * backing VM object.
1842          * File offset must be positive.  If it goes beyond EOF
1843          * we send only the header/trailer and no payload data.
1844          */
1845         AUDIT_ARG_FD(uap->fd);
1846         if ((error = fgetvp_read(td, uap->fd, CAP_READ, &vp)) != 0)
1847                 goto out;
1848         vn_lock(vp, LK_SHARED | LK_RETRY);
1849         if (vp->v_type == VREG) {
1850                 obj = vp->v_object;
1851                 if (obj != NULL) {
1852                         /*
1853                          * Temporarily increase the backing VM
1854                          * object's reference count so that a forced
1855                          * reclamation of its vnode does not
1856                          * immediately destroy it.
1857                          */
1858                         VM_OBJECT_LOCK(obj);
1859                         if ((obj->flags & OBJ_DEAD) == 0) {
1860                                 vm_object_reference_locked(obj);
1861                                 VM_OBJECT_UNLOCK(obj);
1862                         } else {
1863                                 VM_OBJECT_UNLOCK(obj);
1864                                 obj = NULL;
1865                         }
1866                 }
1867         }
1868         VOP_UNLOCK(vp, 0);
1869         if (obj == NULL) {
1870                 error = EINVAL;
1871                 goto out;
1872         }
1873         if (uap->offset < 0) {
1874                 error = EINVAL;
1875                 goto out;
1876         }
1877
1878         /*
1879          * The socket must be a stream socket and connected.
1880          * Remember if it a blocking or non-blocking socket.
1881          */
1882         if ((error = getsock_cap(td->td_proc->p_fd, uap->s, CAP_WRITE,
1883             &sock_fp, NULL)) != 0)
1884                 goto out;
1885         so = sock_fp->f_data;
1886         if (so->so_type != SOCK_STREAM) {
1887                 error = EINVAL;
1888                 goto out;
1889         }
1890         if ((so->so_state & SS_ISCONNECTED) == 0) {
1891                 error = ENOTCONN;
1892                 goto out;
1893         }
1894         /*
1895          * Do not wait on memory allocations but return ENOMEM for
1896          * caller to retry later.
1897          * XXX: Experimental.
1898          */
1899         if (uap->flags & SF_MNOWAIT)
1900                 mnw = 1;
1901
1902         if (uap->flags & SF_SYNC) {
1903                 sfs = malloc(sizeof *sfs, M_TEMP, M_WAITOK | M_ZERO);
1904                 mtx_init(&sfs->mtx, "sendfile", NULL, MTX_DEF);
1905                 cv_init(&sfs->cv, "sendfile");
1906         }
1907
1908 #ifdef MAC
1909         error = mac_socket_check_send(td->td_ucred, so);
1910         if (error)
1911                 goto out;
1912 #endif
1913
1914         /* If headers are specified copy them into mbufs. */
1915         if (hdr_uio != NULL) {
1916                 hdr_uio->uio_td = td;
1917                 hdr_uio->uio_rw = UIO_WRITE;
1918                 if (hdr_uio->uio_resid > 0) {
1919                         /*
1920                          * In FBSD < 5.0 the nbytes to send also included
1921                          * the header.  If compat is specified subtract the
1922                          * header size from nbytes.
1923                          */
1924                         if (compat) {
1925                                 if (uap->nbytes > hdr_uio->uio_resid)
1926                                         uap->nbytes -= hdr_uio->uio_resid;
1927                                 else
1928                                         uap->nbytes = 0;
1929                         }
1930                         m = m_uiotombuf(hdr_uio, (mnw ? M_NOWAIT : M_WAITOK),
1931                             0, 0, 0);
1932                         if (m == NULL) {
1933                                 error = mnw ? EAGAIN : ENOBUFS;
1934                                 goto out;
1935                         }
1936                         hdrlen = m_length(m, NULL);
1937                 }
1938         }
1939
1940         /*
1941          * Protect against multiple writers to the socket.
1942          *
1943          * XXXRW: Historically this has assumed non-interruptibility, so now
1944          * we implement that, but possibly shouldn't.
1945          */
1946         (void)sblock(&so->so_snd, SBL_WAIT | SBL_NOINTR);
1947
1948         /*
1949          * Loop through the pages of the file, starting with the requested
1950          * offset. Get a file page (do I/O if necessary), map the file page
1951          * into an sf_buf, attach an mbuf header to the sf_buf, and queue
1952          * it on the socket.
1953          * This is done in two loops.  The inner loop turns as many pages
1954          * as it can, up to available socket buffer space, without blocking
1955          * into mbufs to have it bulk delivered into the socket send buffer.
1956          * The outer loop checks the state and available space of the socket
1957          * and takes care of the overall progress.
1958          */
1959         for (off = uap->offset, rem = uap->nbytes; ; ) {
1960                 struct mbuf *mtail = NULL;
1961                 int loopbytes = 0;
1962                 int space = 0;
1963                 int done = 0;
1964
1965                 /*
1966                  * Check the socket state for ongoing connection,
1967                  * no errors and space in socket buffer.
1968                  * If space is low allow for the remainder of the
1969                  * file to be processed if it fits the socket buffer.
1970                  * Otherwise block in waiting for sufficient space
1971                  * to proceed, or if the socket is nonblocking, return
1972                  * to userland with EAGAIN while reporting how far
1973                  * we've come.
1974                  * We wait until the socket buffer has significant free
1975                  * space to do bulk sends.  This makes good use of file
1976                  * system read ahead and allows packet segmentation
1977                  * offloading hardware to take over lots of work.  If
1978                  * we were not careful here we would send off only one
1979                  * sfbuf at a time.
1980                  */
1981                 SOCKBUF_LOCK(&so->so_snd);
1982                 if (so->so_snd.sb_lowat < so->so_snd.sb_hiwat / 2)
1983                         so->so_snd.sb_lowat = so->so_snd.sb_hiwat / 2;
1984 retry_space:
1985                 if (so->so_snd.sb_state & SBS_CANTSENDMORE) {
1986                         error = EPIPE;
1987                         SOCKBUF_UNLOCK(&so->so_snd);
1988                         goto done;
1989                 } else if (so->so_error) {
1990                         error = so->so_error;
1991                         so->so_error = 0;
1992                         SOCKBUF_UNLOCK(&so->so_snd);
1993                         goto done;
1994                 }
1995                 space = sbspace(&so->so_snd);
1996                 if (space < rem &&
1997                     (space <= 0 ||
1998                      space < so->so_snd.sb_lowat)) {
1999                         if (so->so_state & SS_NBIO) {
2000                                 SOCKBUF_UNLOCK(&so->so_snd);
2001                                 error = EAGAIN;
2002                                 goto done;
2003                         }
2004                         /*
2005                          * sbwait drops the lock while sleeping.
2006                          * When we loop back to retry_space the
2007                          * state may have changed and we retest
2008                          * for it.
2009                          */
2010                         error = sbwait(&so->so_snd);
2011                         /*
2012                          * An error from sbwait usually indicates that we've
2013                          * been interrupted by a signal. If we've sent anything
2014                          * then return bytes sent, otherwise return the error.
2015                          */
2016                         if (error) {
2017                                 SOCKBUF_UNLOCK(&so->so_snd);
2018                                 goto done;
2019                         }
2020                         goto retry_space;
2021                 }
2022                 SOCKBUF_UNLOCK(&so->so_snd);
2023
2024                 /*
2025                  * Reduce space in the socket buffer by the size of
2026                  * the header mbuf chain.
2027                  * hdrlen is set to 0 after the first loop.
2028                  */
2029                 space -= hdrlen;
2030
2031                 /*
2032                  * Loop and construct maximum sized mbuf chain to be bulk
2033                  * dumped into socket buffer.
2034                  */
2035                 while (space > loopbytes) {
2036                         vm_pindex_t pindex;
2037                         vm_offset_t pgoff;
2038                         struct mbuf *m0;
2039
2040                         VM_OBJECT_LOCK(obj);
2041                         /*
2042                          * Calculate the amount to transfer.
2043                          * Not to exceed a page, the EOF,
2044                          * or the passed in nbytes.
2045                          */
2046                         pgoff = (vm_offset_t)(off & PAGE_MASK);
2047                         xfsize = omin(PAGE_SIZE - pgoff,
2048                             obj->un_pager.vnp.vnp_size - uap->offset -
2049                             fsbytes - loopbytes);
2050                         if (uap->nbytes)
2051                                 rem = (uap->nbytes - fsbytes - loopbytes);
2052                         else
2053                                 rem = obj->un_pager.vnp.vnp_size -
2054                                     uap->offset - fsbytes - loopbytes;
2055                         xfsize = omin(rem, xfsize);
2056                         xfsize = omin(space - loopbytes, xfsize);
2057                         if (xfsize <= 0) {
2058                                 VM_OBJECT_UNLOCK(obj);
2059                                 done = 1;               /* all data sent */
2060                                 break;
2061                         }
2062
2063                         /*
2064                          * Attempt to look up the page.  Allocate
2065                          * if not found or wait and loop if busy.
2066                          */
2067                         pindex = OFF_TO_IDX(off);
2068                         pg = vm_page_grab(obj, pindex, VM_ALLOC_NOBUSY |
2069                             VM_ALLOC_NORMAL | VM_ALLOC_WIRED | VM_ALLOC_RETRY);
2070
2071                         /*
2072                          * Check if page is valid for what we need,
2073                          * otherwise initiate I/O.
2074                          * If we already turned some pages into mbufs,
2075                          * send them off before we come here again and
2076                          * block.
2077                          */
2078                         if (pg->valid && vm_page_is_valid(pg, pgoff, xfsize))
2079                                 VM_OBJECT_UNLOCK(obj);
2080                         else if (m != NULL)
2081                                 error = EAGAIN; /* send what we already got */
2082                         else if (uap->flags & SF_NODISKIO)
2083                                 error = EBUSY;
2084                         else {
2085                                 int bsize;
2086                                 ssize_t resid;
2087
2088                                 /*
2089                                  * Ensure that our page is still around
2090                                  * when the I/O completes.
2091                                  */
2092                                 vm_page_io_start(pg);
2093                                 VM_OBJECT_UNLOCK(obj);
2094
2095                                 /*
2096                                  * Get the page from backing store.
2097                                  */
2098                                 error = vn_lock(vp, LK_SHARED);
2099                                 if (error != 0)
2100                                         goto after_read;
2101                                 bsize = vp->v_mount->mnt_stat.f_iosize;
2102
2103                                 /*
2104                                  * XXXMAC: Because we don't have fp->f_cred
2105                                  * here, we pass in NOCRED.  This is probably
2106                                  * wrong, but is consistent with our original
2107                                  * implementation.
2108                                  */
2109                                 error = vn_rdwr(UIO_READ, vp, NULL, MAXBSIZE,
2110                                     trunc_page(off), UIO_NOCOPY, IO_NODELOCKED |
2111                                     IO_VMIO | ((MAXBSIZE / bsize) << IO_SEQSHIFT),
2112                                     td->td_ucred, NOCRED, &resid, td);
2113                                 VOP_UNLOCK(vp, 0);
2114                         after_read:
2115                                 VM_OBJECT_LOCK(obj);
2116                                 vm_page_io_finish(pg);
2117                                 if (!error)
2118                                         VM_OBJECT_UNLOCK(obj);
2119                                 mbstat.sf_iocnt++;
2120                         }
2121                         if (error) {
2122                                 vm_page_lock(pg);
2123                                 vm_page_unwire(pg, 0);
2124                                 /*
2125                                  * See if anyone else might know about
2126                                  * this page.  If not and it is not valid,
2127                                  * then free it.
2128                                  */
2129                                 if (pg->wire_count == 0 && pg->valid == 0 &&
2130                                     pg->busy == 0 && !(pg->oflags & VPO_BUSY))
2131                                         vm_page_free(pg);
2132                                 vm_page_unlock(pg);
2133                                 VM_OBJECT_UNLOCK(obj);
2134                                 if (error == EAGAIN)
2135                                         error = 0;      /* not a real error */
2136                                 break;
2137                         }
2138
2139                         /*
2140                          * Get a sendfile buf.  When allocating the
2141                          * first buffer for mbuf chain, we usually
2142                          * wait as long as necessary, but this wait
2143                          * can be interrupted.  For consequent
2144                          * buffers, do not sleep, since several
2145                          * threads might exhaust the buffers and then
2146                          * deadlock.
2147                          */
2148                         sf = sf_buf_alloc(pg, (mnw || m != NULL) ? SFB_NOWAIT :
2149                             SFB_CATCH);
2150                         if (sf == NULL) {
2151                                 mbstat.sf_allocfail++;
2152                                 vm_page_lock(pg);
2153                                 vm_page_unwire(pg, 0);
2154                                 KASSERT(pg->object != NULL,
2155                                     ("kern_sendfile: object disappeared"));
2156                                 vm_page_unlock(pg);
2157                                 if (m == NULL)
2158                                         error = (mnw ? EAGAIN : EINTR);
2159                                 break;
2160                         }
2161
2162                         /*
2163                          * Get an mbuf and set it up as having
2164                          * external storage.
2165                          */
2166                         m0 = m_get((mnw ? M_NOWAIT : M_WAITOK), MT_DATA);
2167                         if (m0 == NULL) {
2168                                 error = (mnw ? EAGAIN : ENOBUFS);
2169                                 sf_buf_mext((void *)sf_buf_kva(sf), sf);
2170                                 break;
2171                         }
2172                         MEXTADD(m0, sf_buf_kva(sf), PAGE_SIZE, sf_buf_mext,
2173                             sfs, sf, M_RDONLY, EXT_SFBUF);
2174                         m0->m_data = (char *)sf_buf_kva(sf) + pgoff;
2175                         m0->m_len = xfsize;
2176
2177                         /* Append to mbuf chain. */
2178                         if (mtail != NULL)
2179                                 mtail->m_next = m0;
2180                         else if (m != NULL)
2181                                 m_last(m)->m_next = m0;
2182                         else
2183                                 m = m0;
2184                         mtail = m0;
2185
2186                         /* Keep track of bits processed. */
2187                         loopbytes += xfsize;
2188                         off += xfsize;
2189
2190                         if (sfs != NULL) {
2191                                 mtx_lock(&sfs->mtx);
2192                                 sfs->count++;
2193                                 mtx_unlock(&sfs->mtx);
2194                         }
2195                 }
2196
2197                 /* Add the buffer chain to the socket buffer. */
2198                 if (m != NULL) {
2199                         int mlen, err;
2200
2201                         mlen = m_length(m, NULL);
2202                         SOCKBUF_LOCK(&so->so_snd);
2203                         if (so->so_snd.sb_state & SBS_CANTSENDMORE) {
2204                                 error = EPIPE;
2205                                 SOCKBUF_UNLOCK(&so->so_snd);
2206                                 goto done;
2207                         }
2208                         SOCKBUF_UNLOCK(&so->so_snd);
2209                         CURVNET_SET(so->so_vnet);
2210                         /* Avoid error aliasing. */
2211                         err = (*so->so_proto->pr_usrreqs->pru_send)
2212                                     (so, 0, m, NULL, NULL, td);
2213                         CURVNET_RESTORE();
2214                         if (err == 0) {
2215                                 /*
2216                                  * We need two counters to get the
2217                                  * file offset and nbytes to send
2218                                  * right:
2219                                  * - sbytes contains the total amount
2220                                  *   of bytes sent, including headers.
2221                                  * - fsbytes contains the total amount
2222                                  *   of bytes sent from the file.
2223                                  */
2224                                 sbytes += mlen;
2225                                 fsbytes += mlen;
2226                                 if (hdrlen) {
2227                                         fsbytes -= hdrlen;
2228                                         hdrlen = 0;
2229                                 }
2230                         } else if (error == 0)
2231                                 error = err;
2232                         m = NULL;       /* pru_send always consumes */
2233                 }
2234
2235                 /* Quit outer loop on error or when we're done. */
2236                 if (done)
2237                         break;
2238                 if (error)
2239                         goto done;
2240         }
2241
2242         /*
2243          * Send trailers. Wimp out and use writev(2).
2244          */
2245         if (trl_uio != NULL) {
2246                 sbunlock(&so->so_snd);
2247                 error = kern_writev(td, uap->s, trl_uio);
2248                 if (error == 0)
2249                         sbytes += td->td_retval[0];
2250                 goto out;
2251         }
2252
2253 done:
2254         sbunlock(&so->so_snd);
2255 out:
2256         /*
2257          * If there was no error we have to clear td->td_retval[0]
2258          * because it may have been set by writev.
2259          */
2260         if (error == 0) {
2261                 td->td_retval[0] = 0;
2262         }
2263         if (uap->sbytes != NULL) {
2264                 copyout(&sbytes, uap->sbytes, sizeof(off_t));
2265         }
2266         if (obj != NULL)
2267                 vm_object_deallocate(obj);
2268         if (vp != NULL)
2269                 vrele(vp);
2270         if (so)
2271                 fdrop(sock_fp, td);
2272         if (m)
2273                 m_freem(m);
2274
2275         if (sfs != NULL) {
2276                 mtx_lock(&sfs->mtx);
2277                 if (sfs->count != 0)
2278                         cv_wait(&sfs->cv, &sfs->mtx);
2279                 KASSERT(sfs->count == 0, ("sendfile sync still busy"));
2280                 cv_destroy(&sfs->cv);
2281                 mtx_destroy(&sfs->mtx);
2282                 free(sfs, M_TEMP);
2283         }
2284
2285         if (error == ERESTART)
2286                 error = EINTR;
2287
2288         return (error);
2289 }
2290
2291 /*
2292  * SCTP syscalls.
2293  * Functionality only compiled in if SCTP is defined in the kernel Makefile,
2294  * otherwise all return EOPNOTSUPP.
2295  * XXX: We should make this loadable one day.
2296  */
2297 int
2298 sys_sctp_peeloff(td, uap)
2299         struct thread *td;
2300         struct sctp_peeloff_args /* {
2301                 int     sd;
2302                 caddr_t name;
2303         } */ *uap;
2304 {
2305 #if (defined(INET) || defined(INET6)) && defined(SCTP)
2306         struct file *nfp = NULL;
2307         int error;
2308         struct socket *head, *so;
2309         int fd;
2310         u_int fflag;
2311
2312         AUDIT_ARG_FD(uap->sd);
2313         error = fgetsock(td, uap->sd, CAP_PEELOFF, &head, &fflag);
2314         if (error)
2315                 goto done2;
2316         if (head->so_proto->pr_protocol != IPPROTO_SCTP) {
2317                 error = EOPNOTSUPP;
2318                 goto done;
2319         }
2320         error = sctp_can_peel_off(head, (sctp_assoc_t)uap->name);
2321         if (error)
2322                 goto done;
2323         /*
2324          * At this point we know we do have a assoc to pull
2325          * we proceed to get the fd setup. This may block
2326          * but that is ok.
2327          */
2328
2329         error = falloc(td, &nfp, &fd, 0);
2330         if (error)
2331                 goto done;
2332         td->td_retval[0] = fd;
2333
2334         CURVNET_SET(head->so_vnet);
2335         so = sonewconn(head, SS_ISCONNECTED);
2336         if (so == NULL)
2337                 goto noconnection;
2338         /*
2339          * Before changing the flags on the socket, we have to bump the
2340          * reference count.  Otherwise, if the protocol calls sofree(),
2341          * the socket will be released due to a zero refcount.
2342          */
2343         SOCK_LOCK(so);
2344         soref(so);                      /* file descriptor reference */
2345         SOCK_UNLOCK(so);
2346
2347         ACCEPT_LOCK();
2348
2349         TAILQ_REMOVE(&head->so_comp, so, so_list);
2350         head->so_qlen--;
2351         so->so_state |= (head->so_state & SS_NBIO);
2352         so->so_state &= ~SS_NOFDREF;
2353         so->so_qstate &= ~SQ_COMP;
2354         so->so_head = NULL;
2355         ACCEPT_UNLOCK();
2356         finit(nfp, fflag, DTYPE_SOCKET, so, &socketops);
2357         error = sctp_do_peeloff(head, so, (sctp_assoc_t)uap->name);
2358         if (error)
2359                 goto noconnection;
2360         if (head->so_sigio != NULL)
2361                 fsetown(fgetown(&head->so_sigio), &so->so_sigio);
2362
2363 noconnection:
2364         /*
2365          * close the new descriptor, assuming someone hasn't ripped it
2366          * out from under us.
2367          */
2368         if (error)
2369                 fdclose(td->td_proc->p_fd, nfp, fd, td);
2370
2371         /*
2372          * Release explicitly held references before returning.
2373          */
2374         CURVNET_RESTORE();
2375 done:
2376         if (nfp != NULL)
2377                 fdrop(nfp, td);
2378         fputsock(head);
2379 done2:
2380         return (error);
2381 #else  /* SCTP */
2382         return (EOPNOTSUPP);
2383 #endif /* SCTP */
2384 }
2385
2386 int
2387 sys_sctp_generic_sendmsg (td, uap)
2388         struct thread *td;
2389         struct sctp_generic_sendmsg_args /* {
2390                 int sd,
2391                 caddr_t msg,
2392                 int mlen,
2393                 caddr_t to,
2394                 __socklen_t tolen,
2395                 struct sctp_sndrcvinfo *sinfo,
2396                 int flags
2397         } */ *uap;
2398 {
2399 #if (defined(INET) || defined(INET6)) && defined(SCTP)
2400         struct sctp_sndrcvinfo sinfo, *u_sinfo = NULL;
2401         struct socket *so;
2402         struct file *fp = NULL;
2403         int error = 0, len;
2404         struct sockaddr *to = NULL;
2405 #ifdef KTRACE
2406         struct uio *ktruio = NULL;
2407 #endif
2408         struct uio auio;
2409         struct iovec iov[1];
2410         cap_rights_t rights;
2411
2412         if (uap->sinfo) {
2413                 error = copyin(uap->sinfo, &sinfo, sizeof (sinfo));
2414                 if (error)
2415                         return (error);
2416                 u_sinfo = &sinfo;
2417         }
2418
2419         rights = CAP_WRITE;
2420         if (uap->tolen) {
2421                 error = getsockaddr(&to, uap->to, uap->tolen);
2422                 if (error) {
2423                         to = NULL;
2424                         goto sctp_bad2;
2425                 }
2426                 rights |= CAP_CONNECT;
2427         }
2428
2429         AUDIT_ARG_FD(uap->sd);
2430         error = getsock_cap(td->td_proc->p_fd, uap->sd, rights, &fp, NULL);
2431         if (error)
2432                 goto sctp_bad;
2433 #ifdef KTRACE
2434         if (to && (KTRPOINT(td, KTR_STRUCT)))
2435                 ktrsockaddr(to);
2436 #endif
2437
2438         iov[0].iov_base = uap->msg;
2439         iov[0].iov_len = uap->mlen;
2440
2441         so = (struct socket *)fp->f_data;
2442         if (so->so_proto->pr_protocol != IPPROTO_SCTP) {
2443                 error = EOPNOTSUPP;
2444                 goto sctp_bad;
2445         }
2446 #ifdef MAC
2447         error = mac_socket_check_send(td->td_ucred, so);
2448         if (error)
2449                 goto sctp_bad;
2450 #endif /* MAC */
2451
2452         auio.uio_iov =  iov;
2453         auio.uio_iovcnt = 1;
2454         auio.uio_segflg = UIO_USERSPACE;
2455         auio.uio_rw = UIO_WRITE;
2456         auio.uio_td = td;
2457         auio.uio_offset = 0;                    /* XXX */
2458         auio.uio_resid = 0;
2459         len = auio.uio_resid = uap->mlen;
2460         CURVNET_SET(so->so_vnet);
2461         error = sctp_lower_sosend(so, to, &auio,
2462                     (struct mbuf *)NULL, (struct mbuf *)NULL,
2463                     uap->flags, u_sinfo, td);
2464         CURVNET_RESTORE();
2465         if (error) {
2466                 if (auio.uio_resid != len && (error == ERESTART ||
2467                     error == EINTR || error == EWOULDBLOCK))
2468                         error = 0;
2469                 /* Generation of SIGPIPE can be controlled per socket. */
2470                 if (error == EPIPE && !(so->so_options & SO_NOSIGPIPE) &&
2471                     !(uap->flags & MSG_NOSIGNAL)) {
2472                         PROC_LOCK(td->td_proc);
2473                         tdsignal(td, SIGPIPE);
2474                         PROC_UNLOCK(td->td_proc);
2475                 }
2476         }
2477         if (error == 0)
2478                 td->td_retval[0] = len - auio.uio_resid;
2479 #ifdef KTRACE
2480         if (ktruio != NULL) {
2481                 ktruio->uio_resid = td->td_retval[0];
2482                 ktrgenio(uap->sd, UIO_WRITE, ktruio, error);
2483         }
2484 #endif /* KTRACE */
2485 sctp_bad:
2486         if (fp)
2487                 fdrop(fp, td);
2488 sctp_bad2:
2489         if (to)
2490                 free(to, M_SONAME);
2491         return (error);
2492 #else  /* SCTP */
2493         return (EOPNOTSUPP);
2494 #endif /* SCTP */
2495 }
2496
2497 int
2498 sys_sctp_generic_sendmsg_iov(td, uap)
2499         struct thread *td;
2500         struct sctp_generic_sendmsg_iov_args /* {
2501                 int sd,
2502                 struct iovec *iov,
2503                 int iovlen,
2504                 caddr_t to,
2505                 __socklen_t tolen,
2506                 struct sctp_sndrcvinfo *sinfo,
2507                 int flags
2508         } */ *uap;
2509 {
2510 #if (defined(INET) || defined(INET6)) && defined(SCTP)
2511         struct sctp_sndrcvinfo sinfo, *u_sinfo = NULL;
2512         struct socket *so;
2513         struct file *fp = NULL;
2514         int error=0, i;
2515         ssize_t len;
2516         struct sockaddr *to = NULL;
2517 #ifdef KTRACE
2518         struct uio *ktruio = NULL;
2519 #endif
2520         struct uio auio;
2521         struct iovec *iov, *tiov;
2522         cap_rights_t rights;
2523
2524         if (uap->sinfo) {
2525                 error = copyin(uap->sinfo, &sinfo, sizeof (sinfo));
2526                 if (error)
2527                         return (error);
2528                 u_sinfo = &sinfo;
2529         }
2530         rights = CAP_WRITE;
2531         if (uap->tolen) {
2532                 error = getsockaddr(&to, uap->to, uap->tolen);
2533                 if (error) {
2534                         to = NULL;
2535                         goto sctp_bad2;
2536                 }
2537                 rights |= CAP_CONNECT;
2538         }
2539
2540         AUDIT_ARG_FD(uap->sd);
2541         error = getsock_cap(td->td_proc->p_fd, uap->sd, rights, &fp, NULL);
2542         if (error)
2543                 goto sctp_bad1;
2544
2545 #ifdef COMPAT_FREEBSD32
2546         if (SV_CURPROC_FLAG(SV_ILP32))
2547                 error = freebsd32_copyiniov((struct iovec32 *)uap->iov,
2548                     uap->iovlen, &iov, EMSGSIZE);
2549         else
2550 #endif
2551                 error = copyiniov(uap->iov, uap->iovlen, &iov, EMSGSIZE);
2552         if (error)
2553                 goto sctp_bad1;
2554 #ifdef KTRACE
2555         if (to && (KTRPOINT(td, KTR_STRUCT)))
2556                 ktrsockaddr(to);
2557 #endif
2558
2559         so = (struct socket *)fp->f_data;
2560         if (so->so_proto->pr_protocol != IPPROTO_SCTP) {
2561                 error = EOPNOTSUPP;
2562                 goto sctp_bad;
2563         }
2564 #ifdef MAC
2565         error = mac_socket_check_send(td->td_ucred, so);
2566         if (error)
2567                 goto sctp_bad;
2568 #endif /* MAC */
2569
2570         auio.uio_iov = iov;
2571         auio.uio_iovcnt = uap->iovlen;
2572         auio.uio_segflg = UIO_USERSPACE;
2573         auio.uio_rw = UIO_WRITE;
2574         auio.uio_td = td;
2575         auio.uio_offset = 0;                    /* XXX */
2576         auio.uio_resid = 0;
2577         tiov = iov;
2578         for (i = 0; i <uap->iovlen; i++, tiov++) {
2579                 if ((auio.uio_resid += tiov->iov_len) < 0) {
2580                         error = EINVAL;
2581                         goto sctp_bad;
2582                 }
2583         }
2584         len = auio.uio_resid;
2585         CURVNET_SET(so->so_vnet);
2586         error = sctp_lower_sosend(so, to, &auio,
2587                     (struct mbuf *)NULL, (struct mbuf *)NULL,
2588                     uap->flags, u_sinfo, td);
2589         CURVNET_RESTORE();
2590         if (error) {
2591                 if (auio.uio_resid != len && (error == ERESTART ||
2592                     error == EINTR || error == EWOULDBLOCK))
2593                         error = 0;
2594                 /* Generation of SIGPIPE can be controlled per socket */
2595                 if (error == EPIPE && !(so->so_options & SO_NOSIGPIPE) &&
2596                     !(uap->flags & MSG_NOSIGNAL)) {
2597                         PROC_LOCK(td->td_proc);
2598                         tdsignal(td, SIGPIPE);
2599                         PROC_UNLOCK(td->td_proc);
2600                 }
2601         }
2602         if (error == 0)
2603                 td->td_retval[0] = len - auio.uio_resid;
2604 #ifdef KTRACE
2605         if (ktruio != NULL) {
2606                 ktruio->uio_resid = td->td_retval[0];
2607                 ktrgenio(uap->sd, UIO_WRITE, ktruio, error);
2608         }
2609 #endif /* KTRACE */
2610 sctp_bad:
2611         free(iov, M_IOV);
2612 sctp_bad1:
2613         if (fp)
2614                 fdrop(fp, td);
2615 sctp_bad2:
2616         if (to)
2617                 free(to, M_SONAME);
2618         return (error);
2619 #else  /* SCTP */
2620         return (EOPNOTSUPP);
2621 #endif /* SCTP */
2622 }
2623
2624 int
2625 sys_sctp_generic_recvmsg(td, uap)
2626         struct thread *td;
2627         struct sctp_generic_recvmsg_args /* {
2628                 int sd,
2629                 struct iovec *iov,
2630                 int iovlen,
2631                 struct sockaddr *from,
2632                 __socklen_t *fromlenaddr,
2633                 struct sctp_sndrcvinfo *sinfo,
2634                 int *msg_flags
2635         } */ *uap;
2636 {
2637 #if (defined(INET) || defined(INET6)) && defined(SCTP)
2638         uint8_t sockbufstore[256];
2639         struct uio auio;
2640         struct iovec *iov, *tiov;
2641         struct sctp_sndrcvinfo sinfo;
2642         struct socket *so;
2643         struct file *fp = NULL;
2644         struct sockaddr *fromsa;
2645         int fromlen;
2646         ssize_t len;
2647         int i, msg_flags;
2648         int error = 0;
2649 #ifdef KTRACE
2650         struct uio *ktruio = NULL;
2651 #endif
2652
2653         AUDIT_ARG_FD(uap->sd);
2654         error = getsock_cap(td->td_proc->p_fd, uap->sd, CAP_READ, &fp, NULL);
2655         if (error) {
2656                 return (error);
2657         }
2658 #ifdef COMPAT_FREEBSD32
2659         if (SV_CURPROC_FLAG(SV_ILP32))
2660                 error = freebsd32_copyiniov((struct iovec32 *)uap->iov,
2661                     uap->iovlen, &iov, EMSGSIZE);
2662         else
2663 #endif
2664                 error = copyiniov(uap->iov, uap->iovlen, &iov, EMSGSIZE);
2665         if (error)
2666                 goto out1;
2667
2668         so = fp->f_data;
2669         if (so->so_proto->pr_protocol != IPPROTO_SCTP) {
2670                 error = EOPNOTSUPP;
2671                 goto out;
2672         }
2673 #ifdef MAC
2674         error = mac_socket_check_receive(td->td_ucred, so);
2675         if (error) {
2676                 goto out;
2677         }
2678 #endif /* MAC */
2679
2680         if (uap->fromlenaddr) {
2681                 error = copyin(uap->fromlenaddr,
2682                     &fromlen, sizeof (fromlen));
2683                 if (error) {
2684                         goto out;
2685                 }
2686         } else {
2687                 fromlen = 0;
2688         }
2689         if (uap->msg_flags) {
2690                 error = copyin(uap->msg_flags, &msg_flags, sizeof (int));
2691                 if (error) {
2692                         goto out;
2693                 }
2694         } else {
2695                 msg_flags = 0;
2696         }
2697         auio.uio_iov = iov;
2698         auio.uio_iovcnt = uap->iovlen;
2699         auio.uio_segflg = UIO_USERSPACE;
2700         auio.uio_rw = UIO_READ;
2701         auio.uio_td = td;
2702         auio.uio_offset = 0;                    /* XXX */
2703         auio.uio_resid = 0;
2704         tiov = iov;
2705         for (i = 0; i <uap->iovlen; i++, tiov++) {
2706                 if ((auio.uio_resid += tiov->iov_len) < 0) {
2707                         error = EINVAL;
2708                         goto out;
2709                 }
2710         }
2711         len = auio.uio_resid;
2712         fromsa = (struct sockaddr *)sockbufstore;
2713
2714 #ifdef KTRACE
2715         if (KTRPOINT(td, KTR_GENIO))
2716                 ktruio = cloneuio(&auio);
2717 #endif /* KTRACE */
2718         memset(&sinfo, 0, sizeof(struct sctp_sndrcvinfo));
2719         CURVNET_SET(so->so_vnet);
2720         error = sctp_sorecvmsg(so, &auio, (struct mbuf **)NULL,
2721                     fromsa, fromlen, &msg_flags,
2722                     (struct sctp_sndrcvinfo *)&sinfo, 1);
2723         CURVNET_RESTORE();
2724         if (error) {
2725                 if (auio.uio_resid != len && (error == ERESTART ||
2726                     error == EINTR || error == EWOULDBLOCK))
2727                         error = 0;
2728         } else {
2729                 if (uap->sinfo)
2730                         error = copyout(&sinfo, uap->sinfo, sizeof (sinfo));
2731         }
2732 #ifdef KTRACE
2733         if (ktruio != NULL) {
2734                 ktruio->uio_resid = len - auio.uio_resid;
2735                 ktrgenio(uap->sd, UIO_READ, ktruio, error);
2736         }
2737 #endif /* KTRACE */
2738         if (error)
2739                 goto out;
2740         td->td_retval[0] = len - auio.uio_resid;
2741
2742         if (fromlen && uap->from) {
2743                 len = fromlen;
2744                 if (len <= 0 || fromsa == 0)
2745                         len = 0;
2746                 else {
2747                         len = MIN(len, fromsa->sa_len);
2748                         error = copyout(fromsa, uap->from, (size_t)len);
2749                         if (error)
2750                                 goto out;
2751                 }
2752                 error = copyout(&len, uap->fromlenaddr, sizeof (socklen_t));
2753                 if (error) {
2754                         goto out;
2755                 }
2756         }
2757 #ifdef KTRACE
2758         if (KTRPOINT(td, KTR_STRUCT))
2759                 ktrsockaddr(fromsa);
2760 #endif
2761         if (uap->msg_flags) {
2762                 error = copyout(&msg_flags, uap->msg_flags, sizeof (int));
2763                 if (error) {
2764                         goto out;
2765                 }
2766         }
2767 out:
2768         free(iov, M_IOV);
2769 out1:
2770         if (fp)
2771                 fdrop(fp, td);
2772
2773         return (error);
2774 #else  /* SCTP */
2775         return (EOPNOTSUPP);
2776 #endif /* SCTP */
2777 }