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