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