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  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by the University of
  19  *      California, Berkeley and its contributors.
  20  * 4. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  *
  36  *      @(#)uipc_syscalls.c     8.4 (Berkeley) 2/21/94
  37  * $FreeBSD: src/sys/kern/uipc_syscalls.c,v 1.65.2.17 2003/04/04 17:11:16 tegge Exp $
  38  * $DragonFly: src/sys/kern/uipc_syscalls.c,v 1.2 2003/06/17 04:28:41 dillon Exp $
  39  */
  40
  41 #include "opt_compat.h"
  42 #include "opt_ktrace.h"
  43
  44 #include <sys/param.h>
  45 #include <sys/systm.h>
  46 #include <sys/kernel.h>
  47 #include <sys/sysproto.h>
  48 #include <sys/malloc.h>
  49 #include <sys/filedesc.h>
  50 #include <sys/event.h>
  51 #include <sys/proc.h>
  52 #include <sys/fcntl.h>
  53 #include <sys/file.h>
  54 #include <sys/filio.h>
  55 #include <sys/mbuf.h>
  56 #include <sys/protosw.h>
  57 #include <sys/socket.h>
  58 #include <sys/socketvar.h>
  59 #include <sys/signalvar.h>
  60 #include <sys/uio.h>
  61 #include <sys/vnode.h>
  62 #include <sys/lock.h>
  63 #include <sys/mount.h>
  64 #ifdef KTRACE
  65 #include <sys/ktrace.h>
  66 #endif
  67 #include <vm/vm.h>
  68 #include <vm/vm_object.h>
  69 #include <vm/vm_page.h>
  70 #include <vm/vm_pageout.h>
  71 #include <vm/vm_kern.h>
  72 #include <vm/vm_extern.h>
  73
  74 static void sf_buf_init(void *arg);
  75 SYSINIT(sock_sf, SI_SUB_MBUF, SI_ORDER_ANY, sf_buf_init, NULL)
  76
  77 static int sendit __P((struct proc *p, int s, struct msghdr *mp, int flags));
  78 static int recvit __P((struct proc *p, int s, struct msghdr *mp,
  79                        caddr_t namelenp));
  80
  81 static int accept1 __P((struct proc *p, struct accept_args *uap, int compat));
  82 static int do_sendfile __P((struct proc *p, struct sendfile_args *uap,
  83                             int compat));
  84 static int getsockname1 __P((struct proc *p, struct getsockname_args *uap,
  85                              int compat));
  86 static int getpeername1 __P((struct proc *p, struct getpeername_args *uap,
  87                              int compat));
  88
  89 static SLIST_HEAD(, sf_buf) sf_freelist;
  90 static vm_offset_t sf_base;
  91 static struct sf_buf *sf_bufs;
  92 static int sf_buf_alloc_want;
  93
  94 /*
  95  * System call interface to the socket abstraction.
  96  */
  97 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
  98 #define COMPAT_OLDSOCK
  99 #endif
 100
 101 extern  struct fileops socketops;
 102
 103 int
 104 socket(p, uap)
 105         struct proc *p;
 106         register struct socket_args /* {
 107                 int     domain;
 108                 int     type;
 109                 int     protocol;
 110         } */ *uap;
 111 {
 112         struct filedesc *fdp = p->p_fd;
 113         struct socket *so;
 114         struct file *fp;
 115         int fd, error;
 116
 117         error = falloc(p, &fp, &fd);
 118         if (error)
 119                 return (error);
 120         fhold(fp);
 121         error = socreate(uap->domain, &so, uap->type, uap->protocol, p);
 122         if (error) {
 123                 if (fdp->fd_ofiles[fd] == fp) {
 124                         fdp->fd_ofiles[fd] = NULL;
 125                         fdrop(fp, p);
 126                 }
 127         } else {
 128                 fp->f_data = (caddr_t)so;
 129                 fp->f_flag = FREAD|FWRITE;
 130                 fp->f_ops = &socketops;
 131                 fp->f_type = DTYPE_SOCKET;
 132                 p->p_retval[0] = fd;
 133         }
 134         fdrop(fp, p);
 135         return (error);
 136 }
 137
 138 /* ARGSUSED */
 139 int
 140 bind(p, uap)
 141         struct proc *p;
 142         register struct bind_args /* {
 143                 int     s;
 144                 caddr_t name;
 145                 int     namelen;
 146         } */ *uap;
 147 {
 148         struct file *fp;
 149         struct sockaddr *sa;
 150         int error;
 151
 152         error = holdsock(p->p_fd, uap->s, &fp);
 153         if (error)
 154                 return (error);
 155         error = getsockaddr(&sa, uap->name, uap->namelen);
 156         if (error) {
 157                 fdrop(fp, p);
 158                 return (error);
 159         }
 160         error = sobind((struct socket *)fp->f_data, sa, p);
 161         FREE(sa, M_SONAME);
 162         fdrop(fp, p);
 163         return (error);
 164 }
 165
 166 /* ARGSUSED */
 167 int
 168 listen(p, uap)
 169         struct proc *p;
 170         register struct listen_args /* {
 171                 int     s;
 172                 int     backlog;
 173         } */ *uap;
 174 {
 175         struct file *fp;
 176         int error;
 177
 178         error = holdsock(p->p_fd, uap->s, &fp);
 179         if (error)
 180                 return (error);
 181         error = solisten((struct socket *)fp->f_data, uap->backlog, p);
 182         fdrop(fp, p);
 183         return(error);
 184 }
 185
 186 static int
 187 accept1(p, uap, compat)
 188         struct proc *p;
 189         register struct accept_args /* {
 190                 int     s;
 191                 caddr_t name;
 192                 int     *anamelen;
 193         } */ *uap;
 194         int compat;
 195 {
 196         struct filedesc *fdp = p->p_fd;
 197         struct file *lfp = NULL;
 198         struct file *nfp = NULL;
 199         struct sockaddr *sa;
 200         int namelen, error, s;
 201         struct socket *head, *so;
 202         int fd;
 203         u_int fflag;            /* type must match fp->f_flag */
 204         int tmp;
 205
 206         if (uap->name) {
 207                 error = copyin((caddr_t)uap->anamelen, (caddr_t)&namelen,
 208                         sizeof (namelen));
 209                 if(error)
 210                         return (error);
 211                 if (namelen < 0)
 212                         return (EINVAL);
 213         }
 214         error = holdsock(fdp, uap->s, &lfp);
 215         if (error)
 216                 return (error);
 217         s = splnet();
 218         head = (struct socket *)lfp->f_data;
 219         if ((head->so_options & SO_ACCEPTCONN) == 0) {
 220                 splx(s);
 221                 error = EINVAL;
 222                 goto done;
 223         }
 224         while (TAILQ_EMPTY(&head->so_comp) && head->so_error == 0) {
 225                 if (head->so_state & SS_CANTRCVMORE) {
 226                         head->so_error = ECONNABORTED;
 227                         break;
 228                 }
 229                 if ((head->so_state & SS_NBIO) != 0) {
 230                         head->so_error = EWOULDBLOCK;
 231                         break;
 232                 }
 233                 error = tsleep((caddr_t)&head->so_timeo, PSOCK | PCATCH,
 234                     "accept", 0);
 235                 if (error) {
 236                         splx(s);
 237                         goto done;
 238                 }
 239         }
 240         if (head->so_error) {
 241                 error = head->so_error;
 242                 head->so_error = 0;
 243                 splx(s);
 244                 goto done;
 245         }
 246
 247         /*
 248          * At this point we know that there is at least one connection
 249          * ready to be accepted. Remove it from the queue prior to
 250          * allocating the file descriptor for it since falloc() may
 251          * block allowing another process to accept the connection
 252          * instead.
 253          */
 254         so = TAILQ_FIRST(&head->so_comp);
 255         TAILQ_REMOVE(&head->so_comp, so, so_list);
 256         head->so_qlen--;
 257
 258         fflag = lfp->f_flag;
 259         error = falloc(p, &nfp, &fd);
 260         if (error) {
 261                 /*
 262                  * Probably ran out of file descriptors. Put the
 263                  * unaccepted connection back onto the queue and
 264                  * do another wakeup so some other process might
 265                  * have a chance at it.
 266                  */
 267                 TAILQ_INSERT_HEAD(&head->so_comp, so, so_list);
 268                 head->so_qlen++;
 269                 wakeup_one(&head->so_timeo);
 270                 splx(s);
 271                 goto done;
 272         }
 273         fhold(nfp);
 274         p->p_retval[0] = fd;
 275
 276         /* connection has been removed from the listen queue */
 277         KNOTE(&head->so_rcv.sb_sel.si_note, 0);
 278
 279         so->so_state &= ~SS_COMP;
 280         so->so_head = NULL;
 281         if (head->so_sigio != NULL)
 282                 fsetown(fgetown(head->so_sigio), &so->so_sigio);
 283
 284         nfp->f_data = (caddr_t)so;
 285         nfp->f_flag = fflag;
 286         nfp->f_ops = &socketops;
 287         nfp->f_type = DTYPE_SOCKET;
 288         /* Sync socket nonblocking/async state with file flags */
 289         tmp = fflag & FNONBLOCK;
 290         (void) fo_ioctl(nfp, FIONBIO, (caddr_t)&tmp, p);
 291         tmp = fflag & FASYNC;
 292         (void) fo_ioctl(nfp, FIOASYNC, (caddr_t)&tmp, p);
 293         sa = 0;
 294         error = soaccept(so, &sa);
 295         if (error) {
 296                 /*
 297                  * return a namelen of zero for older code which might
 298                  * ignore the return value from accept.
 299                  */
 300                 if (uap->name != NULL) {
 301                         namelen = 0;
 302                         (void) copyout((caddr_t)&namelen,
 303                             (caddr_t)uap->anamelen, sizeof(*uap->anamelen));
 304                 }
 305                 goto noconnection;
 306         }
 307         if (sa == NULL) {
 308                 namelen = 0;
 309                 if (uap->name)
 310                         goto gotnoname;
 311                 splx(s);
 312                 error = 0;
 313                 goto done;
 314         }
 315         if (uap->name) {
 316                 /* check sa_len before it is destroyed */
 317                 if (namelen > sa->sa_len)
 318                         namelen = sa->sa_len;
 319 #ifdef COMPAT_OLDSOCK
 320                 if (compat)
 321                         ((struct osockaddr *)sa)->sa_family =
 322                             sa->sa_family;
 323 #endif
 324                 error = copyout(sa, (caddr_t)uap->name, (u_int)namelen);
 325                 if (!error)
 326 gotnoname:
 327                         error = copyout((caddr_t)&namelen,
 328                             (caddr_t)uap->anamelen, sizeof (*uap->anamelen));
 329         }
 330 noconnection:
 331         if (sa)
 332                 FREE(sa, M_SONAME);
 333
 334         /*
 335          * close the new descriptor, assuming someone hasn't ripped it
 336          * out from under us.
 337          */
 338         if (error) {
 339                 if (fdp->fd_ofiles[fd] == nfp) {
 340                         fdp->fd_ofiles[fd] = NULL;
 341                         fdrop(nfp, p);
 342                 }
 343         }
 344         splx(s);
 345
 346         /*
 347          * Release explicitly held references before returning.
 348          */
 349 done:
 350         if (nfp != NULL)
 351                 fdrop(nfp, p);
 352         fdrop(lfp, p);
 353         return (error);
 354 }
 355
 356 int
 357 accept(p, uap)
 358         struct proc *p;
 359         struct accept_args *uap;
 360 {
 361
 362         return (accept1(p, uap, 0));
 363 }
 364
 365 #ifdef COMPAT_OLDSOCK
 366 int
 367 oaccept(p, uap)
 368         struct proc *p;
 369         struct accept_args *uap;
 370 {
 371
 372         return (accept1(p, uap, 1));
 373 }
 374 #endif /* COMPAT_OLDSOCK */
 375
 376 /* ARGSUSED */
 377 int
 378 connect(p, uap)
 379         struct proc *p;
 380         register struct connect_args /* {
 381                 int     s;
 382                 caddr_t name;
 383                 int     namelen;
 384         } */ *uap;
 385 {
 386         struct file *fp;
 387         register struct socket *so;
 388         struct sockaddr *sa;
 389         int error, s;
 390
 391         error = holdsock(p->p_fd, uap->s, &fp);
 392         if (error)
 393                 return (error);
 394         so = (struct socket *)fp->f_data;
 395         if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) {
 396                 error = EALREADY;
 397                 goto done;
 398         }
 399         error = getsockaddr(&sa, uap->name, uap->namelen);
 400         if (error)
 401                 goto done;
 402         error = soconnect(so, sa, p);
 403         if (error)
 404                 goto bad;
 405         if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) {
 406                 FREE(sa, M_SONAME);
 407                 error = EINPROGRESS;
 408                 goto done;
 409         }
 410         s = splnet();
 411         while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
 412                 error = tsleep((caddr_t)&so->so_timeo, PSOCK | PCATCH,
 413                     "connec", 0);
 414                 if (error)
 415                         break;
 416         }
 417         if (error == 0) {
 418                 error = so->so_error;
 419                 so->so_error = 0;
 420         }
 421         splx(s);
 422 bad:
 423         so->so_state &= ~SS_ISCONNECTING;
 424         FREE(sa, M_SONAME);
 425         if (error == ERESTART)
 426                 error = EINTR;
 427 done:
 428         fdrop(fp, p);
 429         return (error);
 430 }
 431
 432 int
 433 socketpair(p, uap)
 434         struct proc *p;
 435         register struct socketpair_args /* {
 436                 int     domain;
 437                 int     type;
 438                 int     protocol;
 439                 int     *rsv;
 440         } */ *uap;
 441 {
 442         register struct filedesc *fdp = p->p_fd;
 443         struct file *fp1, *fp2;
 444         struct socket *so1, *so2;
 445         int fd, error, sv[2];
 446
 447         error = socreate(uap->domain, &so1, uap->type, uap->protocol, p);
 448         if (error)
 449                 return (error);
 450         error = socreate(uap->domain, &so2, uap->type, uap->protocol, p);
 451         if (error)
 452                 goto free1;
 453         error = falloc(p, &fp1, &fd);
 454         if (error)
 455                 goto free2;
 456         fhold(fp1);
 457         sv[0] = fd;
 458         fp1->f_data = (caddr_t)so1;
 459         error = falloc(p, &fp2, &fd);
 460         if (error)
 461                 goto free3;
 462         fhold(fp2);
 463         fp2->f_data = (caddr_t)so2;
 464         sv[1] = fd;
 465         error = soconnect2(so1, so2);
 466         if (error)
 467                 goto free4;
 468         if (uap->type == SOCK_DGRAM) {
 469                 /*
 470                  * Datagram socket connection is asymmetric.
 471                  */
 472                  error = soconnect2(so2, so1);
 473                  if (error)
 474                         goto free4;
 475         }
 476         fp1->f_flag = fp2->f_flag = FREAD|FWRITE;
 477         fp1->f_ops = fp2->f_ops = &socketops;
 478         fp1->f_type = fp2->f_type = DTYPE_SOCKET;
 479         error = copyout((caddr_t)sv, (caddr_t)uap->rsv, 2 * sizeof (int));
 480         fdrop(fp1, p);
 481         fdrop(fp2, p);
 482         return (error);
 483 free4:
 484         if (fdp->fd_ofiles[sv[1]] == fp2) {
 485                 fdp->fd_ofiles[sv[1]] = NULL;
 486                 fdrop(fp2, p);
 487         }
 488         fdrop(fp2, p);
 489 free3:
 490         if (fdp->fd_ofiles[sv[0]] == fp1) {
 491                 fdp->fd_ofiles[sv[0]] = NULL;
 492                 fdrop(fp1, p);
 493         }
 494         fdrop(fp1, p);
 495 free2:
 496         (void)soclose(so2);
 497 free1:
 498         (void)soclose(so1);
 499         return (error);
 500 }
 501
 502 static int
 503 sendit(p, s, mp, flags)
 504         register struct proc *p;
 505         int s;
 506         register struct msghdr *mp;
 507         int flags;
 508 {
 509         struct file *fp;
 510         struct uio auio;
 511         register struct iovec *iov;
 512         register int i;
 513         struct mbuf *control;
 514         struct sockaddr *to;
 515         int len, error;
 516         struct socket *so;
 517 #ifdef KTRACE
 518         struct iovec *ktriov = NULL;
 519         struct uio ktruio;
 520 #endif
 521
 522         error = holdsock(p->p_fd, s, &fp);
 523         if (error)
 524                 return (error);
 525         auio.uio_iov = mp->msg_iov;
 526         auio.uio_iovcnt = mp->msg_iovlen;
 527         auio.uio_segflg = UIO_USERSPACE;
 528         auio.uio_rw = UIO_WRITE;
 529         auio.uio_procp = p;
 530         auio.uio_offset = 0;                    /* XXX */
 531         auio.uio_resid = 0;
 532         iov = mp->msg_iov;
 533         for (i = 0; i < mp->msg_iovlen; i++, iov++) {
 534                 if ((auio.uio_resid += iov->iov_len) < 0) {
 535                         fdrop(fp, p);
 536                         return (EINVAL);
 537                 }
 538         }
 539         if (mp->msg_name) {
 540                 error = getsockaddr(&to, mp->msg_name, mp->msg_namelen);
 541                 if (error) {
 542                         fdrop(fp, p);
 543                         return (error);
 544                 }
 545         } else {
 546                 to = 0;
 547         }
 548         if (mp->msg_control) {
 549                 if (mp->msg_controllen < sizeof(struct cmsghdr)
 550 #ifdef COMPAT_OLDSOCK
 551                     && mp->msg_flags != MSG_COMPAT
 552 #endif
 553                 ) {
 554                         error = EINVAL;
 555                         goto bad;
 556                 }
 557                 error = sockargs(&control, mp->msg_control,
 558                     mp->msg_controllen, MT_CONTROL);
 559                 if (error)
 560                         goto bad;
 561 #ifdef COMPAT_OLDSOCK
 562                 if (mp->msg_flags == MSG_COMPAT) {
 563                         register struct cmsghdr *cm;
 564
 565                         M_PREPEND(control, sizeof(*cm), M_WAIT);
 566                         if (control == 0) {
 567                                 error = ENOBUFS;
 568                                 goto bad;
 569                         } else {
 570                                 cm = mtod(control, struct cmsghdr *);
 571                                 cm->cmsg_len = control->m_len;
 572                                 cm->cmsg_level = SOL_SOCKET;
 573                                 cm->cmsg_type = SCM_RIGHTS;
 574                         }
 575                 }
 576 #endif
 577         } else {
 578                 control = 0;
 579         }
 580 #ifdef KTRACE
 581         if (KTRPOINT(p, KTR_GENIO)) {
 582                 int iovlen = auio.uio_iovcnt * sizeof (struct iovec);
 583
 584                 MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
 585                 bcopy((caddr_t)auio.uio_iov, (caddr_t)ktriov, iovlen);
 586                 ktruio = auio;
 587         }
 588 #endif
 589         len = auio.uio_resid;
 590         so = (struct socket *)fp->f_data;
 591         error = so->so_proto->pr_usrreqs->pru_sosend(so, to, &auio, 0, control,
 592                                                      flags, p);
 593         if (error) {
 594                 if (auio.uio_resid != len && (error == ERESTART ||
 595                     error == EINTR || error == EWOULDBLOCK))
 596                         error = 0;
 597                 if (error == EPIPE)
 598                         psignal(p, SIGPIPE);
 599         }
 600         if (error == 0)
 601                 p->p_retval[0] = len - auio.uio_resid;
 602 #ifdef KTRACE
 603         if (ktriov != NULL) {
 604                 if (error == 0) {
 605                         ktruio.uio_iov = ktriov;
 606                         ktruio.uio_resid = p->p_retval[0];
 607                         ktrgenio(p->p_tracep, s, UIO_WRITE, &ktruio, error);
 608                 }
 609                 FREE(ktriov, M_TEMP);
 610         }
 611 #endif
 612 bad:
 613         fdrop(fp, p);
 614         if (to)
 615                 FREE(to, M_SONAME);
 616         return (error);
 617 }
 618
 619 int
 620 sendto(p, uap)
 621         struct proc *p;
 622         register struct sendto_args /* {
 623                 int     s;
 624                 caddr_t buf;
 625                 size_t  len;
 626                 int     flags;
 627                 caddr_t to;
 628                 int     tolen;
 629         } */ *uap;
 630 {
 631         struct msghdr msg;
 632         struct iovec aiov;
 633
 634         msg.msg_name = uap->to;
 635         msg.msg_namelen = uap->tolen;
 636         msg.msg_iov = &aiov;
 637         msg.msg_iovlen = 1;
 638         msg.msg_control = 0;
 639 #ifdef COMPAT_OLDSOCK
 640         msg.msg_flags = 0;
 641 #endif
 642         aiov.iov_base = uap->buf;
 643         aiov.iov_len = uap->len;
 644         return (sendit(p, uap->s, &msg, uap->flags));
 645 }
 646
 647 #ifdef COMPAT_OLDSOCK
 648 int
 649 osend(p, uap)
 650         struct proc *p;
 651         register struct osend_args /* {
 652                 int     s;
 653                 caddr_t buf;
 654                 int     len;
 655                 int     flags;
 656         } */ *uap;
 657 {
 658         struct msghdr msg;
 659         struct iovec aiov;
 660
 661         msg.msg_name = 0;
 662         msg.msg_namelen = 0;
 663         msg.msg_iov = &aiov;
 664         msg.msg_iovlen = 1;
 665         aiov.iov_base = uap->buf;
 666         aiov.iov_len = uap->len;
 667         msg.msg_control = 0;
 668         msg.msg_flags = 0;
 669         return (sendit(p, uap->s, &msg, uap->flags));
 670 }
 671
 672 int
 673 osendmsg(p, uap)
 674         struct proc *p;
 675         register struct osendmsg_args /* {
 676                 int     s;
 677                 caddr_t msg;
 678                 int     flags;
 679         } */ *uap;
 680 {
 681         struct msghdr msg;
 682         struct iovec aiov[UIO_SMALLIOV], *iov;
 683         int error;
 684
 685         error = copyin(uap->msg, (caddr_t)&msg, sizeof (struct omsghdr));
 686         if (error)
 687                 return (error);
 688         if ((u_int)msg.msg_iovlen >= UIO_SMALLIOV) {
 689                 if ((u_int)msg.msg_iovlen >= UIO_MAXIOV)
 690                         return (EMSGSIZE);
 691                 MALLOC(iov, struct iovec *,
 692                       sizeof(struct iovec) * (u_int)msg.msg_iovlen, M_IOV,
 693                       M_WAITOK);
 694         } else
 695                 iov = aiov;
 696         error = copyin((caddr_t)msg.msg_iov, (caddr_t)iov,
 697             (unsigned)(msg.msg_iovlen * sizeof (struct iovec)));
 698         if (error)
 699                 goto done;
 700         msg.msg_flags = MSG_COMPAT;
 701         msg.msg_iov = iov;
 702         error = sendit(p, uap->s, &msg, uap->flags);
 703 done:
 704         if (iov != aiov)
 705                 FREE(iov, M_IOV);
 706         return (error);
 707 }
 708 #endif
 709
 710 int
 711 sendmsg(p, uap)
 712         struct proc *p;
 713         register struct sendmsg_args /* {
 714                 int     s;
 715                 caddr_t msg;
 716                 int     flags;
 717         } */ *uap;
 718 {
 719         struct msghdr msg;
 720         struct iovec aiov[UIO_SMALLIOV], *iov;
 721         int error;
 722
 723         error = copyin(uap->msg, (caddr_t)&msg, sizeof (msg));
 724         if (error)
 725                 return (error);
 726         if ((u_int)msg.msg_iovlen >= UIO_SMALLIOV) {
 727                 if ((u_int)msg.msg_iovlen >= UIO_MAXIOV)
 728                         return (EMSGSIZE);
 729                 MALLOC(iov, struct iovec *,
 730                        sizeof(struct iovec) * (u_int)msg.msg_iovlen, M_IOV,
 731                        M_WAITOK);
 732         } else
 733                 iov = aiov;
 734         if (msg.msg_iovlen &&
 735             (error = copyin((caddr_t)msg.msg_iov, (caddr_t)iov,
 736             (unsigned)(msg.msg_iovlen * sizeof (struct iovec)))))
 737                 goto done;
 738         msg.msg_iov = iov;
 739 #ifdef COMPAT_OLDSOCK
 740         msg.msg_flags = 0;
 741 #endif
 742         error = sendit(p, uap->s, &msg, uap->flags);
 743 done:
 744         if (iov != aiov)
 745                 FREE(iov, M_IOV);
 746         return (error);
 747 }
 748
 749 static int
 750 recvit(p, s, mp, namelenp)
 751         register struct proc *p;
 752         int s;
 753         register struct msghdr *mp;
 754         caddr_t namelenp;
 755 {
 756         struct file *fp;
 757         struct uio auio;
 758         register struct iovec *iov;
 759         register int i;
 760         int len, error;
 761         struct mbuf *m, *control = 0;
 762         caddr_t ctlbuf;
 763         struct socket *so;
 764         struct sockaddr *fromsa = 0;
 765 #ifdef KTRACE
 766         struct iovec *ktriov = NULL;
 767         struct uio ktruio;
 768 #endif
 769
 770         error = holdsock(p->p_fd, s, &fp);
 771         if (error)
 772                 return (error);
 773         auio.uio_iov = mp->msg_iov;
 774         auio.uio_iovcnt = mp->msg_iovlen;
 775         auio.uio_segflg = UIO_USERSPACE;
 776         auio.uio_rw = UIO_READ;
 777         auio.uio_procp = p;
 778         auio.uio_offset = 0;                    /* XXX */
 779         auio.uio_resid = 0;
 780         iov = mp->msg_iov;
 781         for (i = 0; i < mp->msg_iovlen; i++, iov++) {
 782                 if ((auio.uio_resid += iov->iov_len) < 0) {
 783                         fdrop(fp, p);
 784                         return (EINVAL);
 785                 }
 786         }
 787 #ifdef KTRACE
 788         if (KTRPOINT(p, KTR_GENIO)) {
 789                 int iovlen = auio.uio_iovcnt * sizeof (struct iovec);
 790
 791                 MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
 792                 bcopy((caddr_t)auio.uio_iov, (caddr_t)ktriov, iovlen);
 793                 ktruio = auio;
 794         }
 795 #endif
 796         len = auio.uio_resid;
 797         so = (struct socket *)fp->f_data;
 798         error = so->so_proto->pr_usrreqs->pru_soreceive(so, &fromsa, &auio,
 799             (struct mbuf **)0, mp->msg_control ? &control : (struct mbuf **)0,
 800             &mp->msg_flags);
 801         if (error) {
 802                 if (auio.uio_resid != len && (error == ERESTART ||
 803                     error == EINTR || error == EWOULDBLOCK))
 804                         error = 0;
 805         }
 806 #ifdef KTRACE
 807         if (ktriov != NULL) {
 808                 if (error == 0) {
 809                         ktruio.uio_iov = ktriov;
 810                         ktruio.uio_resid = len - auio.uio_resid;
 811                         ktrgenio(p->p_tracep, s, UIO_READ, &ktruio, error);
 812                 }
 813                 FREE(ktriov, M_TEMP);
 814         }
 815 #endif
 816         if (error)
 817                 goto out;
 818         p->p_retval[0] = len - auio.uio_resid;
 819         if (mp->msg_name) {
 820                 len = mp->msg_namelen;
 821                 if (len <= 0 || fromsa == 0)
 822                         len = 0;
 823                 else {
 824 #ifndef MIN
 825 #define MIN(a,b) ((a)>(b)?(b):(a))
 826 #endif
 827                         /* save sa_len before it is destroyed by MSG_COMPAT */
 828                         len = MIN(len, fromsa->sa_len);
 829 #ifdef COMPAT_OLDSOCK
 830                         if (mp->msg_flags & MSG_COMPAT)
 831                                 ((struct osockaddr *)fromsa)->sa_family =
 832                                     fromsa->sa_family;
 833 #endif
 834                         error = copyout(fromsa,
 835                             (caddr_t)mp->msg_name, (unsigned)len);
 836                         if (error)
 837                                 goto out;
 838                 }
 839                 mp->msg_namelen = len;
 840                 if (namelenp &&
 841                     (error = copyout((caddr_t)&len, namelenp, sizeof (int)))) {
 842 #ifdef COMPAT_OLDSOCK
 843                         if (mp->msg_flags & MSG_COMPAT)
 844                                 error = 0;      /* old recvfrom didn't check */
 845                         else
 846 #endif
 847                         goto out;
 848                 }
 849         }
 850         if (mp->msg_control) {
 851 #ifdef COMPAT_OLDSOCK
 852                 /*
 853                  * We assume that old recvmsg calls won't receive access
 854                  * rights and other control info, esp. as control info
 855                  * is always optional and those options didn't exist in 4.3.
 856                  * If we receive rights, trim the cmsghdr; anything else
 857                  * is tossed.
 858                  */
 859                 if (control && mp->msg_flags & MSG_COMPAT) {
 860                         if (mtod(control, struct cmsghdr *)->cmsg_level !=
 861                             SOL_SOCKET ||
 862                             mtod(control, struct cmsghdr *)->cmsg_type !=
 863                             SCM_RIGHTS) {
 864                                 mp->msg_controllen = 0;
 865                                 goto out;
 866                         }
 867                         control->m_len -= sizeof (struct cmsghdr);
 868                         control->m_data += sizeof (struct cmsghdr);
 869                 }
 870 #endif
 871                 len = mp->msg_controllen;
 872                 m = control;
 873                 mp->msg_controllen = 0;
 874                 ctlbuf = (caddr_t) mp->msg_control;
 875
 876                 while (m && len > 0) {
 877                         unsigned int tocopy;
 878
 879                         if (len >= m->m_len)
 880                                 tocopy = m->m_len;
 881                         else {
 882                                 mp->msg_flags |= MSG_CTRUNC;
 883                                 tocopy = len;
 884                         }
 885
 886                         if ((error = copyout((caddr_t)mtod(m, caddr_t),
 887                                         ctlbuf, tocopy)) != 0)
 888                                 goto out;
 889
 890                         ctlbuf += tocopy;
 891                         len -= tocopy;
 892                         m = m->m_next;
 893                 }
 894                 mp->msg_controllen = ctlbuf - (caddr_t)mp->msg_control;
 895         }
 896 out:
 897         fdrop(fp, p);
 898         if (fromsa)
 899                 FREE(fromsa, M_SONAME);
 900         if (control)
 901                 m_freem(control);
 902         return (error);
 903 }
 904
 905 int
 906 recvfrom(p, uap)
 907         struct proc *p;
 908         register struct recvfrom_args /* {
 909                 int     s;
 910                 caddr_t buf;
 911                 size_t  len;
 912                 int     flags;
 913                 caddr_t from;
 914                 int     *fromlenaddr;
 915         } */ *uap;
 916 {
 917         struct msghdr msg;
 918         struct iovec aiov;
 919         int error;
 920
 921         if (uap->fromlenaddr) {
 922                 error = copyin((caddr_t)uap->fromlenaddr,
 923                     (caddr_t)&msg.msg_namelen, sizeof (msg.msg_namelen));
 924                 if (error)
 925                         return (error);
 926         } else
 927                 msg.msg_namelen = 0;
 928         msg.msg_name = uap->from;
 929         msg.msg_iov = &aiov;
 930         msg.msg_iovlen = 1;
 931         aiov.iov_base = uap->buf;
 932         aiov.iov_len = uap->len;
 933         msg.msg_control = 0;
 934         msg.msg_flags = uap->flags;
 935         return (recvit(p, uap->s, &msg, (caddr_t)uap->fromlenaddr));
 936 }
 937
 938 #ifdef COMPAT_OLDSOCK
 939 int
 940 orecvfrom(p, uap)
 941         struct proc *p;
 942         struct recvfrom_args *uap;
 943 {
 944
 945         uap->flags |= MSG_COMPAT;
 946         return (recvfrom(p, uap));
 947 }
 948 #endif
 949
 950
 951 #ifdef COMPAT_OLDSOCK
 952 int
 953 orecv(p, uap)
 954         struct proc *p;
 955         register struct orecv_args /* {
 956                 int     s;
 957                 caddr_t buf;
 958                 int     len;
 959                 int     flags;
 960         } */ *uap;
 961 {
 962         struct msghdr msg;
 963         struct iovec aiov;
 964
 965         msg.msg_name = 0;
 966         msg.msg_namelen = 0;
 967         msg.msg_iov = &aiov;
 968         msg.msg_iovlen = 1;
 969         aiov.iov_base = uap->buf;
 970         aiov.iov_len = uap->len;
 971         msg.msg_control = 0;
 972         msg.msg_flags = uap->flags;
 973         return (recvit(p, uap->s, &msg, (caddr_t)0));
 974 }
 975
 976 /*
 977  * Old recvmsg.  This code takes advantage of the fact that the old msghdr
 978  * overlays the new one, missing only the flags, and with the (old) access
 979  * rights where the control fields are now.
 980  */
 981 int
 982 orecvmsg(p, uap)
 983         struct proc *p;
 984         register struct orecvmsg_args /* {
 985                 int     s;
 986                 struct  omsghdr *msg;
 987                 int     flags;
 988         } */ *uap;
 989 {
 990         struct msghdr msg;
 991         struct iovec aiov[UIO_SMALLIOV], *iov;
 992         int error;
 993
 994         error = copyin((caddr_t)uap->msg, (caddr_t)&msg,
 995             sizeof (struct omsghdr));
 996         if (error)
 997                 return (error);
 998         if ((u_int)msg.msg_iovlen >= UIO_SMALLIOV) {
 999                 if ((u_int)msg.msg_iovlen >= UIO_MAXIOV)
1000                         return (EMSGSIZE);
1001                 MALLOC(iov, struct iovec *,
1002                       sizeof(struct iovec) * (u_int)msg.msg_iovlen, M_IOV,
1003                       M_WAITOK);
1004         } else
1005                 iov = aiov;
1006         msg.msg_flags = uap->flags | MSG_COMPAT;
1007         error = copyin((caddr_t)msg.msg_iov, (caddr_t)iov,
1008             (unsigned)(msg.msg_iovlen * sizeof (struct iovec)));
1009         if (error)
1010                 goto done;
1011         msg.msg_iov = iov;
1012         error = recvit(p, uap->s, &msg, (caddr_t)&uap->msg->msg_namelen);
1013
1014         if (msg.msg_controllen && error == 0)
1015                 error = copyout((caddr_t)&msg.msg_controllen,
1016                     (caddr_t)&uap->msg->msg_accrightslen, sizeof (int));
1017 done:
1018         if (iov != aiov)
1019                 FREE(iov, M_IOV);
1020         return (error);
1021 }
1022 #endif
1023
1024 int
1025 recvmsg(p, uap)
1026         struct proc *p;
1027         register struct recvmsg_args /* {
1028                 int     s;
1029                 struct  msghdr *msg;
1030                 int     flags;
1031         } */ *uap;
1032 {
1033         struct msghdr msg;
1034         struct iovec aiov[UIO_SMALLIOV], *uiov, *iov;
1035         register int error;
1036
1037         error = copyin((caddr_t)uap->msg, (caddr_t)&msg, sizeof (msg));
1038         if (error)
1039                 return (error);
1040         if ((u_int)msg.msg_iovlen >= UIO_SMALLIOV) {
1041                 if ((u_int)msg.msg_iovlen >= UIO_MAXIOV)
1042                         return (EMSGSIZE);
1043                 MALLOC(iov, struct iovec *,
1044                        sizeof(struct iovec) * (u_int)msg.msg_iovlen, M_IOV,
1045                        M_WAITOK);
1046         } else
1047                 iov = aiov;
1048 #ifdef COMPAT_OLDSOCK
1049         msg.msg_flags = uap->flags &~ MSG_COMPAT;
1050 #else
1051         msg.msg_flags = uap->flags;
1052 #endif
1053         uiov = msg.msg_iov;
1054         msg.msg_iov = iov;
1055         error = copyin((caddr_t)uiov, (caddr_t)iov,
1056             (unsigned)(msg.msg_iovlen * sizeof (struct iovec)));
1057         if (error)
1058                 goto done;
1059         error = recvit(p, uap->s, &msg, (caddr_t)0);
1060         if (!error) {
1061                 msg.msg_iov = uiov;
1062                 error = copyout((caddr_t)&msg, (caddr_t)uap->msg, sizeof(msg));
1063         }
1064 done:
1065         if (iov != aiov)
1066                 FREE(iov, M_IOV);
1067         return (error);
1068 }
1069
1070 /* ARGSUSED */
1071 int
1072 shutdown(p, uap)
1073         struct proc *p;
1074         register struct shutdown_args /* {
1075                 int     s;
1076                 int     how;
1077         } */ *uap;
1078 {
1079         struct file *fp;
1080         int error;
1081
1082         error = holdsock(p->p_fd, uap->s, &fp);
1083         if (error)
1084                 return (error);
1085         error = soshutdown((struct socket *)fp->f_data, uap->how);
1086         fdrop(fp, p);
1087         return(error);
1088 }
1089
1090 /* ARGSUSED */
1091 int
1092 setsockopt(p, uap)
1093         struct proc *p;
1094         register struct setsockopt_args /* {
1095                 int     s;
1096                 int     level;
1097                 int     name;
1098                 caddr_t val;
1099                 int     valsize;
1100         } */ *uap;
1101 {
1102         struct file *fp;
1103         struct sockopt sopt;
1104         int error;
1105
1106         if (uap->val == 0 && uap->valsize != 0)
1107                 return (EFAULT);
1108         if (uap->valsize < 0)
1109                 return (EINVAL);
1110
1111         error = holdsock(p->p_fd, uap->s, &fp);
1112         if (error)
1113                 return (error);
1114
1115         sopt.sopt_dir = SOPT_SET;
1116         sopt.sopt_level = uap->level;
1117         sopt.sopt_name = uap->name;
1118         sopt.sopt_val = uap->val;
1119         sopt.sopt_valsize = uap->valsize;
1120         sopt.sopt_p = p;
1121         error = sosetopt((struct socket *)fp->f_data, &sopt);
1122         fdrop(fp, p);
1123         return(error);
1124 }
1125
1126 /* ARGSUSED */
1127 int
1128 getsockopt(p, uap)
1129         struct proc *p;
1130         register struct getsockopt_args /* {
1131                 int     s;
1132                 int     level;
1133                 int     name;
1134                 caddr_t val;
1135                 int     *avalsize;
1136         } */ *uap;
1137 {
1138         int     valsize, error;
1139         struct  file *fp;
1140         struct  sockopt sopt;
1141
1142         error = holdsock(p->p_fd, uap->s, &fp);
1143         if (error)
1144                 return (error);
1145         if (uap->val) {
1146                 error = copyin((caddr_t)uap->avalsize, (caddr_t)&valsize,
1147                     sizeof (valsize));
1148                 if (error) {
1149                         fdrop(fp, p);
1150                         return (error);
1151                 }
1152                 if (valsize < 0) {
1153                         fdrop(fp, p);
1154                         return (EINVAL);
1155                 }
1156         } else {
1157                 valsize = 0;
1158         }
1159
1160         sopt.sopt_dir = SOPT_GET;
1161         sopt.sopt_level = uap->level;
1162         sopt.sopt_name = uap->name;
1163         sopt.sopt_val = uap->val;
1164         sopt.sopt_valsize = (size_t)valsize; /* checked non-negative above */
1165         sopt.sopt_p = p;
1166
1167         error = sogetopt((struct socket *)fp->f_data, &sopt);
1168         if (error == 0) {
1169                 valsize = sopt.sopt_valsize;
1170                 error = copyout((caddr_t)&valsize,
1171                                 (caddr_t)uap->avalsize, sizeof (valsize));
1172         }
1173         fdrop(fp, p);
1174         return (error);
1175 }
1176
1177 /*
1178  * Get socket name.
1179  */
1180 /* ARGSUSED */
1181 static int
1182 getsockname1(p, uap, compat)
1183         struct proc *p;
1184         register struct getsockname_args /* {
1185                 int     fdes;
1186                 caddr_t asa;
1187                 int     *alen;
1188         } */ *uap;
1189         int compat;
1190 {
1191         struct file *fp;
1192         register struct socket *so;
1193         struct sockaddr *sa;
1194         int len, error;
1195
1196         error = holdsock(p->p_fd, uap->fdes, &fp);
1197         if (error)
1198                 return (error);
1199         error = copyin((caddr_t)uap->alen, (caddr_t)&len, sizeof (len));
1200         if (error) {
1201                 fdrop(fp, p);
1202                 return (error);
1203         }
1204         if (len < 0) {
1205                 fdrop(fp, p);
1206                 return (EINVAL);
1207         }
1208         so = (struct socket *)fp->f_data;
1209         sa = 0;
1210         error = (*so->so_proto->pr_usrreqs->pru_sockaddr)(so, &sa);
1211         if (error)
1212                 goto bad;
1213         if (sa == 0) {
1214                 len = 0;
1215                 goto gotnothing;
1216         }
1217
1218         len = MIN(len, sa->sa_len);
1219 #ifdef COMPAT_OLDSOCK
1220         if (compat)
1221                 ((struct osockaddr *)sa)->sa_family = sa->sa_family;
1222 #endif
1223         error = copyout(sa, (caddr_t)uap->asa, (u_int)len);
1224         if (error == 0)
1225 gotnothing:
1226                 error = copyout((caddr_t)&len, (caddr_t)uap->alen,
1227                     sizeof (len));
1228 bad:
1229         if (sa)
1230                 FREE(sa, M_SONAME);
1231         fdrop(fp, p);
1232         return (error);
1233 }
1234
1235 int
1236 getsockname(p, uap)
1237         struct proc *p;
1238         struct getsockname_args *uap;
1239 {
1240
1241         return (getsockname1(p, uap, 0));
1242 }
1243
1244 #ifdef COMPAT_OLDSOCK
1245 int
1246 ogetsockname(p, uap)
1247         struct proc *p;
1248         struct getsockname_args *uap;
1249 {
1250
1251         return (getsockname1(p, uap, 1));
1252 }
1253 #endif /* COMPAT_OLDSOCK */
1254
1255 /*
1256  * Get name of peer for connected socket.
1257  */
1258 /* ARGSUSED */
1259 static int
1260 getpeername1(p, uap, compat)
1261         struct proc *p;
1262         register struct getpeername_args /* {
1263                 int     fdes;
1264                 caddr_t asa;
1265                 int     *alen;
1266         } */ *uap;
1267         int compat;
1268 {
1269         struct file *fp;
1270         register struct socket *so;
1271         struct sockaddr *sa;
1272         int len, error;
1273
1274         error = holdsock(p->p_fd, uap->fdes, &fp);
1275         if (error)
1276                 return (error);
1277         so = (struct socket *)fp->f_data;
1278         if ((so->so_state & (SS_ISCONNECTED|SS_ISCONFIRMING)) == 0) {
1279                 fdrop(fp, p);
1280                 return (ENOTCONN);
1281         }
1282         error = copyin((caddr_t)uap->alen, (caddr_t)&len, sizeof (len));
1283         if (error) {
1284                 fdrop(fp, p);
1285                 return (error);
1286         }
1287         if (len < 0) {
1288                 fdrop(fp, p);
1289                 return (EINVAL);
1290         }
1291         sa = 0;
1292         error = (*so->so_proto->pr_usrreqs->pru_peeraddr)(so, &sa);
1293         if (error)
1294                 goto bad;
1295         if (sa == 0) {
1296                 len = 0;
1297                 goto gotnothing;
1298         }
1299         len = MIN(len, sa->sa_len);
1300 #ifdef COMPAT_OLDSOCK
1301         if (compat)
1302                 ((struct osockaddr *)sa)->sa_family =
1303                     sa->sa_family;
1304 #endif
1305         error = copyout(sa, (caddr_t)uap->asa, (u_int)len);
1306         if (error)
1307                 goto bad;
1308 gotnothing:
1309         error = copyout((caddr_t)&len, (caddr_t)uap->alen, sizeof (len));
1310 bad:
1311         if (sa)
1312                 FREE(sa, M_SONAME);
1313         fdrop(fp, p);
1314         return (error);
1315 }
1316
1317 int
1318 getpeername(p, uap)
1319         struct proc *p;
1320         struct getpeername_args *uap;
1321 {
1322
1323         return (getpeername1(p, uap, 0));
1324 }
1325
1326 #ifdef COMPAT_OLDSOCK
1327 int
1328 ogetpeername(p, uap)
1329         struct proc *p;
1330         struct ogetpeername_args *uap;
1331 {
1332
1333         /* XXX uap should have type `getpeername_args *' to begin with. */
1334         return (getpeername1(p, (struct getpeername_args *)uap, 1));
1335 }
1336 #endif /* COMPAT_OLDSOCK */
1337
1338 int
1339 sockargs(mp, buf, buflen, type)
1340         struct mbuf **mp;
1341         caddr_t buf;
1342         int buflen, type;
1343 {
1344         register struct sockaddr *sa;
1345         register struct mbuf *m;
1346         int error;
1347
1348         if ((u_int)buflen > MLEN) {
1349 #ifdef COMPAT_OLDSOCK
1350                 if (type == MT_SONAME && (u_int)buflen <= 112)
1351                         buflen = MLEN;          /* unix domain compat. hack */
1352                 else
1353 #endif
1354                 return (EINVAL);
1355         }
1356         m = m_get(M_WAIT, type);
1357         if (m == NULL)
1358                 return (ENOBUFS);
1359         m->m_len = buflen;
1360         error = copyin(buf, mtod(m, caddr_t), (u_int)buflen);
1361         if (error)
1362                 (void) m_free(m);
1363         else {
1364                 *mp = m;
1365                 if (type == MT_SONAME) {
1366                         sa = mtod(m, struct sockaddr *);
1367
1368 #if defined(COMPAT_OLDSOCK) && BYTE_ORDER != BIG_ENDIAN
1369                         if (sa->sa_family == 0 && sa->sa_len < AF_MAX)
1370                                 sa->sa_family = sa->sa_len;
1371 #endif
1372                         sa->sa_len = buflen;
1373                 }
1374         }
1375         return (error);
1376 }
1377
1378 int
1379 getsockaddr(namp, uaddr, len)
1380         struct sockaddr **namp;
1381         caddr_t uaddr;
1382         size_t len;
1383 {
1384         struct sockaddr *sa;
1385         int error;
1386
1387         if (len > SOCK_MAXADDRLEN)
1388                 return ENAMETOOLONG;
1389         MALLOC(sa, struct sockaddr *, len, M_SONAME, M_WAITOK);
1390         error = copyin(uaddr, sa, len);
1391         if (error) {
1392                 FREE(sa, M_SONAME);
1393         } else {
1394 #if defined(COMPAT_OLDSOCK) && BYTE_ORDER != BIG_ENDIAN
1395                 if (sa->sa_family == 0 && sa->sa_len < AF_MAX)
1396                         sa->sa_family = sa->sa_len;
1397 #endif
1398                 sa->sa_len = len;
1399                 *namp = sa;
1400         }
1401         return error;
1402 }
1403
1404 /*
1405  * holdsock() - load the struct file pointer associated
1406  * with a socket into *fpp.  If an error occurs, non-zero
1407  * will be returned and *fpp will be set to NULL.
1408  */
1409 int
1410 holdsock(fdp, fdes, fpp)
1411         struct filedesc *fdp;
1412         int fdes;
1413         struct file **fpp;
1414 {
1415         register struct file *fp = NULL;
1416         int error = 0;
1417
1418         if ((unsigned)fdes >= fdp->fd_nfiles ||
1419             (fp = fdp->fd_ofiles[fdes]) == NULL) {
1420                 error = EBADF;
1421         } else if (fp->f_type != DTYPE_SOCKET) {
1422                 error = ENOTSOCK;
1423                 fp = NULL;
1424         } else {
1425                 fhold(fp);
1426         }
1427         *fpp = fp;
1428         return(error);
1429 }
1430
1431 /*
1432  * Allocate a pool of sf_bufs (sendfile(2) or "super-fast" if you prefer. :-))
1433  */
1434 static void
1435 sf_buf_init(void *arg)
1436 {
1437         int i;
1438
1439         SLIST_INIT(&sf_freelist);
1440         sf_base = kmem_alloc_pageable(kernel_map, nsfbufs * PAGE_SIZE);
1441         sf_bufs = malloc(nsfbufs * sizeof(struct sf_buf), M_TEMP, M_NOWAIT);
1442         bzero(sf_bufs, nsfbufs * sizeof(struct sf_buf));
1443         for (i = 0; i < nsfbufs; i++) {
1444                 sf_bufs[i].kva = sf_base + i * PAGE_SIZE;
1445                 SLIST_INSERT_HEAD(&sf_freelist, &sf_bufs[i], free_list);
1446         }
1447 }
1448
1449 /*
1450  * Get an sf_buf from the freelist. Will block if none are available.
1451  */
1452 struct sf_buf *
1453 sf_buf_alloc()
1454 {
1455         struct sf_buf *sf;
1456         int s;
1457         int error;
1458
1459         s = splimp();
1460         while ((sf = SLIST_FIRST(&sf_freelist)) == NULL) {
1461                 sf_buf_alloc_want = 1;
1462                 error = tsleep(&sf_freelist, PVM|PCATCH, "sfbufa", 0);
1463                 if (error)
1464                         break;
1465         }
1466         if (sf != NULL) {
1467                 SLIST_REMOVE_HEAD(&sf_freelist, free_list);
1468                 sf->refcnt = 1;
1469         }
1470         splx(s);
1471         return (sf);
1472 }
1473
1474 #define dtosf(x)        (&sf_bufs[((uintptr_t)(x) - (uintptr_t)sf_base) >> PAGE_SHIFT])
1475 void
1476 sf_buf_ref(caddr_t addr, u_int size)
1477 {
1478         struct sf_buf *sf;
1479
1480         sf = dtosf(addr);
1481         if (sf->refcnt == 0)
1482                 panic("sf_buf_ref: referencing a free sf_buf");
1483         sf->refcnt++;
1484 }
1485
1486 /*
1487  * Lose a reference to an sf_buf. When none left, detach mapped page
1488  * and release resources back to the system.
1489  *
1490  * Must be called at splimp.
1491  */
1492 void
1493 sf_buf_free(caddr_t addr, u_int size)
1494 {
1495         struct sf_buf *sf;
1496         struct vm_page *m;
1497         int s;
1498
1499         sf = dtosf(addr);
1500         if (sf->refcnt == 0)
1501                 panic("sf_buf_free: freeing free sf_buf");
1502         sf->refcnt--;
1503         if (sf->refcnt == 0) {
1504                 pmap_qremove((vm_offset_t)addr, 1);
1505                 m = sf->m;
1506                 s = splvm();
1507                 vm_page_unwire(m, 0);
1508                 /*
1509                  * Check for the object going away on us. This can
1510                  * happen since we don't hold a reference to it.
1511                  * If so, we're responsible for freeing the page.
1512                  */
1513                 if (m->wire_count == 0 && m->object == NULL)
1514                         vm_page_free(m);
1515                 splx(s);
1516                 sf->m = NULL;
1517                 SLIST_INSERT_HEAD(&sf_freelist, sf, free_list);
1518                 if (sf_buf_alloc_want) {
1519                         sf_buf_alloc_want = 0;
1520                         wakeup(&sf_freelist);
1521                 }
1522         }
1523 }
1524
1525 /*
1526  * sendfile(2).
1527  * int sendfile(int fd, int s, off_t offset, size_t nbytes,
1528  *       struct sf_hdtr *hdtr, off_t *sbytes, int flags)
1529  *
1530  * Send a file specified by 'fd' and starting at 'offset' to a socket
1531  * specified by 's'. Send only 'nbytes' of the file or until EOF if
1532  * nbytes == 0. Optionally add a header and/or trailer to the socket
1533  * output. If specified, write the total number of bytes sent into *sbytes.
1534  */
1535 int
1536 sendfile(struct proc *p, struct sendfile_args *uap)
1537 {
1538
1539         return (do_sendfile(p, uap, 0));
1540 }
1541
1542 #ifdef COMPAT_43
1543 int
1544 osendfile(struct proc *p, struct osendfile_args *uap)
1545 {
1546         struct sendfile_args args;
1547
1548         args.fd = uap->fd;
1549         args.s = uap->s;
1550         args.offset = uap->offset;
1551         args.nbytes = uap->nbytes;
1552         args.hdtr = uap->hdtr;
1553         args.sbytes = uap->sbytes;
1554         args.flags = uap->flags;
1555
1556         return (do_sendfile(p, &args, 1));
1557 }
1558 #endif
1559
1560 int
1561 do_sendfile(struct proc *p, struct sendfile_args *uap, int compat)
1562 {
1563         struct file *fp;
1564         struct filedesc *fdp = p->p_fd;
1565         struct vnode *vp;
1566         struct vm_object *obj;
1567         struct socket *so;
1568         struct mbuf *m;
1569         struct sf_buf *sf;
1570         struct vm_page *pg;
1571         struct writev_args nuap;
1572         struct sf_hdtr hdtr;
1573         off_t off, xfsize, hdtr_size, sbytes = 0;
1574         int error = 0, s;
1575
1576         vp = NULL;
1577         hdtr_size = 0;
1578         /*
1579          * Do argument checking. Must be a regular file in, stream
1580          * type and connected socket out, positive offset.
1581          */
1582         fp = holdfp(fdp, uap->fd, FREAD);
1583         if (fp == NULL) {
1584                 error = EBADF;
1585                 goto done;
1586         }
1587         if (fp->f_type != DTYPE_VNODE) {
1588                 error = EINVAL;
1589                 goto done;
1590         }
1591         vp = (struct vnode *)fp->f_data;
1592         vref(vp);
1593         if (vp->v_type != VREG || VOP_GETVOBJECT(vp, &obj) != 0) {
1594                 error = EINVAL;
1595                 goto done;
1596         }
1597         fdrop(fp, p);
1598         error = holdsock(p->p_fd, uap->s, &fp);
1599         if (error)
1600                 goto done;
1601         so = (struct socket *)fp->f_data;
1602         if (so->so_type != SOCK_STREAM) {
1603                 error = EINVAL;
1604                 goto done;
1605         }
1606         if ((so->so_state & SS_ISCONNECTED) == 0) {
1607                 error = ENOTCONN;
1608                 goto done;
1609         }
1610         if (uap->offset < 0) {
1611                 error = EINVAL;
1612                 goto done;
1613         }
1614
1615         /*
1616          * If specified, get the pointer to the sf_hdtr struct for
1617          * any headers/trailers.
1618          */
1619         if (uap->hdtr != NULL) {
1620                 error = copyin(uap->hdtr, &hdtr, sizeof(hdtr));
1621                 if (error)
1622                         goto done;
1623                 /*
1624                  * Send any headers. Wimp out and use writev(2).
1625                  */
1626                 if (hdtr.headers != NULL) {
1627                         nuap.fd = uap->s;
1628                         nuap.iovp = hdtr.headers;
1629                         nuap.iovcnt = hdtr.hdr_cnt;
1630                         error = writev(p, &nuap);
1631                         if (error)
1632                                 goto done;
1633                         if (compat)
1634                                 sbytes += p->p_retval[0];
1635                         else
1636                                 hdtr_size += p->p_retval[0];
1637                 }
1638         }
1639
1640         /*
1641          * Protect against multiple writers to the socket.
1642          */
1643         (void) sblock(&so->so_snd, M_WAITOK);
1644
1645         /*
1646          * Loop through the pages in the file, starting with the requested
1647          * offset. Get a file page (do I/O if necessary), map the file page
1648          * into an sf_buf, attach an mbuf header to the sf_buf, and queue
1649          * it on the socket.
1650          */
1651         for (off = uap->offset; ; off += xfsize, sbytes += xfsize) {
1652                 vm_pindex_t pindex;
1653                 vm_offset_t pgoff;
1654
1655                 pindex = OFF_TO_IDX(off);
1656 retry_lookup:
1657                 /*
1658                  * Calculate the amount to transfer. Not to exceed a page,
1659                  * the EOF, or the passed in nbytes.
1660                  */
1661                 xfsize = obj->un_pager.vnp.vnp_size - off;
1662                 if (xfsize > PAGE_SIZE)
1663                         xfsize = PAGE_SIZE;
1664                 pgoff = (vm_offset_t)(off & PAGE_MASK);
1665                 if (PAGE_SIZE - pgoff < xfsize)
1666                         xfsize = PAGE_SIZE - pgoff;
1667                 if (uap->nbytes && xfsize > (uap->nbytes - sbytes))
1668                         xfsize = uap->nbytes - sbytes;
1669                 if (xfsize <= 0)
1670                         break;
1671                 /*
1672                  * Optimize the non-blocking case by looking at the socket space
1673                  * before going to the extra work of constituting the sf_buf.
1674                  */
1675                 if ((so->so_state & SS_NBIO) && sbspace(&so->so_snd) <= 0) {
1676                         if (so->so_state & SS_CANTSENDMORE)
1677                                 error = EPIPE;
1678                         else
1679                                 error = EAGAIN;
1680                         sbunlock(&so->so_snd);
1681                         goto done;
1682                 }
1683                 /*
1684                  * Attempt to look up the page.
1685                  *
1686                  *      Allocate if not found
1687                  *
1688                  *      Wait and loop if busy.
1689                  */
1690                 pg = vm_page_lookup(obj, pindex);
1691
1692                 if (pg == NULL) {
1693                         pg = vm_page_alloc(obj, pindex, VM_ALLOC_NORMAL);
1694                         if (pg == NULL) {
1695                                 VM_WAIT;
1696                                 goto retry_lookup;
1697                         }
1698                         vm_page_wakeup(pg);
1699                 } else if (vm_page_sleep_busy(pg, TRUE, "sfpbsy")) {
1700                         goto retry_lookup;
1701                 }
1702
1703                 /*
1704                  * Wire the page so it does not get ripped out from under
1705                  * us.
1706                  */
1707
1708                 vm_page_wire(pg);
1709
1710                 /*
1711                  * If page is not valid for what we need, initiate I/O
1712                  */
1713
1714                 if (!pg->valid || !vm_page_is_valid(pg, pgoff, xfsize)) {
1715                         struct uio auio;
1716                         struct iovec aiov;
1717                         int bsize;
1718
1719                         /*
1720                          * Ensure that our page is still around when the I/O
1721                          * completes.
1722                          */
1723                         vm_page_io_start(pg);
1724
1725                         /*
1726                          * Get the page from backing store.
1727                          */
1728                         bsize = vp->v_mount->mnt_stat.f_iosize;
1729                         auio.uio_iov = &aiov;
1730                         auio.uio_iovcnt = 1;
1731                         aiov.iov_base = 0;
1732                         aiov.iov_len = MAXBSIZE;
1733                         auio.uio_resid = MAXBSIZE;
1734                         auio.uio_offset = trunc_page(off);
1735                         auio.uio_segflg = UIO_NOCOPY;
1736                         auio.uio_rw = UIO_READ;
1737                         auio.uio_procp = p;
1738                         vn_lock(vp, LK_SHARED | LK_NOPAUSE | LK_RETRY, p);
1739                         error = VOP_READ(vp, &auio, IO_VMIO | ((MAXBSIZE / bsize) << 16),
1740                                 p->p_ucred);
1741                         VOP_UNLOCK(vp, 0, p);
1742                         vm_page_flag_clear(pg, PG_ZERO);
1743                         vm_page_io_finish(pg);
1744                         if (error) {
1745                                 vm_page_unwire(pg, 0);
1746                                 /*
1747                                  * See if anyone else might know about this page.
1748                                  * If not and it is not valid, then free it.
1749                                  */
1750                                 if (pg->wire_count == 0 && pg->valid == 0 &&
1751                                     pg->busy == 0 && !(pg->flags & PG_BUSY) &&
1752                                     pg->hold_count == 0) {
1753                                         vm_page_busy(pg);
1754                                         vm_page_free(pg);
1755                                 }
1756                                 sbunlock(&so->so_snd);
1757                                 goto done;
1758                         }
1759                 }
1760
1761
1762                 /*
1763                  * Get a sendfile buf. We usually wait as long as necessary,
1764                  * but this wait can be interrupted.
1765                  */
1766                 if ((sf = sf_buf_alloc()) == NULL) {
1767                         s = splvm();
1768                         vm_page_unwire(pg, 0);
1769                         if (pg->wire_count == 0 && pg->object == NULL)
1770                                 vm_page_free(pg);
1771                         splx(s);
1772                         sbunlock(&so->so_snd);
1773                         error = EINTR;
1774                         goto done;
1775                 }
1776
1777
1778                 /*
1779                  * Allocate a kernel virtual page and insert the physical page
1780                  * into it.
1781                  */
1782
1783                 sf->m = pg;
1784                 pmap_qenter(sf->kva, &pg, 1);
1785                 /*
1786                  * Get an mbuf header and set it up as having external storage.
1787                  */
1788                 MGETHDR(m, M_WAIT, MT_DATA);
1789                 if (m == NULL) {
1790                         error = ENOBUFS;
1791                         sf_buf_free((void *)sf->kva, PAGE_SIZE);
1792                         sbunlock(&so->so_snd);
1793                         goto done;
1794                 }
1795                 m->m_ext.ext_free = sf_buf_free;
1796                 m->m_ext.ext_ref = sf_buf_ref;
1797                 m->m_ext.ext_buf = (void *)sf->kva;
1798                 m->m_ext.ext_size = PAGE_SIZE;
1799                 m->m_data = (char *) sf->kva + pgoff;
1800                 m->m_flags |= M_EXT;
1801                 m->m_pkthdr.len = m->m_len = xfsize;
1802                 /*
1803                  * Add the buffer to the socket buffer chain.
1804                  */
1805                 s = splnet();
1806 retry_space:
1807                 /*
1808                  * Make sure that the socket is still able to take more data.
1809                  * CANTSENDMORE being true usually means that the connection
1810                  * was closed. so_error is true when an error was sensed after
1811                  * a previous send.
1812                  * The state is checked after the page mapping and buffer
1813                  * allocation above since those operations may block and make
1814                  * any socket checks stale. From this point forward, nothing
1815                  * blocks before the pru_send (or more accurately, any blocking
1816                  * results in a loop back to here to re-check).
1817                  */
1818                 if ((so->so_state & SS_CANTSENDMORE) || so->so_error) {
1819                         if (so->so_state & SS_CANTSENDMORE) {
1820                                 error = EPIPE;
1821                         } else {
1822                                 error = so->so_error;
1823                                 so->so_error = 0;
1824                         }
1825                         m_freem(m);
1826                         sbunlock(&so->so_snd);
1827                         splx(s);
1828                         goto done;
1829                 }
1830                 /*
1831                  * Wait for socket space to become available. We do this just
1832                  * after checking the connection state above in order to avoid
1833                  * a race condition with sbwait().
1834                  */
1835                 if (sbspace(&so->so_snd) < so->so_snd.sb_lowat) {
1836                         if (so->so_state & SS_NBIO) {
1837                                 m_freem(m);
1838                                 sbunlock(&so->so_snd);
1839                                 splx(s);
1840                                 error = EAGAIN;
1841                                 goto done;
1842                         }
1843                         error = sbwait(&so->so_snd);
1844                         /*
1845                          * An error from sbwait usually indicates that we've
1846                          * been interrupted by a signal. If we've sent anything
1847                          * then return bytes sent, otherwise return the error.
1848                          */
1849                         if (error) {
1850                                 m_freem(m);
1851                                 sbunlock(&so->so_snd);
1852                                 splx(s);
1853                                 goto done;
1854                         }
1855                         goto retry_space;
1856                 }
1857                 error = (*so->so_proto->pr_usrreqs->pru_send)(so, 0, m, 0, 0, p);
1858                 splx(s);
1859                 if (error) {
1860                         sbunlock(&so->so_snd);
1861                         goto done;
1862                 }
1863         }
1864         sbunlock(&so->so_snd);
1865
1866         /*
1867          * Send trailers. Wimp out and use writev(2).
1868          */
1869         if (uap->hdtr != NULL && hdtr.trailers != NULL) {
1870                         nuap.fd = uap->s;
1871                         nuap.iovp = hdtr.trailers;
1872                         nuap.iovcnt = hdtr.trl_cnt;
1873                         error = writev(p, &nuap);
1874                         if (error)
1875                                 goto done;
1876                         if (compat)
1877                                 sbytes += p->p_retval[0];
1878                         else
1879                                 hdtr_size += p->p_retval[0];
1880         }
1881
1882 done:
1883         if (uap->sbytes != NULL) {
1884                 if (compat == 0)
1885                         sbytes += hdtr_size;
1886                 copyout(&sbytes, uap->sbytes, sizeof(off_t));
1887         }
1888         if (vp)
1889                 vrele(vp);
1890         if (fp)
1891                 fdrop(fp, p);
1892         return (error);
1893 }