sys/kern/uipc_syscalls.c

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