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  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  *      @(#)uipc_syscalls.c     8.4 (Berkeley) 2/21/94
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include "opt_capsicum.h"
  36 #include "opt_inet.h"
  37 #include "opt_inet6.h"
  38 #include "opt_compat.h"
  39 #include "opt_ktrace.h"
  40
  41 #include <sys/param.h>
  42 #include <sys/systm.h>
  43 #include <sys/capsicum.h>
  44 #include <sys/kernel.h>
  45 #include <sys/lock.h>
  46 #include <sys/mutex.h>
  47 #include <sys/sysproto.h>
  48 #include <sys/malloc.h>
  49 #include <sys/filedesc.h>
  50 #include <sys/proc.h>
  51 #include <sys/filio.h>
  52 #include <sys/jail.h>
  53 #include <sys/mbuf.h>
  54 #include <sys/protosw.h>
  55 #include <sys/rwlock.h>
  56 #include <sys/socket.h>
  57 #include <sys/socketvar.h>
  58 #include <sys/syscallsubr.h>
  59 #ifdef KTRACE
  60 #include <sys/ktrace.h>
  61 #endif
  62 #ifdef COMPAT_FREEBSD32
  63 #include <compat/freebsd32/freebsd32_util.h>
  64 #endif
  65
  66 #include <net/vnet.h>
  67
  68 #include <security/audit/audit.h>
  69 #include <security/mac/mac_framework.h>
  70
  71 /*
  72  * Flags for accept1() and kern_accept4(), in addition to SOCK_CLOEXEC
  73  * and SOCK_NONBLOCK.
  74  */
  75 #define ACCEPT4_INHERIT 0x1
  76 #define ACCEPT4_COMPAT  0x2
  77
  78 static int sendit(struct thread *td, int s, struct msghdr *mp, int flags);
  79 static int recvit(struct thread *td, int s, struct msghdr *mp, void *namelenp);
  80
  81 static int accept1(struct thread *td, int s, struct sockaddr *uname,
  82                    socklen_t *anamelen, int flags);
  83 static int getsockname1(struct thread *td, struct getsockname_args *uap,
  84                         int compat);
  85 static int getpeername1(struct thread *td, struct getpeername_args *uap,
  86                         int compat);
  87 static int sockargs(struct mbuf **, char *, socklen_t, int);
  88
  89 /*
  90  * Convert a user file descriptor to a kernel file entry and check if required
  91  * capability rights are present.
  92  * A reference on the file entry is held upon returning.
  93  */
  94 int
  95 getsock_cap(struct thread *td, int fd, cap_rights_t *rightsp,
  96     struct file **fpp, u_int *fflagp)
  97 {
  98         struct file *fp;
  99         int error;
 100
 101         error = fget_unlocked(td->td_proc->p_fd, fd, rightsp, &fp, NULL);
 102         if (error != 0)
 103                 return (error);
 104         if (fp->f_type != DTYPE_SOCKET) {
 105                 fdrop(fp, td);
 106                 return (ENOTSOCK);
 107         }
 108         if (fflagp != NULL)
 109                 *fflagp = fp->f_flag;
 110         *fpp = fp;
 111         return (0);
 112 }
 113
 114 /*
 115  * System call interface to the socket abstraction.
 116  */
 117 #if defined(COMPAT_43)
 118 #define COMPAT_OLDSOCK
 119 #endif
 120
 121 int
 122 sys_socket(struct thread *td, struct socket_args *uap)
 123 {
 124         struct socket *so;
 125         struct file *fp;
 126         int fd, error, type, oflag, fflag;
 127
 128         AUDIT_ARG_SOCKET(uap->domain, uap->type, uap->protocol);
 129
 130         type = uap->type;
 131         oflag = 0;
 132         fflag = 0;
 133         if ((type & SOCK_CLOEXEC) != 0) {
 134                 type &= ~SOCK_CLOEXEC;
 135                 oflag |= O_CLOEXEC;
 136         }
 137         if ((type & SOCK_NONBLOCK) != 0) {
 138                 type &= ~SOCK_NONBLOCK;
 139                 fflag |= FNONBLOCK;
 140         }
 141
 142 #ifdef MAC
 143         error = mac_socket_check_create(td->td_ucred, uap->domain, type,
 144             uap->protocol);
 145         if (error != 0)
 146                 return (error);
 147 #endif
 148         error = falloc(td, &fp, &fd, oflag);
 149         if (error != 0)
 150                 return (error);
 151         /* An extra reference on `fp' has been held for us by falloc(). */
 152         error = socreate(uap->domain, &so, type, uap->protocol,
 153             td->td_ucred, td);
 154         if (error != 0) {
 155                 fdclose(td, fp, fd);
 156         } else {
 157                 finit(fp, FREAD | FWRITE | fflag, DTYPE_SOCKET, so, &socketops);
 158                 if ((fflag & FNONBLOCK) != 0)
 159                         (void) fo_ioctl(fp, FIONBIO, &fflag, td->td_ucred, td);
 160                 td->td_retval[0] = fd;
 161         }
 162         fdrop(fp, td);
 163         return (error);
 164 }
 165
 166 int
 167 sys_bind(struct thread *td, struct bind_args *uap)
 168 {
 169         struct sockaddr *sa;
 170         int error;
 171
 172         error = getsockaddr(&sa, uap->name, uap->namelen);
 173         if (error == 0) {
 174                 error = kern_bindat(td, AT_FDCWD, uap->s, sa);
 175                 free(sa, M_SONAME);
 176         }
 177         return (error);
 178 }
 179
 180 int
 181 kern_bindat(struct thread *td, int dirfd, int fd, struct sockaddr *sa)
 182 {
 183         struct socket *so;
 184         struct file *fp;
 185         cap_rights_t rights;
 186         int error;
 187
 188         AUDIT_ARG_FD(fd);
 189         AUDIT_ARG_SOCKADDR(td, dirfd, sa);
 190         error = getsock_cap(td, fd, cap_rights_init(&rights, CAP_BIND),
 191             &fp, NULL);
 192         if (error != 0)
 193                 return (error);
 194         so = fp->f_data;
 195 #ifdef KTRACE
 196         if (KTRPOINT(td, KTR_STRUCT))
 197                 ktrsockaddr(sa);
 198 #endif
 199 #ifdef MAC
 200         error = mac_socket_check_bind(td->td_ucred, so, sa);
 201         if (error == 0) {
 202 #endif
 203                 if (dirfd == AT_FDCWD)
 204                         error = sobind(so, sa, td);
 205                 else
 206                         error = sobindat(dirfd, so, sa, td);
 207 #ifdef MAC
 208         }
 209 #endif
 210         fdrop(fp, td);
 211         return (error);
 212 }
 213
 214 int
 215 sys_bindat(struct thread *td, struct bindat_args *uap)
 216 {
 217         struct sockaddr *sa;
 218         int error;
 219
 220         error = getsockaddr(&sa, uap->name, uap->namelen);
 221         if (error == 0) {
 222                 error = kern_bindat(td, uap->fd, uap->s, sa);
 223                 free(sa, M_SONAME);
 224         }
 225         return (error);
 226 }
 227
 228 int
 229 sys_listen(struct thread *td, struct listen_args *uap)
 230 {
 231         struct socket *so;
 232         struct file *fp;
 233         cap_rights_t rights;
 234         int error;
 235
 236         AUDIT_ARG_FD(uap->s);
 237         error = getsock_cap(td, uap->s, cap_rights_init(&rights, CAP_LISTEN),
 238             &fp, NULL);
 239         if (error == 0) {
 240                 so = fp->f_data;
 241 #ifdef MAC
 242                 error = mac_socket_check_listen(td->td_ucred, so);
 243                 if (error == 0)
 244 #endif
 245                         error = solisten(so, uap->backlog, td);
 246                 fdrop(fp, td);
 247         }
 248         return(error);
 249 }
 250
 251 /*
 252  * accept1()
 253  */
 254 static int
 255 accept1(td, s, uname, anamelen, flags)
 256         struct thread *td;
 257         int s;
 258         struct sockaddr *uname;
 259         socklen_t *anamelen;
 260         int flags;
 261 {
 262         struct sockaddr *name;
 263         socklen_t namelen;
 264         struct file *fp;
 265         int error;
 266
 267         if (uname == NULL)
 268                 return (kern_accept4(td, s, NULL, NULL, flags, NULL));
 269
 270         error = copyin(anamelen, &namelen, sizeof (namelen));
 271         if (error != 0)
 272                 return (error);
 273
 274         error = kern_accept4(td, s, &name, &namelen, flags, &fp);
 275
 276         if (error != 0)
 277                 return (error);
 278
 279         if (error == 0 && uname != NULL) {
 280 #ifdef COMPAT_OLDSOCK
 281                 if (flags & ACCEPT4_COMPAT)
 282                         ((struct osockaddr *)name)->sa_family =
 283                             name->sa_family;
 284 #endif
 285                 error = copyout(name, uname, namelen);
 286         }
 287         if (error == 0)
 288                 error = copyout(&namelen, anamelen,
 289                     sizeof(namelen));
 290         if (error != 0)
 291                 fdclose(td, fp, td->td_retval[0]);
 292         fdrop(fp, td);
 293         free(name, M_SONAME);
 294         return (error);
 295 }
 296
 297 int
 298 kern_accept(struct thread *td, int s, struct sockaddr **name,
 299     socklen_t *namelen, struct file **fp)
 300 {
 301         return (kern_accept4(td, s, name, namelen, ACCEPT4_INHERIT, fp));
 302 }
 303
 304 int
 305 kern_accept4(struct thread *td, int s, struct sockaddr **name,
 306     socklen_t *namelen, int flags, struct file **fp)
 307 {
 308         struct file *headfp, *nfp = NULL;
 309         struct sockaddr *sa = NULL;
 310         struct socket *head, *so;
 311         cap_rights_t rights;
 312         u_int fflag;
 313         pid_t pgid;
 314         int error, fd, tmp;
 315
 316         if (name != NULL)
 317                 *name = NULL;
 318
 319         AUDIT_ARG_FD(s);
 320         error = getsock_cap(td, s, cap_rights_init(&rights, CAP_ACCEPT),
 321             &headfp, &fflag);
 322         if (error != 0)
 323                 return (error);
 324         head = headfp->f_data;
 325         if ((head->so_options & SO_ACCEPTCONN) == 0) {
 326                 error = EINVAL;
 327                 goto done;
 328         }
 329 #ifdef MAC
 330         error = mac_socket_check_accept(td->td_ucred, head);
 331         if (error != 0)
 332                 goto done;
 333 #endif
 334         error = falloc(td, &nfp, &fd, (flags & SOCK_CLOEXEC) ? O_CLOEXEC : 0);
 335         if (error != 0)
 336                 goto done;
 337         ACCEPT_LOCK();
 338         if ((head->so_state & SS_NBIO) && TAILQ_EMPTY(&head->so_comp)) {
 339                 ACCEPT_UNLOCK();
 340                 error = EWOULDBLOCK;
 341                 goto noconnection;
 342         }
 343         while (TAILQ_EMPTY(&head->so_comp) && head->so_error == 0) {
 344                 if (head->so_rcv.sb_state & SBS_CANTRCVMORE) {
 345                         head->so_error = ECONNABORTED;
 346                         break;
 347                 }
 348                 error = msleep(&head->so_timeo, &accept_mtx, PSOCK | PCATCH,
 349                     "accept", 0);
 350                 if (error != 0) {
 351                         ACCEPT_UNLOCK();
 352                         goto noconnection;
 353                 }
 354         }
 355         if (head->so_error) {
 356                 error = head->so_error;
 357                 head->so_error = 0;
 358                 ACCEPT_UNLOCK();
 359                 goto noconnection;
 360         }
 361         so = TAILQ_FIRST(&head->so_comp);
 362         KASSERT(!(so->so_qstate & SQ_INCOMP), ("accept1: so SQ_INCOMP"));
 363         KASSERT(so->so_qstate & SQ_COMP, ("accept1: so not SQ_COMP"));
 364
 365         /*
 366          * Before changing the flags on the socket, we have to bump the
 367          * reference count.  Otherwise, if the protocol calls sofree(),
 368          * the socket will be released due to a zero refcount.
 369          */
 370         SOCK_LOCK(so);                  /* soref() and so_state update */
 371         soref(so);                      /* file descriptor reference */
 372
 373         TAILQ_REMOVE(&head->so_comp, so, so_list);
 374         head->so_qlen--;
 375         if (flags & ACCEPT4_INHERIT)
 376                 so->so_state |= (head->so_state & SS_NBIO);
 377         else
 378                 so->so_state |= (flags & SOCK_NONBLOCK) ? SS_NBIO : 0;
 379         so->so_qstate &= ~SQ_COMP;
 380         so->so_head = NULL;
 381
 382         SOCK_UNLOCK(so);
 383         ACCEPT_UNLOCK();
 384
 385         /* An extra reference on `nfp' has been held for us by falloc(). */
 386         td->td_retval[0] = fd;
 387
 388         /* connection has been removed from the listen queue */
 389         KNOTE_UNLOCKED(&head->so_rcv.sb_sel.si_note, 0);
 390
 391         if (flags & ACCEPT4_INHERIT) {
 392                 pgid = fgetown(&head->so_sigio);
 393                 if (pgid != 0)
 394                         fsetown(pgid, &so->so_sigio);
 395         } else {
 396                 fflag &= ~(FNONBLOCK | FASYNC);
 397                 if (flags & SOCK_NONBLOCK)
 398                         fflag |= FNONBLOCK;
 399         }
 400
 401         finit(nfp, fflag, DTYPE_SOCKET, so, &socketops);
 402         /* Sync socket nonblocking/async state with file flags */
 403         tmp = fflag & FNONBLOCK;
 404         (void) fo_ioctl(nfp, FIONBIO, &tmp, td->td_ucred, td);
 405         tmp = fflag & FASYNC;
 406         (void) fo_ioctl(nfp, FIOASYNC, &tmp, td->td_ucred, td);
 407         sa = NULL;
 408         error = soaccept(so, &sa);
 409         if (error != 0)
 410                 goto noconnection;
 411         if (sa == NULL) {
 412                 if (name)
 413                         *namelen = 0;
 414                 goto done;
 415         }
 416         AUDIT_ARG_SOCKADDR(td, AT_FDCWD, sa);
 417         if (name) {
 418                 /* check sa_len before it is destroyed */
 419                 if (*namelen > sa->sa_len)
 420                         *namelen = sa->sa_len;
 421 #ifdef KTRACE
 422                 if (KTRPOINT(td, KTR_STRUCT))
 423                         ktrsockaddr(sa);
 424 #endif
 425                 *name = sa;
 426                 sa = NULL;
 427         }
 428 noconnection:
 429         free(sa, M_SONAME);
 430
 431         /*
 432          * close the new descriptor, assuming someone hasn't ripped it
 433          * out from under us.
 434          */
 435         if (error != 0)
 436                 fdclose(td, nfp, fd);
 437
 438         /*
 439          * Release explicitly held references before returning.  We return
 440          * a reference on nfp to the caller on success if they request it.
 441          */
 442 done:
 443         if (fp != NULL) {
 444                 if (error == 0) {
 445                         *fp = nfp;
 446                         nfp = NULL;
 447                 } else
 448                         *fp = NULL;
 449         }
 450         if (nfp != NULL)
 451                 fdrop(nfp, td);
 452         fdrop(headfp, td);
 453         return (error);
 454 }
 455
 456 int
 457 sys_accept(td, uap)
 458         struct thread *td;
 459         struct accept_args *uap;
 460 {
 461
 462         return (accept1(td, uap->s, uap->name, uap->anamelen, ACCEPT4_INHERIT));
 463 }
 464
 465 int
 466 sys_accept4(td, uap)
 467         struct thread *td;
 468         struct accept4_args *uap;
 469 {
 470
 471         if (uap->flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
 472                 return (EINVAL);
 473
 474         return (accept1(td, uap->s, uap->name, uap->anamelen, uap->flags));
 475 }
 476
 477 #ifdef COMPAT_OLDSOCK
 478 int
 479 oaccept(td, uap)
 480         struct thread *td;
 481         struct accept_args *uap;
 482 {
 483
 484         return (accept1(td, uap->s, uap->name, uap->anamelen,
 485             ACCEPT4_INHERIT | ACCEPT4_COMPAT));
 486 }
 487 #endif /* COMPAT_OLDSOCK */
 488
 489 int
 490 sys_connect(struct thread *td, struct connect_args *uap)
 491 {
 492         struct sockaddr *sa;
 493         int error;
 494
 495         error = getsockaddr(&sa, uap->name, uap->namelen);
 496         if (error == 0) {
 497                 error = kern_connectat(td, AT_FDCWD, uap->s, sa);
 498                 free(sa, M_SONAME);
 499         }
 500         return (error);
 501 }
 502
 503 int
 504 kern_connectat(struct thread *td, int dirfd, int fd, struct sockaddr *sa)
 505 {
 506         struct socket *so;
 507         struct file *fp;
 508         cap_rights_t rights;
 509         int error, interrupted = 0;
 510
 511         AUDIT_ARG_FD(fd);
 512         AUDIT_ARG_SOCKADDR(td, dirfd, sa);
 513         error = getsock_cap(td, fd, cap_rights_init(&rights, CAP_CONNECT),
 514             &fp, NULL);
 515         if (error != 0)
 516                 return (error);
 517         so = fp->f_data;
 518         if (so->so_state & SS_ISCONNECTING) {
 519                 error = EALREADY;
 520                 goto done1;
 521         }
 522 #ifdef KTRACE
 523         if (KTRPOINT(td, KTR_STRUCT))
 524                 ktrsockaddr(sa);
 525 #endif
 526 #ifdef MAC
 527         error = mac_socket_check_connect(td->td_ucred, so, sa);
 528         if (error != 0)
 529                 goto bad;
 530 #endif
 531         if (dirfd == AT_FDCWD)
 532                 error = soconnect(so, sa, td);
 533         else
 534                 error = soconnectat(dirfd, so, sa, td);
 535         if (error != 0)
 536                 goto bad;
 537         if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) {
 538                 error = EINPROGRESS;
 539                 goto done1;
 540         }
 541         SOCK_LOCK(so);
 542         while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
 543                 error = msleep(&so->so_timeo, SOCK_MTX(so), PSOCK | PCATCH,
 544                     "connec", 0);
 545                 if (error != 0) {
 546                         if (error == EINTR || error == ERESTART)
 547                                 interrupted = 1;
 548                         break;
 549                 }
 550         }
 551         if (error == 0) {
 552                 error = so->so_error;
 553                 so->so_error = 0;
 554         }
 555         SOCK_UNLOCK(so);
 556 bad:
 557         if (!interrupted)
 558                 so->so_state &= ~SS_ISCONNECTING;
 559         if (error == ERESTART)
 560                 error = EINTR;
 561 done1:
 562         fdrop(fp, td);
 563         return (error);
 564 }
 565
 566 int
 567 sys_connectat(struct thread *td, struct connectat_args *uap)
 568 {
 569         struct sockaddr *sa;
 570         int error;
 571
 572         error = getsockaddr(&sa, uap->name, uap->namelen);
 573         if (error == 0) {
 574                 error = kern_connectat(td, uap->fd, uap->s, sa);
 575                 free(sa, M_SONAME);
 576         }
 577         return (error);
 578 }
 579
 580 int
 581 kern_socketpair(struct thread *td, int domain, int type, int protocol,
 582     int *rsv)
 583 {
 584         struct file *fp1, *fp2;
 585         struct socket *so1, *so2;
 586         int fd, error, oflag, fflag;
 587
 588         AUDIT_ARG_SOCKET(domain, type, protocol);
 589
 590         oflag = 0;
 591         fflag = 0;
 592         if ((type & SOCK_CLOEXEC) != 0) {
 593                 type &= ~SOCK_CLOEXEC;
 594                 oflag |= O_CLOEXEC;
 595         }
 596         if ((type & SOCK_NONBLOCK) != 0) {
 597                 type &= ~SOCK_NONBLOCK;
 598                 fflag |= FNONBLOCK;
 599         }
 600 #ifdef MAC
 601         /* We might want to have a separate check for socket pairs. */
 602         error = mac_socket_check_create(td->td_ucred, domain, type,
 603             protocol);
 604         if (error != 0)
 605                 return (error);
 606 #endif
 607         error = socreate(domain, &so1, type, protocol, td->td_ucred, td);
 608         if (error != 0)
 609                 return (error);
 610         error = socreate(domain, &so2, type, protocol, td->td_ucred, td);
 611         if (error != 0)
 612                 goto free1;
 613         /* On success extra reference to `fp1' and 'fp2' is set by falloc. */
 614         error = falloc(td, &fp1, &fd, oflag);
 615         if (error != 0)
 616                 goto free2;
 617         rsv[0] = fd;
 618         fp1->f_data = so1;      /* so1 already has ref count */
 619         error = falloc(td, &fp2, &fd, oflag);
 620         if (error != 0)
 621                 goto free3;
 622         fp2->f_data = so2;      /* so2 already has ref count */
 623         rsv[1] = fd;
 624         error = soconnect2(so1, so2);
 625         if (error != 0)
 626                 goto free4;
 627         if (type == SOCK_DGRAM) {
 628                 /*
 629                  * Datagram socket connection is asymmetric.
 630                  */
 631                  error = soconnect2(so2, so1);
 632                  if (error != 0)
 633                         goto free4;
 634         }
 635         finit(fp1, FREAD | FWRITE | fflag, DTYPE_SOCKET, fp1->f_data,
 636             &socketops);
 637         finit(fp2, FREAD | FWRITE | fflag, DTYPE_SOCKET, fp2->f_data,
 638             &socketops);
 639         if ((fflag & FNONBLOCK) != 0) {
 640                 (void) fo_ioctl(fp1, FIONBIO, &fflag, td->td_ucred, td);
 641                 (void) fo_ioctl(fp2, FIONBIO, &fflag, td->td_ucred, td);
 642         }
 643         fdrop(fp1, td);
 644         fdrop(fp2, td);
 645         return (0);
 646 free4:
 647         fdclose(td, fp2, rsv[1]);
 648         fdrop(fp2, td);
 649 free3:
 650         fdclose(td, fp1, rsv[0]);
 651         fdrop(fp1, td);
 652 free2:
 653         if (so2 != NULL)
 654                 (void)soclose(so2);
 655 free1:
 656         if (so1 != NULL)
 657                 (void)soclose(so1);
 658         return (error);
 659 }
 660
 661 int
 662 sys_socketpair(struct thread *td, struct socketpair_args *uap)
 663 {
 664         int error, sv[2];
 665
 666         error = kern_socketpair(td, uap->domain, uap->type,
 667             uap->protocol, sv);
 668         if (error != 0)
 669                 return (error);
 670         error = copyout(sv, uap->rsv, 2 * sizeof(int));
 671         if (error != 0) {
 672                 (void)kern_close(td, sv[0]);
 673                 (void)kern_close(td, sv[1]);
 674         }
 675         return (error);
 676 }
 677
 678 static int
 679 sendit(struct thread *td, int s, struct msghdr *mp, int flags)
 680 {
 681         struct mbuf *control;
 682         struct sockaddr *to;
 683         int error;
 684
 685 #ifdef CAPABILITY_MODE
 686         if (IN_CAPABILITY_MODE(td) && (mp->msg_name != NULL))
 687                 return (ECAPMODE);
 688 #endif
 689
 690         if (mp->msg_name != NULL) {
 691                 error = getsockaddr(&to, mp->msg_name, mp->msg_namelen);
 692                 if (error != 0) {
 693                         to = NULL;
 694                         goto bad;
 695                 }
 696                 mp->msg_name = to;
 697         } else {
 698                 to = NULL;
 699         }
 700
 701         if (mp->msg_control) {
 702                 if (mp->msg_controllen < sizeof(struct cmsghdr)
 703 #ifdef COMPAT_OLDSOCK
 704                     && mp->msg_flags != MSG_COMPAT
 705 #endif
 706                 ) {
 707                         error = EINVAL;
 708                         goto bad;
 709                 }
 710                 error = sockargs(&control, mp->msg_control,
 711                     mp->msg_controllen, MT_CONTROL);
 712                 if (error != 0)
 713                         goto bad;
 714 #ifdef COMPAT_OLDSOCK
 715                 if (mp->msg_flags == MSG_COMPAT) {
 716                         struct cmsghdr *cm;
 717
 718                         M_PREPEND(control, sizeof(*cm), M_WAITOK);
 719                         cm = mtod(control, struct cmsghdr *);
 720                         cm->cmsg_len = control->m_len;
 721                         cm->cmsg_level = SOL_SOCKET;
 722                         cm->cmsg_type = SCM_RIGHTS;
 723                 }
 724 #endif
 725         } else {
 726                 control = NULL;
 727         }
 728
 729         error = kern_sendit(td, s, mp, flags, control, UIO_USERSPACE);
 730
 731 bad:
 732         free(to, M_SONAME);
 733         return (error);
 734 }
 735
 736 int
 737 kern_sendit(struct thread *td, int s, struct msghdr *mp, int flags,
 738     struct mbuf *control, enum uio_seg segflg)
 739 {
 740         struct file *fp;
 741         struct uio auio;
 742         struct iovec *iov;
 743         struct socket *so;
 744         cap_rights_t rights;
 745 #ifdef KTRACE
 746         struct uio *ktruio = NULL;
 747 #endif
 748         ssize_t len;
 749         int i, error;
 750
 751         AUDIT_ARG_FD(s);
 752         cap_rights_init(&rights, CAP_SEND);
 753         if (mp->msg_name != NULL) {
 754                 AUDIT_ARG_SOCKADDR(td, AT_FDCWD, mp->msg_name);
 755                 cap_rights_set(&rights, CAP_CONNECT);
 756         }
 757         error = getsock_cap(td, s, &rights, &fp, NULL);
 758         if (error != 0)
 759                 return (error);
 760         so = (struct socket *)fp->f_data;
 761
 762 #ifdef KTRACE
 763         if (mp->msg_name != NULL && KTRPOINT(td, KTR_STRUCT))
 764                 ktrsockaddr(mp->msg_name);
 765 #endif
 766 #ifdef MAC
 767         if (mp->msg_name != NULL) {
 768                 error = mac_socket_check_connect(td->td_ucred, so,
 769                     mp->msg_name);
 770                 if (error != 0)
 771                         goto bad;
 772         }
 773         error = mac_socket_check_send(td->td_ucred, so);
 774         if (error != 0)
 775                 goto bad;
 776 #endif
 777
 778         auio.uio_iov = mp->msg_iov;
 779         auio.uio_iovcnt = mp->msg_iovlen;
 780         auio.uio_segflg = segflg;
 781         auio.uio_rw = UIO_WRITE;
 782         auio.uio_td = td;
 783         auio.uio_offset = 0;                    /* XXX */
 784         auio.uio_resid = 0;
 785         iov = mp->msg_iov;
 786         for (i = 0; i < mp->msg_iovlen; i++, iov++) {
 787                 if ((auio.uio_resid += iov->iov_len) < 0) {
 788                         error = EINVAL;
 789                         goto bad;
 790                 }
 791         }
 792 #ifdef KTRACE
 793         if (KTRPOINT(td, KTR_GENIO))
 794                 ktruio = cloneuio(&auio);
 795 #endif
 796         len = auio.uio_resid;
 797         error = sosend(so, mp->msg_name, &auio, 0, control, flags, td);
 798         if (error != 0) {
 799                 if (auio.uio_resid != len && (error == ERESTART ||
 800                     error == EINTR || error == EWOULDBLOCK))
 801                         error = 0;
 802                 /* Generation of SIGPIPE can be controlled per socket */
 803                 if (error == EPIPE && !(so->so_options & SO_NOSIGPIPE) &&
 804                     !(flags & MSG_NOSIGNAL)) {
 805                         PROC_LOCK(td->td_proc);
 806                         tdsignal(td, SIGPIPE);
 807                         PROC_UNLOCK(td->td_proc);
 808                 }
 809         }
 810         if (error == 0)
 811                 td->td_retval[0] = len - auio.uio_resid;
 812 #ifdef KTRACE
 813         if (ktruio != NULL) {
 814                 ktruio->uio_resid = td->td_retval[0];
 815                 ktrgenio(s, UIO_WRITE, ktruio, error);
 816         }
 817 #endif
 818 bad:
 819         fdrop(fp, td);
 820         return (error);
 821 }
 822
 823 int
 824 sys_sendto(struct thread *td, struct sendto_args *uap)
 825 {
 826         struct msghdr msg;
 827         struct iovec aiov;
 828
 829         msg.msg_name = uap->to;
 830         msg.msg_namelen = uap->tolen;
 831         msg.msg_iov = &aiov;
 832         msg.msg_iovlen = 1;
 833         msg.msg_control = 0;
 834 #ifdef COMPAT_OLDSOCK
 835         msg.msg_flags = 0;
 836 #endif
 837         aiov.iov_base = uap->buf;
 838         aiov.iov_len = uap->len;
 839         return (sendit(td, uap->s, &msg, uap->flags));
 840 }
 841
 842 #ifdef COMPAT_OLDSOCK
 843 int
 844 osend(struct thread *td, struct osend_args *uap)
 845 {
 846         struct msghdr msg;
 847         struct iovec aiov;
 848
 849         msg.msg_name = 0;
 850         msg.msg_namelen = 0;
 851         msg.msg_iov = &aiov;
 852         msg.msg_iovlen = 1;
 853         aiov.iov_base = uap->buf;
 854         aiov.iov_len = uap->len;
 855         msg.msg_control = 0;
 856         msg.msg_flags = 0;
 857         return (sendit(td, uap->s, &msg, uap->flags));
 858 }
 859
 860 int
 861 osendmsg(struct thread *td, struct osendmsg_args *uap)
 862 {
 863         struct msghdr msg;
 864         struct iovec *iov;
 865         int error;
 866
 867         error = copyin(uap->msg, &msg, sizeof (struct omsghdr));
 868         if (error != 0)
 869                 return (error);
 870         error = copyiniov(msg.msg_iov, msg.msg_iovlen, &iov, EMSGSIZE);
 871         if (error != 0)
 872                 return (error);
 873         msg.msg_iov = iov;
 874         msg.msg_flags = MSG_COMPAT;
 875         error = sendit(td, uap->s, &msg, uap->flags);
 876         free(iov, M_IOV);
 877         return (error);
 878 }
 879 #endif
 880
 881 int
 882 sys_sendmsg(struct thread *td, struct sendmsg_args *uap)
 883 {
 884         struct msghdr msg;
 885         struct iovec *iov;
 886         int error;
 887
 888         error = copyin(uap->msg, &msg, sizeof (msg));
 889         if (error != 0)
 890                 return (error);
 891         error = copyiniov(msg.msg_iov, msg.msg_iovlen, &iov, EMSGSIZE);
 892         if (error != 0)
 893                 return (error);
 894         msg.msg_iov = iov;
 895 #ifdef COMPAT_OLDSOCK
 896         msg.msg_flags = 0;
 897 #endif
 898         error = sendit(td, uap->s, &msg, uap->flags);
 899         free(iov, M_IOV);
 900         return (error);
 901 }
 902
 903 int
 904 kern_recvit(struct thread *td, int s, struct msghdr *mp, enum uio_seg fromseg,
 905     struct mbuf **controlp)
 906 {
 907         struct uio auio;
 908         struct iovec *iov;
 909         struct mbuf *m, *control = NULL;
 910         caddr_t ctlbuf;
 911         struct file *fp;
 912         struct socket *so;
 913         struct sockaddr *fromsa = NULL;
 914         cap_rights_t rights;
 915 #ifdef KTRACE
 916         struct uio *ktruio = NULL;
 917 #endif
 918         ssize_t len;
 919         int error, i;
 920
 921         if (controlp != NULL)
 922                 *controlp = NULL;
 923
 924         AUDIT_ARG_FD(s);
 925         error = getsock_cap(td, s, cap_rights_init(&rights, CAP_RECV),
 926             &fp, NULL);
 927         if (error != 0)
 928                 return (error);
 929         so = fp->f_data;
 930
 931 #ifdef MAC
 932         error = mac_socket_check_receive(td->td_ucred, so);
 933         if (error != 0) {
 934                 fdrop(fp, td);
 935                 return (error);
 936         }
 937 #endif
 938
 939         auio.uio_iov = mp->msg_iov;
 940         auio.uio_iovcnt = mp->msg_iovlen;
 941         auio.uio_segflg = UIO_USERSPACE;
 942         auio.uio_rw = UIO_READ;
 943         auio.uio_td = td;
 944         auio.uio_offset = 0;                    /* XXX */
 945         auio.uio_resid = 0;
 946         iov = mp->msg_iov;
 947         for (i = 0; i < mp->msg_iovlen; i++, iov++) {
 948                 if ((auio.uio_resid += iov->iov_len) < 0) {
 949                         fdrop(fp, td);
 950                         return (EINVAL);
 951                 }
 952         }
 953 #ifdef KTRACE
 954         if (KTRPOINT(td, KTR_GENIO))
 955                 ktruio = cloneuio(&auio);
 956 #endif
 957         len = auio.uio_resid;
 958         error = soreceive(so, &fromsa, &auio, NULL,
 959             (mp->msg_control || controlp) ? &control : NULL,
 960             &mp->msg_flags);
 961         if (error != 0) {
 962                 if (auio.uio_resid != len && (error == ERESTART ||
 963                     error == EINTR || error == EWOULDBLOCK))
 964                         error = 0;
 965         }
 966         if (fromsa != NULL)
 967                 AUDIT_ARG_SOCKADDR(td, AT_FDCWD, fromsa);
 968 #ifdef KTRACE
 969         if (ktruio != NULL) {
 970                 ktruio->uio_resid = len - auio.uio_resid;
 971                 ktrgenio(s, UIO_READ, ktruio, error);
 972         }
 973 #endif
 974         if (error != 0)
 975                 goto out;
 976         td->td_retval[0] = len - auio.uio_resid;
 977         if (mp->msg_name) {
 978                 len = mp->msg_namelen;
 979                 if (len <= 0 || fromsa == NULL)
 980                         len = 0;
 981                 else {
 982                         /* save sa_len before it is destroyed by MSG_COMPAT */
 983                         len = MIN(len, fromsa->sa_len);
 984 #ifdef COMPAT_OLDSOCK
 985                         if (mp->msg_flags & MSG_COMPAT)
 986                                 ((struct osockaddr *)fromsa)->sa_family =
 987                                     fromsa->sa_family;
 988 #endif
 989                         if (fromseg == UIO_USERSPACE) {
 990                                 error = copyout(fromsa, mp->msg_name,
 991                                     (unsigned)len);
 992                                 if (error != 0)
 993                                         goto out;
 994                         } else
 995                                 bcopy(fromsa, mp->msg_name, len);
 996                 }
 997                 mp->msg_namelen = len;
 998         }
 999         if (mp->msg_control && controlp == NULL) {
1000 #ifdef COMPAT_OLDSOCK
1001                 /*
1002                  * We assume that old recvmsg calls won't receive access
1003                  * rights and other control info, esp. as control info
1004                  * is always optional and those options didn't exist in 4.3.
1005                  * If we receive rights, trim the cmsghdr; anything else
1006                  * is tossed.
1007                  */
1008                 if (control && mp->msg_flags & MSG_COMPAT) {
1009                         if (mtod(control, struct cmsghdr *)->cmsg_level !=
1010                             SOL_SOCKET ||
1011                             mtod(control, struct cmsghdr *)->cmsg_type !=
1012                             SCM_RIGHTS) {
1013                                 mp->msg_controllen = 0;
1014                                 goto out;
1015                         }
1016                         control->m_len -= sizeof (struct cmsghdr);
1017                         control->m_data += sizeof (struct cmsghdr);
1018                 }
1019 #endif
1020                 len = mp->msg_controllen;
1021                 m = control;
1022                 mp->msg_controllen = 0;
1023                 ctlbuf = mp->msg_control;
1024
1025                 while (m && len > 0) {
1026                         unsigned int tocopy;
1027
1028                         if (len >= m->m_len)
1029                                 tocopy = m->m_len;
1030                         else {
1031                                 mp->msg_flags |= MSG_CTRUNC;
1032                                 tocopy = len;
1033                         }
1034
1035                         if ((error = copyout(mtod(m, caddr_t),
1036                                         ctlbuf, tocopy)) != 0)
1037                                 goto out;
1038
1039                         ctlbuf += tocopy;
1040                         len -= tocopy;
1041                         m = m->m_next;
1042                 }
1043                 mp->msg_controllen = ctlbuf - (caddr_t)mp->msg_control;
1044         }
1045 out:
1046         fdrop(fp, td);
1047 #ifdef KTRACE
1048         if (fromsa && KTRPOINT(td, KTR_STRUCT))
1049                 ktrsockaddr(fromsa);
1050 #endif
1051         free(fromsa, M_SONAME);
1052
1053         if (error == 0 && controlp != NULL)
1054                 *controlp = control;
1055         else  if (control)
1056                 m_freem(control);
1057
1058         return (error);
1059 }
1060
1061 static int
1062 recvit(struct thread *td, int s, struct msghdr *mp, void *namelenp)
1063 {
1064         int error;
1065
1066         error = kern_recvit(td, s, mp, UIO_USERSPACE, NULL);
1067         if (error != 0)
1068                 return (error);
1069         if (namelenp != NULL) {
1070                 error = copyout(&mp->msg_namelen, namelenp, sizeof (socklen_t));
1071 #ifdef COMPAT_OLDSOCK
1072                 if (mp->msg_flags & MSG_COMPAT)
1073                         error = 0;      /* old recvfrom didn't check */
1074 #endif
1075         }
1076         return (error);
1077 }
1078
1079 int
1080 sys_recvfrom(struct thread *td, struct recvfrom_args *uap)
1081 {
1082         struct msghdr msg;
1083         struct iovec aiov;
1084         int error;
1085
1086         if (uap->fromlenaddr) {
1087                 error = copyin(uap->fromlenaddr,
1088                     &msg.msg_namelen, sizeof (msg.msg_namelen));
1089                 if (error != 0)
1090                         goto done2;
1091         } else {
1092                 msg.msg_namelen = 0;
1093         }
1094         msg.msg_name = uap->from;
1095         msg.msg_iov = &aiov;
1096         msg.msg_iovlen = 1;
1097         aiov.iov_base = uap->buf;
1098         aiov.iov_len = uap->len;
1099         msg.msg_control = 0;
1100         msg.msg_flags = uap->flags;
1101         error = recvit(td, uap->s, &msg, uap->fromlenaddr);
1102 done2:
1103         return (error);
1104 }
1105
1106 #ifdef COMPAT_OLDSOCK
1107 int
1108 orecvfrom(struct thread *td, struct recvfrom_args *uap)
1109 {
1110
1111         uap->flags |= MSG_COMPAT;
1112         return (sys_recvfrom(td, uap));
1113 }
1114 #endif
1115
1116 #ifdef COMPAT_OLDSOCK
1117 int
1118 orecv(struct thread *td, struct orecv_args *uap)
1119 {
1120         struct msghdr msg;
1121         struct iovec aiov;
1122
1123         msg.msg_name = 0;
1124         msg.msg_namelen = 0;
1125         msg.msg_iov = &aiov;
1126         msg.msg_iovlen = 1;
1127         aiov.iov_base = uap->buf;
1128         aiov.iov_len = uap->len;
1129         msg.msg_control = 0;
1130         msg.msg_flags = uap->flags;
1131         return (recvit(td, uap->s, &msg, NULL));
1132 }
1133
1134 /*
1135  * Old recvmsg.  This code takes advantage of the fact that the old msghdr
1136  * overlays the new one, missing only the flags, and with the (old) access
1137  * rights where the control fields are now.
1138  */
1139 int
1140 orecvmsg(struct thread *td, struct orecvmsg_args *uap)
1141 {
1142         struct msghdr msg;
1143         struct iovec *iov;
1144         int error;
1145
1146         error = copyin(uap->msg, &msg, sizeof (struct omsghdr));
1147         if (error != 0)
1148                 return (error);
1149         error = copyiniov(msg.msg_iov, msg.msg_iovlen, &iov, EMSGSIZE);
1150         if (error != 0)
1151                 return (error);
1152         msg.msg_flags = uap->flags | MSG_COMPAT;
1153         msg.msg_iov = iov;
1154         error = recvit(td, uap->s, &msg, &uap->msg->msg_namelen);
1155         if (msg.msg_controllen && error == 0)
1156                 error = copyout(&msg.msg_controllen,
1157                     &uap->msg->msg_accrightslen, sizeof (int));
1158         free(iov, M_IOV);
1159         return (error);
1160 }
1161 #endif
1162
1163 int
1164 sys_recvmsg(struct thread *td, struct recvmsg_args *uap)
1165 {
1166         struct msghdr msg;
1167         struct iovec *uiov, *iov;
1168         int error;
1169
1170         error = copyin(uap->msg, &msg, sizeof (msg));
1171         if (error != 0)
1172                 return (error);
1173         error = copyiniov(msg.msg_iov, msg.msg_iovlen, &iov, EMSGSIZE);
1174         if (error != 0)
1175                 return (error);
1176         msg.msg_flags = uap->flags;
1177 #ifdef COMPAT_OLDSOCK
1178         msg.msg_flags &= ~MSG_COMPAT;
1179 #endif
1180         uiov = msg.msg_iov;
1181         msg.msg_iov = iov;
1182         error = recvit(td, uap->s, &msg, NULL);
1183         if (error == 0) {
1184                 msg.msg_iov = uiov;
1185                 error = copyout(&msg, uap->msg, sizeof(msg));
1186         }
1187         free(iov, M_IOV);
1188         return (error);
1189 }
1190
1191 int
1192 sys_shutdown(struct thread *td, struct shutdown_args *uap)
1193 {
1194         struct socket *so;
1195         struct file *fp;
1196         cap_rights_t rights;
1197         int error;
1198
1199         AUDIT_ARG_FD(uap->s);
1200         error = getsock_cap(td, uap->s, cap_rights_init(&rights, CAP_SHUTDOWN),
1201             &fp, NULL);
1202         if (error == 0) {
1203                 so = fp->f_data;
1204                 error = soshutdown(so, uap->how);
1205                 /*
1206                  * Previous versions did not return ENOTCONN, but 0 in
1207                  * case the socket was not connected. Some important
1208                  * programs like syslogd up to r279016, 2015-02-19,
1209                  * still depend on this behavior.
1210                  */
1211                 if (error == ENOTCONN &&
1212                     td->td_proc->p_osrel < P_OSREL_SHUTDOWN_ENOTCONN)
1213                         error = 0;
1214                 fdrop(fp, td);
1215         }
1216         return (error);
1217 }
1218
1219 int
1220 sys_setsockopt(struct thread *td, struct setsockopt_args *uap)
1221 {
1222
1223         return (kern_setsockopt(td, uap->s, uap->level, uap->name,
1224             uap->val, UIO_USERSPACE, uap->valsize));
1225 }
1226
1227 int
1228 kern_setsockopt(struct thread *td, int s, int level, int name, void *val,
1229     enum uio_seg valseg, socklen_t valsize)
1230 {
1231         struct socket *so;
1232         struct file *fp;
1233         struct sockopt sopt;
1234         cap_rights_t rights;
1235         int error;
1236
1237         if (val == NULL && valsize != 0)
1238                 return (EFAULT);
1239         if ((int)valsize < 0)
1240                 return (EINVAL);
1241
1242         sopt.sopt_dir = SOPT_SET;
1243         sopt.sopt_level = level;
1244         sopt.sopt_name = name;
1245         sopt.sopt_val = val;
1246         sopt.sopt_valsize = valsize;
1247         switch (valseg) {
1248         case UIO_USERSPACE:
1249                 sopt.sopt_td = td;
1250                 break;
1251         case UIO_SYSSPACE:
1252                 sopt.sopt_td = NULL;
1253                 break;
1254         default:
1255                 panic("kern_setsockopt called with bad valseg");
1256         }
1257
1258         AUDIT_ARG_FD(s);
1259         error = getsock_cap(td, s, cap_rights_init(&rights, CAP_SETSOCKOPT),
1260             &fp, NULL);
1261         if (error == 0) {
1262                 so = fp->f_data;
1263                 error = sosetopt(so, &sopt);
1264                 fdrop(fp, td);
1265         }
1266         return(error);
1267 }
1268
1269 int
1270 sys_getsockopt(struct thread *td, struct getsockopt_args *uap)
1271 {
1272         socklen_t valsize;
1273         int error;
1274
1275         if (uap->val) {
1276                 error = copyin(uap->avalsize, &valsize, sizeof (valsize));
1277                 if (error != 0)
1278                         return (error);
1279         }
1280
1281         error = kern_getsockopt(td, uap->s, uap->level, uap->name,
1282             uap->val, UIO_USERSPACE, &valsize);
1283
1284         if (error == 0)
1285                 error = copyout(&valsize, uap->avalsize, sizeof (valsize));
1286         return (error);
1287 }
1288
1289 /*
1290  * Kernel version of getsockopt.
1291  * optval can be a userland or userspace. optlen is always a kernel pointer.
1292  */
1293 int
1294 kern_getsockopt(struct thread *td, int s, int level, int name, void *val,
1295     enum uio_seg valseg, socklen_t *valsize)
1296 {
1297         struct socket *so;
1298         struct file *fp;
1299         struct sockopt sopt;
1300         cap_rights_t rights;
1301         int error;
1302
1303         if (val == NULL)
1304                 *valsize = 0;
1305         if ((int)*valsize < 0)
1306                 return (EINVAL);
1307
1308         sopt.sopt_dir = SOPT_GET;
1309         sopt.sopt_level = level;
1310         sopt.sopt_name = name;
1311         sopt.sopt_val = val;
1312         sopt.sopt_valsize = (size_t)*valsize; /* checked non-negative above */
1313         switch (valseg) {
1314         case UIO_USERSPACE:
1315                 sopt.sopt_td = td;
1316                 break;
1317         case UIO_SYSSPACE:
1318                 sopt.sopt_td = NULL;
1319                 break;
1320         default:
1321                 panic("kern_getsockopt called with bad valseg");
1322         }
1323
1324         AUDIT_ARG_FD(s);
1325         error = getsock_cap(td, s, cap_rights_init(&rights, CAP_GETSOCKOPT),
1326             &fp, NULL);
1327         if (error == 0) {
1328                 so = fp->f_data;
1329                 error = sogetopt(so, &sopt);
1330                 *valsize = sopt.sopt_valsize;
1331                 fdrop(fp, td);
1332         }
1333         return (error);
1334 }
1335
1336 /*
1337  * getsockname1() - Get socket name.
1338  */
1339 static int
1340 getsockname1(struct thread *td, struct getsockname_args *uap, int compat)
1341 {
1342         struct sockaddr *sa;
1343         socklen_t len;
1344         int error;
1345
1346         error = copyin(uap->alen, &len, sizeof(len));
1347         if (error != 0)
1348                 return (error);
1349
1350         error = kern_getsockname(td, uap->fdes, &sa, &len);
1351         if (error != 0)
1352                 return (error);
1353
1354         if (len != 0) {
1355 #ifdef COMPAT_OLDSOCK
1356                 if (compat)
1357                         ((struct osockaddr *)sa)->sa_family = sa->sa_family;
1358 #endif
1359                 error = copyout(sa, uap->asa, (u_int)len);
1360         }
1361         free(sa, M_SONAME);
1362         if (error == 0)
1363                 error = copyout(&len, uap->alen, sizeof(len));
1364         return (error);
1365 }
1366
1367 int
1368 kern_getsockname(struct thread *td, int fd, struct sockaddr **sa,
1369     socklen_t *alen)
1370 {
1371         struct socket *so;
1372         struct file *fp;
1373         cap_rights_t rights;
1374         socklen_t len;
1375         int error;
1376
1377         AUDIT_ARG_FD(fd);
1378         error = getsock_cap(td, fd, cap_rights_init(&rights, CAP_GETSOCKNAME),
1379             &fp, NULL);
1380         if (error != 0)
1381                 return (error);
1382         so = fp->f_data;
1383         *sa = NULL;
1384         CURVNET_SET(so->so_vnet);
1385         error = (*so->so_proto->pr_usrreqs->pru_sockaddr)(so, sa);
1386         CURVNET_RESTORE();
1387         if (error != 0)
1388                 goto bad;
1389         if (*sa == NULL)
1390                 len = 0;
1391         else
1392                 len = MIN(*alen, (*sa)->sa_len);
1393         *alen = len;
1394 #ifdef KTRACE
1395         if (KTRPOINT(td, KTR_STRUCT))
1396                 ktrsockaddr(*sa);
1397 #endif
1398 bad:
1399         fdrop(fp, td);
1400         if (error != 0 && *sa != NULL) {
1401                 free(*sa, M_SONAME);
1402                 *sa = NULL;
1403         }
1404         return (error);
1405 }
1406
1407 int
1408 sys_getsockname(struct thread *td, struct getsockname_args *uap)
1409 {
1410
1411         return (getsockname1(td, uap, 0));
1412 }
1413
1414 #ifdef COMPAT_OLDSOCK
1415 int
1416 ogetsockname(struct thread *td, struct getsockname_args *uap)
1417 {
1418
1419         return (getsockname1(td, uap, 1));
1420 }
1421 #endif /* COMPAT_OLDSOCK */
1422
1423 /*
1424  * getpeername1() - Get name of peer for connected socket.
1425  */
1426 static int
1427 getpeername1(struct thread *td, struct getpeername_args *uap, int compat)
1428 {
1429         struct sockaddr *sa;
1430         socklen_t len;
1431         int error;
1432
1433         error = copyin(uap->alen, &len, sizeof (len));
1434         if (error != 0)
1435                 return (error);
1436
1437         error = kern_getpeername(td, uap->fdes, &sa, &len);
1438         if (error != 0)
1439                 return (error);
1440
1441         if (len != 0) {
1442 #ifdef COMPAT_OLDSOCK
1443                 if (compat)
1444                         ((struct osockaddr *)sa)->sa_family = sa->sa_family;
1445 #endif
1446                 error = copyout(sa, uap->asa, (u_int)len);
1447         }
1448         free(sa, M_SONAME);
1449         if (error == 0)
1450                 error = copyout(&len, uap->alen, sizeof(len));
1451         return (error);
1452 }
1453
1454 int
1455 kern_getpeername(struct thread *td, int fd, struct sockaddr **sa,
1456     socklen_t *alen)
1457 {
1458         struct socket *so;
1459         struct file *fp;
1460         cap_rights_t rights;
1461         socklen_t len;
1462         int error;
1463
1464         AUDIT_ARG_FD(fd);
1465         error = getsock_cap(td, fd, cap_rights_init(&rights, CAP_GETPEERNAME),
1466             &fp, NULL);
1467         if (error != 0)
1468                 return (error);
1469         so = fp->f_data;
1470         if ((so->so_state & (SS_ISCONNECTED|SS_ISCONFIRMING)) == 0) {
1471                 error = ENOTCONN;
1472                 goto done;
1473         }
1474         *sa = NULL;
1475         CURVNET_SET(so->so_vnet);
1476         error = (*so->so_proto->pr_usrreqs->pru_peeraddr)(so, sa);
1477         CURVNET_RESTORE();
1478         if (error != 0)
1479                 goto bad;
1480         if (*sa == NULL)
1481                 len = 0;
1482         else
1483                 len = MIN(*alen, (*sa)->sa_len);
1484         *alen = len;
1485 #ifdef KTRACE
1486         if (KTRPOINT(td, KTR_STRUCT))
1487                 ktrsockaddr(*sa);
1488 #endif
1489 bad:
1490         if (error != 0 && *sa != NULL) {
1491                 free(*sa, M_SONAME);
1492                 *sa = NULL;
1493         }
1494 done:
1495         fdrop(fp, td);
1496         return (error);
1497 }
1498
1499 int
1500 sys_getpeername(struct thread *td, struct getpeername_args *uap)
1501 {
1502
1503         return (getpeername1(td, uap, 0));
1504 }
1505
1506 #ifdef COMPAT_OLDSOCK
1507 int
1508 ogetpeername(struct thread *td, struct ogetpeername_args *uap)
1509 {
1510
1511         /* XXX uap should have type `getpeername_args *' to begin with. */
1512         return (getpeername1(td, (struct getpeername_args *)uap, 1));
1513 }
1514 #endif /* COMPAT_OLDSOCK */
1515
1516 static int
1517 sockargs(struct mbuf **mp, char *buf, socklen_t buflen, int type)
1518 {
1519         struct sockaddr *sa;
1520         struct mbuf *m;
1521         int error;
1522
1523         if (buflen > MLEN) {
1524 #ifdef COMPAT_OLDSOCK
1525                 if (type == MT_SONAME && buflen <= 112)
1526                         buflen = MLEN;          /* unix domain compat. hack */
1527                 else
1528 #endif
1529                         if (buflen > MCLBYTES)
1530                                 return (EINVAL);
1531         }
1532         m = m_get2(buflen, M_WAITOK, type, 0);
1533         m->m_len = buflen;
1534         error = copyin(buf, mtod(m, void *), buflen);
1535         if (error != 0)
1536                 (void) m_free(m);
1537         else {
1538                 *mp = m;
1539                 if (type == MT_SONAME) {
1540                         sa = mtod(m, struct sockaddr *);
1541
1542 #if defined(COMPAT_OLDSOCK) && BYTE_ORDER != BIG_ENDIAN
1543                         if (sa->sa_family == 0 && sa->sa_len < AF_MAX)
1544                                 sa->sa_family = sa->sa_len;
1545 #endif
1546                         sa->sa_len = buflen;
1547                 }
1548         }
1549         return (error);
1550 }
1551
1552 int
1553 getsockaddr(struct sockaddr **namp, caddr_t uaddr, size_t len)
1554 {
1555         struct sockaddr *sa;
1556         int error;
1557
1558         if (len > SOCK_MAXADDRLEN)
1559                 return (ENAMETOOLONG);
1560         if (len < offsetof(struct sockaddr, sa_data[0]))
1561                 return (EINVAL);
1562         sa = malloc(len, M_SONAME, M_WAITOK);
1563         error = copyin(uaddr, sa, len);
1564         if (error != 0) {
1565                 free(sa, M_SONAME);
1566         } else {
1567 #if defined(COMPAT_OLDSOCK) && BYTE_ORDER != BIG_ENDIAN
1568                 if (sa->sa_family == 0 && sa->sa_len < AF_MAX)
1569                         sa->sa_family = sa->sa_len;
1570 #endif
1571                 sa->sa_len = len;
1572                 *namp = sa;
1573         }
1574         return (error);
1575 }