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