1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #include <sys/types.h> 28 #include <sys/param.h> 29 #include <sys/systm.h> 30 #include <sys/sysmacros.h> 31 #include <sys/debug.h> 32 #include <sys/cmn_err.h> 33 34 #include <sys/stropts.h> 35 #include <sys/socket.h> 36 #include <sys/socketvar.h> 37 38 #define _SUN_TPI_VERSION 2 39 #include <sys/tihdr.h> 40 #include <sys/sockio.h> 41 #include <sys/sodirect.h> 42 #include <sys/kmem_impl.h> 43 44 #include <sys/strsubr.h> 45 #include <sys/strsun.h> 46 #include <sys/ddi.h> 47 #include <netinet/in.h> 48 #include <inet/ip.h> 49 50 #include <fs/sockfs/sockcommon.h> 51 52 #include <sys/socket_proto.h> 53 54 #include <fs/sockfs/socktpi_impl.h> 55 #include <sys/tihdr.h> 56 #include <fs/sockfs/nl7c.h> 57 #include <inet/kssl/ksslapi.h> 58 59 60 extern int xnet_skip_checks; 61 extern int xnet_check_print; 62 63 static void so_queue_oob(sock_upper_handle_t, mblk_t *, size_t); 64 65 66 /*ARGSUSED*/ 67 int 68 so_accept_notsupp(struct sonode *lso, int fflag, 69 struct cred *cr, struct sonode **nsop) 70 { 71 return (EOPNOTSUPP); 72 } 73 74 /*ARGSUSED*/ 75 int 76 so_listen_notsupp(struct sonode *so, int backlog, struct cred *cr) 77 { 78 return (EOPNOTSUPP); 79 } 80 81 /*ARGSUSED*/ 82 int 83 so_getsockname_notsupp(struct sonode *so, struct sockaddr *sa, 84 socklen_t *len, struct cred *cr) 85 { 86 return (EOPNOTSUPP); 87 } 88 89 /*ARGSUSED*/ 90 int 91 so_getpeername_notsupp(struct sonode *so, struct sockaddr *addr, 92 socklen_t *addrlen, boolean_t accept, struct cred *cr) 93 { 94 return (EOPNOTSUPP); 95 } 96 97 /*ARGSUSED*/ 98 int 99 so_shutdown_notsupp(struct sonode *so, int how, struct cred *cr) 100 { 101 return (EOPNOTSUPP); 102 } 103 104 /*ARGSUSED*/ 105 int 106 so_sendmblk_notsupp(struct sonode *so, struct msghdr *msg, int fflag, 107 struct cred *cr, mblk_t **mpp) 108 { 109 return (EOPNOTSUPP); 110 } 111 112 /* 113 * Generic Socket Ops 114 */ 115 116 /* ARGSUSED */ 117 int 118 so_init(struct sonode *so, struct sonode *pso, struct cred *cr, int flags) 119 { 120 return (socket_init_common(so, pso, flags, cr)); 121 } 122 123 int 124 so_bind(struct sonode *so, struct sockaddr *name, socklen_t namelen, 125 int flags, struct cred *cr) 126 { 127 int error; 128 129 SO_BLOCK_FALLBACK(so, SOP_BIND(so, name, namelen, flags, cr)); 130 131 ASSERT(flags == _SOBIND_XPG4_2 || flags == _SOBIND_SOCKBSD); 132 133 /* X/Open requires this check */ 134 if ((so->so_state & SS_CANTSENDMORE) && !xnet_skip_checks) { 135 if (xnet_check_print) { 136 printf("sockfs: X/Open bind state check " 137 "caused EINVAL\n"); 138 } 139 error = EINVAL; 140 goto done; 141 } 142 143 /* 144 * a bind to a NULL address is interpreted as unbind. So just 145 * do the downcall. 146 */ 147 if (name == NULL) 148 goto dobind; 149 150 switch (so->so_family) { 151 case AF_INET: 152 if ((size_t)namelen != sizeof (sin_t)) { 153 error = name->sa_family != so->so_family ? 154 EAFNOSUPPORT : EINVAL; 155 eprintsoline(so, error); 156 goto done; 157 } 158 159 if ((flags & _SOBIND_XPG4_2) && 160 (name->sa_family != so->so_family)) { 161 /* 162 * This check has to be made for X/Open 163 * sockets however application failures have 164 * been observed when it is applied to 165 * all sockets. 166 */ 167 error = EAFNOSUPPORT; 168 eprintsoline(so, error); 169 goto done; 170 } 171 /* 172 * Force a zero sa_family to match so_family. 173 * 174 * Some programs like inetd(1M) don't set the 175 * family field. Other programs leave 176 * sin_family set to garbage - SunOS 4.X does 177 * not check the family field on a bind. 178 * We use the family field that 179 * was passed in to the socket() call. 180 */ 181 name->sa_family = so->so_family; 182 break; 183 184 case AF_INET6: { 185 #ifdef DEBUG 186 sin6_t *sin6 = (sin6_t *)name; 187 #endif 188 if ((size_t)namelen != sizeof (sin6_t)) { 189 error = name->sa_family != so->so_family ? 190 EAFNOSUPPORT : EINVAL; 191 eprintsoline(so, error); 192 goto done; 193 } 194 195 if (name->sa_family != so->so_family) { 196 /* 197 * With IPv6 we require the family to match 198 * unlike in IPv4. 199 */ 200 error = EAFNOSUPPORT; 201 eprintsoline(so, error); 202 goto done; 203 } 204 #ifdef DEBUG 205 /* 206 * Verify that apps don't forget to clear 207 * sin6_scope_id etc 208 */ 209 if (sin6->sin6_scope_id != 0 && 210 !IN6_IS_ADDR_LINKSCOPE(&sin6->sin6_addr)) { 211 zcmn_err(getzoneid(), CE_WARN, 212 "bind with uninitialized sin6_scope_id " 213 "(%d) on socket. Pid = %d\n", 214 (int)sin6->sin6_scope_id, 215 (int)curproc->p_pid); 216 } 217 if (sin6->__sin6_src_id != 0) { 218 zcmn_err(getzoneid(), CE_WARN, 219 "bind with uninitialized __sin6_src_id " 220 "(%d) on socket. Pid = %d\n", 221 (int)sin6->__sin6_src_id, 222 (int)curproc->p_pid); 223 } 224 #endif /* DEBUG */ 225 226 break; 227 } 228 default: 229 /* Just pass the request to the protocol */ 230 goto dobind; 231 } 232 233 /* 234 * First we check if either NCA or KSSL has been enabled for 235 * the requested address, and if so, we fall back to TPI. 236 * If neither of those two services are enabled, then we just 237 * pass the request to the protocol. 238 * 239 * Note that KSSL can only be enabled on a socket if NCA is NOT 240 * enabled for that socket, hence the else-statement below. 241 */ 242 if (nl7c_enabled && ((so->so_family == AF_INET || 243 so->so_family == AF_INET6) && 244 nl7c_lookup_addr(name, namelen) != NULL)) { 245 /* 246 * NL7C is not supported in non-global zones, 247 * we enforce this restriction here. 248 */ 249 if (so->so_zoneid == GLOBAL_ZONEID) { 250 /* NCA should be used, so fall back to TPI */ 251 error = so_tpi_fallback(so, cr); 252 SO_UNBLOCK_FALLBACK(so); 253 if (error) 254 return (error); 255 else 256 return (SOP_BIND(so, name, namelen, flags, cr)); 257 } 258 } else if (so->so_type == SOCK_STREAM) { 259 /* Check if KSSL has been configured for this address */ 260 kssl_ent_t ent; 261 kssl_endpt_type_t type; 262 struct T_bind_req bind_req; 263 mblk_t *mp; 264 265 /* 266 * TODO: Check with KSSL team if we could add a function call 267 * that only queries whether KSSL is enabled for the given 268 * address. 269 */ 270 bind_req.PRIM_type = T_BIND_REQ; 271 bind_req.ADDR_length = namelen; 272 bind_req.ADDR_offset = (t_scalar_t)sizeof (bind_req); 273 mp = soallocproto2(&bind_req, sizeof (bind_req), 274 name, namelen, 0, _ALLOC_SLEEP, cr); 275 276 type = kssl_check_proxy(mp, so, &ent); 277 freemsg(mp); 278 279 if (type != KSSL_NO_PROXY) { 280 /* 281 * KSSL has been configured for this address, so 282 * we must fall back to TPI. 283 */ 284 kssl_release_ent(ent, so, type); 285 error = so_tpi_fallback(so, cr); 286 SO_UNBLOCK_FALLBACK(so); 287 if (error) 288 return (error); 289 else 290 return (SOP_BIND(so, name, namelen, flags, cr)); 291 } 292 } 293 294 dobind: 295 error = (*so->so_downcalls->sd_bind) 296 (so->so_proto_handle, name, namelen, cr); 297 done: 298 SO_UNBLOCK_FALLBACK(so); 299 300 return (error); 301 } 302 303 int 304 so_listen(struct sonode *so, int backlog, struct cred *cr) 305 { 306 int error = 0; 307 308 ASSERT(MUTEX_NOT_HELD(&so->so_lock)); 309 SO_BLOCK_FALLBACK(so, SOP_LISTEN(so, backlog, cr)); 310 311 error = (*so->so_downcalls->sd_listen)(so->so_proto_handle, backlog, 312 cr); 313 314 SO_UNBLOCK_FALLBACK(so); 315 316 return (error); 317 } 318 319 320 int 321 so_connect(struct sonode *so, const struct sockaddr *name, 322 socklen_t namelen, int fflag, int flags, struct cred *cr) 323 { 324 int error = 0; 325 sock_connid_t id; 326 327 ASSERT(MUTEX_NOT_HELD(&so->so_lock)); 328 SO_BLOCK_FALLBACK(so, SOP_CONNECT(so, name, namelen, fflag, flags, cr)); 329 330 /* 331 * If there is a pending error, return error 332 * This can happen if a non blocking operation caused an error. 333 */ 334 335 if (so->so_error != 0) { 336 mutex_enter(&so->so_lock); 337 error = sogeterr(so, B_TRUE); 338 mutex_exit(&so->so_lock); 339 if (error != 0) 340 goto done; 341 } 342 343 error = (*so->so_downcalls->sd_connect)(so->so_proto_handle, 344 name, namelen, &id, cr); 345 346 if (error == EINPROGRESS) 347 error = so_wait_connected(so, fflag & (FNONBLOCK|FNDELAY), id); 348 349 done: 350 SO_UNBLOCK_FALLBACK(so); 351 return (error); 352 } 353 354 /*ARGSUSED*/ 355 int 356 so_accept(struct sonode *so, int fflag, struct cred *cr, struct sonode **nsop) 357 { 358 int error = 0; 359 struct sonode *nso; 360 361 *nsop = NULL; 362 363 SO_BLOCK_FALLBACK(so, SOP_ACCEPT(so, fflag, cr, nsop)); 364 if ((so->so_state & SS_ACCEPTCONN) == 0) { 365 SO_UNBLOCK_FALLBACK(so); 366 return ((so->so_type == SOCK_DGRAM || so->so_type == SOCK_RAW) ? 367 EOPNOTSUPP : EINVAL); 368 } 369 370 if ((error = so_acceptq_dequeue(so, (fflag & (FNONBLOCK|FNDELAY)), 371 &nso)) == 0) { 372 ASSERT(nso != NULL); 373 374 /* finish the accept */ 375 error = (*so->so_downcalls->sd_accept)(so->so_proto_handle, 376 nso->so_proto_handle, (sock_upper_handle_t)nso, cr); 377 if (error != 0) { 378 (void) socket_close(nso, 0, cr); 379 socket_destroy(nso); 380 } else { 381 *nsop = nso; 382 } 383 } 384 385 SO_UNBLOCK_FALLBACK(so); 386 return (error); 387 } 388 389 int 390 so_sendmsg(struct sonode *so, struct nmsghdr *msg, struct uio *uiop, 391 struct cred *cr) 392 { 393 int error, flags; 394 boolean_t dontblock; 395 ssize_t orig_resid; 396 mblk_t *mp; 397 398 SO_BLOCK_FALLBACK(so, SOP_SENDMSG(so, msg, uiop, cr)); 399 400 flags = msg->msg_flags; 401 error = 0; 402 dontblock = (flags & MSG_DONTWAIT) || 403 (uiop->uio_fmode & (FNONBLOCK|FNDELAY)); 404 405 if (!(flags & MSG_XPG4_2) && msg->msg_controllen != 0) { 406 /* 407 * Old way of passing fd's is not supported 408 */ 409 SO_UNBLOCK_FALLBACK(so); 410 return (EOPNOTSUPP); 411 } 412 413 if ((so->so_mode & SM_ATOMIC) && 414 uiop->uio_resid > so->so_proto_props.sopp_maxpsz && 415 so->so_proto_props.sopp_maxpsz != -1) { 416 SO_UNBLOCK_FALLBACK(so); 417 return (EMSGSIZE); 418 } 419 420 /* 421 * For atomic sends we will only do one iteration. 422 */ 423 do { 424 if (so->so_state & SS_CANTSENDMORE) { 425 error = EPIPE; 426 break; 427 } 428 429 if (so->so_error != 0) { 430 mutex_enter(&so->so_lock); 431 error = sogeterr(so, B_TRUE); 432 mutex_exit(&so->so_lock); 433 if (error != 0) 434 break; 435 } 436 437 /* 438 * Send down OOB messages even if the send path is being 439 * flow controlled (assuming the protocol supports OOB data). 440 */ 441 if (flags & MSG_OOB) { 442 if ((so->so_mode & SM_EXDATA) == 0) { 443 error = EOPNOTSUPP; 444 break; 445 } 446 } else if (so->so_snd_qfull) { 447 /* 448 * Need to wait until the protocol is ready to receive 449 * more data for transmission. 450 */ 451 if ((error = so_snd_wait_qnotfull(so, dontblock)) != 0) 452 break; 453 } 454 455 /* 456 * Time to send data to the protocol. We either copy the 457 * data into mblks or pass the uio directly to the protocol. 458 * We decide what to do based on the available down calls. 459 */ 460 if (so->so_downcalls->sd_send_uio != NULL) { 461 error = (*so->so_downcalls->sd_send_uio) 462 (so->so_proto_handle, uiop, msg, cr); 463 if (error != 0) 464 break; 465 } else { 466 /* save the resid in case of failure */ 467 orig_resid = uiop->uio_resid; 468 469 if ((mp = socopyinuio(uiop, 470 so->so_proto_props.sopp_maxpsz, 471 so->so_proto_props.sopp_wroff, 472 so->so_proto_props.sopp_maxblk, 473 so->so_proto_props.sopp_tail, &error, 474 cr)) == NULL) { 475 break; 476 } 477 ASSERT(uiop->uio_resid >= 0); 478 479 error = (*so->so_downcalls->sd_send) 480 (so->so_proto_handle, mp, msg, cr); 481 if (error != 0) { 482 /* 483 * The send failed. We do not have to free the 484 * mblks, because that is the protocol's 485 * responsibility. However, uio_resid must 486 * remain accurate, so adjust that here. 487 */ 488 uiop->uio_resid = orig_resid; 489 break; 490 } 491 } 492 } while (uiop->uio_resid > 0); 493 494 SO_UNBLOCK_FALLBACK(so); 495 496 return (error); 497 } 498 499 int 500 so_sendmblk(struct sonode *so, struct nmsghdr *msg, int fflag, 501 struct cred *cr, mblk_t **mpp) 502 { 503 int error; 504 boolean_t dontblock; 505 size_t size; 506 mblk_t *mp = *mpp; 507 508 SO_BLOCK_FALLBACK(so, SOP_SENDMBLK(so, msg, fflag, cr, mpp)); 509 510 error = 0; 511 dontblock = (msg->msg_flags & MSG_DONTWAIT) || 512 (fflag & (FNONBLOCK|FNDELAY)); 513 size = msgdsize(mp); 514 515 if ((so->so_mode & SM_SENDFILESUPP) == 0 || 516 so->so_downcalls->sd_send == NULL) { 517 SO_UNBLOCK_FALLBACK(so); 518 return (EOPNOTSUPP); 519 } 520 521 if ((so->so_mode & SM_ATOMIC) && 522 size > so->so_proto_props.sopp_maxpsz && 523 so->so_proto_props.sopp_maxpsz != -1) { 524 SO_UNBLOCK_FALLBACK(so); 525 return (EMSGSIZE); 526 } 527 528 while (mp != NULL) { 529 mblk_t *nmp, *last_mblk; 530 size_t mlen; 531 532 if (so->so_state & SS_CANTSENDMORE) { 533 error = EPIPE; 534 break; 535 } 536 if (so->so_error != 0) { 537 mutex_enter(&so->so_lock); 538 error = sogeterr(so, B_TRUE); 539 mutex_exit(&so->so_lock); 540 if (error != 0) 541 break; 542 } 543 if (so->so_snd_qfull) { 544 /* 545 * Need to wait until the protocol is ready to receive 546 * more data for transmission. 547 */ 548 if ((error = so_snd_wait_qnotfull(so, dontblock)) != 0) 549 break; 550 } 551 552 /* 553 * We only allow so_maxpsz of data to be sent down to 554 * the protocol at time. 555 */ 556 mlen = MBLKL(mp); 557 nmp = mp->b_cont; 558 last_mblk = mp; 559 while (nmp != NULL) { 560 mlen += MBLKL(nmp); 561 if (mlen > so->so_proto_props.sopp_maxpsz) { 562 last_mblk->b_cont = NULL; 563 break; 564 } 565 last_mblk = nmp; 566 nmp = nmp->b_cont; 567 } 568 569 error = (*so->so_downcalls->sd_send) 570 (so->so_proto_handle, mp, msg, cr); 571 if (error != 0) { 572 /* 573 * The send failed. The protocol will free the mblks 574 * that were sent down. Let the caller deal with the 575 * rest. 576 */ 577 *mpp = nmp; 578 break; 579 } 580 581 *mpp = mp = nmp; 582 } 583 584 SO_UNBLOCK_FALLBACK(so); 585 586 return (error); 587 } 588 589 int 590 so_shutdown(struct sonode *so, int how, struct cred *cr) 591 { 592 int error; 593 594 SO_BLOCK_FALLBACK(so, SOP_SHUTDOWN(so, how, cr)); 595 596 /* 597 * SunOS 4.X has no check for datagram sockets. 598 * 5.X checks that it is connected (ENOTCONN) 599 * X/Open requires that we check the connected state. 600 */ 601 if (!(so->so_state & SS_ISCONNECTED)) { 602 if (!xnet_skip_checks) { 603 error = ENOTCONN; 604 if (xnet_check_print) { 605 printf("sockfs: X/Open shutdown check " 606 "caused ENOTCONN\n"); 607 } 608 } 609 goto done; 610 } 611 612 error = ((*so->so_downcalls->sd_shutdown)(so->so_proto_handle, 613 how, cr)); 614 615 /* 616 * Protocol agreed to shutdown. We need to flush the 617 * receive buffer if the receive side is being shutdown. 618 */ 619 if (error == 0 && how != SHUT_WR) { 620 mutex_enter(&so->so_lock); 621 /* wait for active reader to finish */ 622 (void) so_lock_read(so, 0); 623 624 so_rcv_flush(so); 625 626 so_unlock_read(so); 627 mutex_exit(&so->so_lock); 628 } 629 630 done: 631 SO_UNBLOCK_FALLBACK(so); 632 return (error); 633 } 634 635 int 636 so_getsockname(struct sonode *so, struct sockaddr *addr, 637 socklen_t *addrlen, struct cred *cr) 638 { 639 int error; 640 641 SO_BLOCK_FALLBACK(so, SOP_GETSOCKNAME(so, addr, addrlen, cr)); 642 643 error = (*so->so_downcalls->sd_getsockname) 644 (so->so_proto_handle, addr, addrlen, cr); 645 646 SO_UNBLOCK_FALLBACK(so); 647 return (error); 648 } 649 650 int 651 so_getpeername(struct sonode *so, struct sockaddr *addr, 652 socklen_t *addrlen, boolean_t accept, struct cred *cr) 653 { 654 int error; 655 656 SO_BLOCK_FALLBACK(so, SOP_GETPEERNAME(so, addr, addrlen, accept, cr)); 657 658 if (accept) { 659 error = (*so->so_downcalls->sd_getpeername) 660 (so->so_proto_handle, addr, addrlen, cr); 661 } else if (!(so->so_state & SS_ISCONNECTED)) { 662 error = ENOTCONN; 663 } else if ((so->so_state & SS_CANTSENDMORE) && !xnet_skip_checks) { 664 /* Added this check for X/Open */ 665 error = EINVAL; 666 if (xnet_check_print) { 667 printf("sockfs: X/Open getpeername check => EINVAL\n"); 668 } 669 } else { 670 error = (*so->so_downcalls->sd_getpeername) 671 (so->so_proto_handle, addr, addrlen, cr); 672 } 673 674 SO_UNBLOCK_FALLBACK(so); 675 return (error); 676 } 677 678 int 679 so_getsockopt(struct sonode *so, int level, int option_name, 680 void *optval, socklen_t *optlenp, int flags, struct cred *cr) 681 { 682 int error = 0; 683 684 ASSERT(MUTEX_NOT_HELD(&so->so_lock)); 685 SO_BLOCK_FALLBACK(so, 686 SOP_GETSOCKOPT(so, level, option_name, optval, optlenp, flags, cr)); 687 688 error = socket_getopt_common(so, level, option_name, optval, optlenp, 689 flags); 690 if (error < 0) { 691 error = (*so->so_downcalls->sd_getsockopt) 692 (so->so_proto_handle, level, option_name, optval, optlenp, 693 cr); 694 if (error == ENOPROTOOPT) { 695 if (level == SOL_SOCKET) { 696 /* 697 * If a protocol does not support a particular 698 * socket option, set can fail (not allowed) 699 * but get can not fail. This is the previous 700 * sockfs bahvior. 701 */ 702 switch (option_name) { 703 case SO_LINGER: 704 if (*optlenp < (t_uscalar_t) 705 sizeof (struct linger)) { 706 error = EINVAL; 707 break; 708 } 709 error = 0; 710 bzero(optval, sizeof (struct linger)); 711 *optlenp = sizeof (struct linger); 712 break; 713 case SO_RCVTIMEO: 714 case SO_SNDTIMEO: 715 if (*optlenp < (t_uscalar_t) 716 sizeof (struct timeval)) { 717 error = EINVAL; 718 break; 719 } 720 error = 0; 721 bzero(optval, sizeof (struct timeval)); 722 *optlenp = sizeof (struct timeval); 723 break; 724 case SO_SND_BUFINFO: 725 if (*optlenp < (t_uscalar_t) 726 sizeof (struct so_snd_bufinfo)) { 727 error = EINVAL; 728 break; 729 } 730 error = 0; 731 bzero(optval, 732 sizeof (struct so_snd_bufinfo)); 733 *optlenp = 734 sizeof (struct so_snd_bufinfo); 735 break; 736 case SO_DEBUG: 737 case SO_REUSEADDR: 738 case SO_KEEPALIVE: 739 case SO_DONTROUTE: 740 case SO_BROADCAST: 741 case SO_USELOOPBACK: 742 case SO_OOBINLINE: 743 case SO_DGRAM_ERRIND: 744 case SO_SNDBUF: 745 case SO_RCVBUF: 746 error = 0; 747 *((int32_t *)optval) = 0; 748 *optlenp = sizeof (int32_t); 749 break; 750 default: 751 break; 752 } 753 } 754 } 755 } 756 757 SO_UNBLOCK_FALLBACK(so); 758 return (error); 759 } 760 761 int 762 so_setsockopt(struct sonode *so, int level, int option_name, 763 const void *optval, socklen_t optlen, struct cred *cr) 764 { 765 int error = 0; 766 struct timeval tl; 767 const void *opt = optval; 768 769 SO_BLOCK_FALLBACK(so, 770 SOP_SETSOCKOPT(so, level, option_name, optval, optlen, cr)); 771 772 /* X/Open requires this check */ 773 if (so->so_state & SS_CANTSENDMORE && !xnet_skip_checks) { 774 SO_UNBLOCK_FALLBACK(so); 775 if (xnet_check_print) 776 printf("sockfs: X/Open setsockopt check => EINVAL\n"); 777 return (EINVAL); 778 } 779 780 if (level == SOL_SOCKET) { 781 switch (option_name) { 782 case SO_RCVTIMEO: 783 case SO_SNDTIMEO: { 784 /* 785 * We pass down these two options to protocol in order 786 * to support some third part protocols which need to 787 * know them. For those protocols which don't care 788 * these two options, simply return 0. 789 */ 790 clock_t t_usec; 791 792 if (get_udatamodel() == DATAMODEL_NONE || 793 get_udatamodel() == DATAMODEL_NATIVE) { 794 if (optlen != sizeof (struct timeval)) { 795 error = EINVAL; 796 goto done; 797 } 798 bcopy((struct timeval *)optval, &tl, 799 sizeof (struct timeval)); 800 } else { 801 if (optlen != sizeof (struct timeval32)) { 802 error = EINVAL; 803 goto done; 804 } 805 TIMEVAL32_TO_TIMEVAL(&tl, 806 (struct timeval32 *)optval); 807 } 808 opt = &tl; 809 optlen = sizeof (tl); 810 t_usec = tl.tv_sec * 1000 * 1000 + tl.tv_usec; 811 mutex_enter(&so->so_lock); 812 if (option_name == SO_RCVTIMEO) 813 so->so_rcvtimeo = drv_usectohz(t_usec); 814 else 815 so->so_sndtimeo = drv_usectohz(t_usec); 816 mutex_exit(&so->so_lock); 817 break; 818 } 819 case SO_RCVBUF: 820 /* 821 * XXX XPG 4.2 applications retrieve SO_RCVBUF from 822 * sockfs since the transport might adjust the value 823 * and not return exactly what was set by the 824 * application. 825 */ 826 so->so_xpg_rcvbuf = *(int32_t *)optval; 827 break; 828 } 829 } 830 error = (*so->so_downcalls->sd_setsockopt) 831 (so->so_proto_handle, level, option_name, opt, optlen, cr); 832 done: 833 SO_UNBLOCK_FALLBACK(so); 834 return (error); 835 } 836 837 int 838 so_ioctl(struct sonode *so, int cmd, intptr_t arg, int mode, 839 struct cred *cr, int32_t *rvalp) 840 { 841 int error = 0; 842 843 SO_BLOCK_FALLBACK(so, SOP_IOCTL(so, cmd, arg, mode, cr, rvalp)); 844 845 /* 846 * If there is a pending error, return error 847 * This can happen if a non blocking operation caused an error. 848 */ 849 if (so->so_error != 0) { 850 mutex_enter(&so->so_lock); 851 error = sogeterr(so, B_TRUE); 852 mutex_exit(&so->so_lock); 853 if (error != 0) 854 goto done; 855 } 856 857 /* 858 * calling strioc can result in the socket falling back to TPI, 859 * if that is supported. 860 */ 861 if ((error = socket_ioctl_common(so, cmd, arg, mode, cr, rvalp)) < 0 && 862 (error = socket_strioc_common(so, cmd, arg, mode, cr, rvalp)) < 0) { 863 error = (*so->so_downcalls->sd_ioctl)(so->so_proto_handle, 864 cmd, arg, mode, rvalp, cr); 865 } 866 867 done: 868 SO_UNBLOCK_FALLBACK(so); 869 870 return (error); 871 } 872 873 int 874 so_poll(struct sonode *so, short events, int anyyet, short *reventsp, 875 struct pollhead **phpp) 876 { 877 int state = so->so_state; 878 *reventsp = 0; 879 880 /* 881 * In sockets the errors are represented as input/output events 882 */ 883 if (so->so_error != 0 && 884 ((POLLIN|POLLRDNORM|POLLOUT) & events) != 0) { 885 *reventsp = (POLLIN|POLLRDNORM|POLLOUT) & events; 886 return (0); 887 } 888 889 /* 890 * If the socket is in a state where it can send data 891 * turn on POLLWRBAND and POLLOUT events. 892 */ 893 if ((so->so_mode & SM_CONNREQUIRED) == 0 || (state & SS_ISCONNECTED)) { 894 /* 895 * out of band data is allowed even if the connection 896 * is flow controlled 897 */ 898 *reventsp |= POLLWRBAND & events; 899 if (!so->so_snd_qfull) { 900 /* 901 * As long as there is buffer to send data 902 * turn on POLLOUT events 903 */ 904 *reventsp |= POLLOUT & events; 905 } 906 } 907 908 /* 909 * Turn on POLLIN whenever there is data on the receive queue, 910 * or the socket is in a state where no more data will be received. 911 * Also, if the socket is accepting connections, flip the bit if 912 * there is something on the queue. 913 * 914 * We do an initial check for events without holding locks. However, 915 * if there are no event available, then we redo the check for POLLIN 916 * events under the lock. 917 */ 918 919 /* Pending connections */ 920 if (so->so_acceptq_len > 0) 921 *reventsp |= (POLLIN|POLLRDNORM) & events; 922 923 /* Data */ 924 /* so_downcalls is null for sctp */ 925 if (so->so_downcalls != NULL && so->so_downcalls->sd_poll != NULL) { 926 *reventsp |= (*so->so_downcalls->sd_poll) 927 (so->so_proto_handle, events & SO_PROTO_POLLEV, anyyet, 928 CRED()) & events; 929 ASSERT((*reventsp & ~events) == 0); 930 /* do not recheck events */ 931 events &= ~SO_PROTO_POLLEV; 932 } else { 933 if (SO_HAVE_DATA(so)) 934 *reventsp |= (POLLIN|POLLRDNORM) & events; 935 936 /* Urgent data */ 937 if ((state & SS_OOBPEND) != 0) { 938 *reventsp |= (POLLRDBAND | POLLPRI) & events; 939 } 940 } 941 942 if (!*reventsp && !anyyet) { 943 /* Check for read events again, but this time under lock */ 944 if (events & (POLLIN|POLLRDNORM)) { 945 mutex_enter(&so->so_lock); 946 if (SO_HAVE_DATA(so) || so->so_acceptq_len > 0) { 947 mutex_exit(&so->so_lock); 948 *reventsp |= (POLLIN|POLLRDNORM) & events; 949 return (0); 950 } else { 951 so->so_pollev |= SO_POLLEV_IN; 952 mutex_exit(&so->so_lock); 953 } 954 } 955 *phpp = &so->so_poll_list; 956 } 957 return (0); 958 } 959 960 /* 961 * Generic Upcalls 962 */ 963 void 964 so_connected(sock_upper_handle_t sock_handle, sock_connid_t id, 965 cred_t *peer_cred, pid_t peer_cpid) 966 { 967 struct sonode *so = (struct sonode *)sock_handle; 968 969 mutex_enter(&so->so_lock); 970 ASSERT(so->so_proto_handle != NULL); 971 972 if (peer_cred != NULL) { 973 if (so->so_peercred != NULL) 974 crfree(so->so_peercred); 975 crhold(peer_cred); 976 so->so_peercred = peer_cred; 977 so->so_cpid = peer_cpid; 978 } 979 980 so->so_proto_connid = id; 981 soisconnected(so); 982 /* 983 * Wake ones who're waiting for conn to become established. 984 */ 985 so_notify_connected(so); 986 } 987 988 int 989 so_disconnected(sock_upper_handle_t sock_handle, sock_connid_t id, int error) 990 { 991 struct sonode *so = (struct sonode *)sock_handle; 992 993 mutex_enter(&so->so_lock); 994 995 so->so_proto_connid = id; 996 soisdisconnected(so, error); 997 so_notify_disconnected(so, error); 998 999 return (0); 1000 } 1001 1002 void 1003 so_opctl(sock_upper_handle_t sock_handle, sock_opctl_action_t action, 1004 uintptr_t arg) 1005 { 1006 struct sonode *so = (struct sonode *)sock_handle; 1007 1008 switch (action) { 1009 case SOCK_OPCTL_SHUT_SEND: 1010 mutex_enter(&so->so_lock); 1011 socantsendmore(so); 1012 so_notify_disconnecting(so); 1013 break; 1014 case SOCK_OPCTL_SHUT_RECV: { 1015 mutex_enter(&so->so_lock); 1016 socantrcvmore(so); 1017 so_notify_eof(so); 1018 break; 1019 } 1020 case SOCK_OPCTL_ENAB_ACCEPT: 1021 mutex_enter(&so->so_lock); 1022 so->so_state |= SS_ACCEPTCONN; 1023 so->so_backlog = (unsigned int)arg; 1024 mutex_exit(&so->so_lock); 1025 break; 1026 default: 1027 ASSERT(0); 1028 break; 1029 } 1030 } 1031 1032 void 1033 so_txq_full(sock_upper_handle_t sock_handle, boolean_t qfull) 1034 { 1035 struct sonode *so = (struct sonode *)sock_handle; 1036 1037 if (qfull) { 1038 so_snd_qfull(so); 1039 } else { 1040 so_snd_qnotfull(so); 1041 mutex_enter(&so->so_lock); 1042 so_notify_writable(so); 1043 } 1044 } 1045 1046 sock_upper_handle_t 1047 so_newconn(sock_upper_handle_t parenthandle, 1048 sock_lower_handle_t proto_handle, sock_downcalls_t *sock_downcalls, 1049 struct cred *peer_cred, pid_t peer_cpid, sock_upcalls_t **sock_upcallsp) 1050 { 1051 struct sonode *so = (struct sonode *)parenthandle; 1052 struct sonode *nso; 1053 int error; 1054 1055 ASSERT(proto_handle != NULL); 1056 1057 if ((so->so_state & SS_ACCEPTCONN) == 0 || 1058 so->so_acceptq_len >= so->so_backlog) 1059 return (NULL); 1060 1061 nso = socket_newconn(so, proto_handle, sock_downcalls, SOCKET_NOSLEEP, 1062 &error); 1063 if (nso == NULL) 1064 return (NULL); 1065 1066 if (peer_cred != NULL) { 1067 crhold(peer_cred); 1068 nso->so_peercred = peer_cred; 1069 nso->so_cpid = peer_cpid; 1070 } 1071 1072 /* 1073 * The new socket (nso), proto_handle and sock_upcallsp are all 1074 * valid at this point. But as soon as nso is placed in the accept 1075 * queue that can no longer be assumed (since an accept() thread may 1076 * pull it off the queue and close the socket). 1077 */ 1078 *sock_upcallsp = &so_upcalls; 1079 1080 (void) so_acceptq_enqueue(so, nso); 1081 1082 mutex_enter(&so->so_lock); 1083 so_notify_newconn(so); 1084 1085 return ((sock_upper_handle_t)nso); 1086 } 1087 1088 void 1089 so_set_prop(sock_upper_handle_t sock_handle, struct sock_proto_props *soppp) 1090 { 1091 struct sonode *so; 1092 1093 so = (struct sonode *)sock_handle; 1094 1095 mutex_enter(&so->so_lock); 1096 1097 if (soppp->sopp_flags & SOCKOPT_MAXBLK) 1098 so->so_proto_props.sopp_maxblk = soppp->sopp_maxblk; 1099 if (soppp->sopp_flags & SOCKOPT_WROFF) 1100 so->so_proto_props.sopp_wroff = soppp->sopp_wroff; 1101 if (soppp->sopp_flags & SOCKOPT_TAIL) 1102 so->so_proto_props.sopp_tail = soppp->sopp_tail; 1103 if (soppp->sopp_flags & SOCKOPT_RCVHIWAT) 1104 so->so_proto_props.sopp_rxhiwat = soppp->sopp_rxhiwat; 1105 if (soppp->sopp_flags & SOCKOPT_RCVLOWAT) 1106 so->so_proto_props.sopp_rxlowat = soppp->sopp_rxlowat; 1107 if (soppp->sopp_flags & SOCKOPT_MAXPSZ) 1108 so->so_proto_props.sopp_maxpsz = soppp->sopp_maxpsz; 1109 if (soppp->sopp_flags & SOCKOPT_MINPSZ) 1110 so->so_proto_props.sopp_minpsz = soppp->sopp_minpsz; 1111 if (soppp->sopp_flags & SOCKOPT_ZCOPY) { 1112 if (soppp->sopp_zcopyflag & ZCVMSAFE) { 1113 so->so_proto_props.sopp_zcopyflag |= STZCVMSAFE; 1114 so->so_proto_props.sopp_zcopyflag &= ~STZCVMUNSAFE; 1115 } else if (soppp->sopp_zcopyflag & ZCVMUNSAFE) { 1116 so->so_proto_props.sopp_zcopyflag |= STZCVMUNSAFE; 1117 so->so_proto_props.sopp_zcopyflag &= ~STZCVMSAFE; 1118 } 1119 1120 if (soppp->sopp_zcopyflag & COPYCACHED) { 1121 so->so_proto_props.sopp_zcopyflag |= STRCOPYCACHED; 1122 } 1123 } 1124 if (soppp->sopp_flags & SOCKOPT_OOBINLINE) 1125 so->so_proto_props.sopp_oobinline = soppp->sopp_oobinline; 1126 if (soppp->sopp_flags & SOCKOPT_RCVTIMER) 1127 so->so_proto_props.sopp_rcvtimer = soppp->sopp_rcvtimer; 1128 if (soppp->sopp_flags & SOCKOPT_RCVTHRESH) 1129 so->so_proto_props.sopp_rcvthresh = soppp->sopp_rcvthresh; 1130 if (soppp->sopp_flags & SOCKOPT_MAXADDRLEN) 1131 so->so_proto_props.sopp_maxaddrlen = soppp->sopp_maxaddrlen; 1132 1133 mutex_exit(&so->so_lock); 1134 1135 #ifdef DEBUG 1136 soppp->sopp_flags &= ~(SOCKOPT_MAXBLK | SOCKOPT_WROFF | SOCKOPT_TAIL | 1137 SOCKOPT_RCVHIWAT | SOCKOPT_RCVLOWAT | SOCKOPT_MAXPSZ | 1138 SOCKOPT_ZCOPY | SOCKOPT_OOBINLINE | SOCKOPT_RCVTIMER | 1139 SOCKOPT_RCVTHRESH | SOCKOPT_MAXADDRLEN | SOCKOPT_MINPSZ); 1140 ASSERT(soppp->sopp_flags == 0); 1141 #endif 1142 } 1143 1144 /* ARGSUSED */ 1145 ssize_t 1146 so_queue_msg(sock_upper_handle_t sock_handle, mblk_t *mp, 1147 size_t msg_size, int flags, int *errorp, boolean_t *force_pushp) 1148 { 1149 struct sonode *so = (struct sonode *)sock_handle; 1150 boolean_t force_push = B_TRUE; 1151 int space_left; 1152 sodirect_t *sodp = so->so_direct; 1153 1154 ASSERT(errorp != NULL); 1155 *errorp = 0; 1156 if (mp == NULL) { 1157 if (msg_size > 0) { 1158 ASSERT(so->so_downcalls->sd_recv_uio != NULL); 1159 mutex_enter(&so->so_lock); 1160 /* the notify functions will drop the lock */ 1161 if (flags & MSG_OOB) 1162 so_notify_oobdata(so, IS_SO_OOB_INLINE(so)); 1163 else 1164 so_notify_data(so, msg_size); 1165 return (0); 1166 } 1167 /* 1168 * recv space check 1169 */ 1170 mutex_enter(&so->so_lock); 1171 space_left = so->so_rcvbuf - so->so_rcv_queued; 1172 if (space_left <= 0) { 1173 so->so_flowctrld = B_TRUE; 1174 *errorp = ENOSPC; 1175 space_left = -1; 1176 } 1177 goto done_unlock; 1178 } 1179 1180 ASSERT(mp->b_next == NULL); 1181 ASSERT(DB_TYPE(mp) == M_DATA || DB_TYPE(mp) == M_PROTO); 1182 ASSERT(msg_size == msgdsize(mp)); 1183 1184 if (flags & MSG_OOB) { 1185 so_queue_oob(sock_handle, mp, msg_size); 1186 return (0); 1187 } 1188 1189 if (force_pushp != NULL) 1190 force_push = *force_pushp; 1191 1192 if (DB_TYPE(mp) == M_PROTO && !__TPI_PRIM_ISALIGNED(mp->b_rptr)) { 1193 /* The read pointer is not aligned correctly for TPI */ 1194 zcmn_err(getzoneid(), CE_WARN, 1195 "sockfs: Unaligned TPI message received. rptr = %p\n", 1196 (void *)mp->b_rptr); 1197 freemsg(mp); 1198 mutex_enter(sodp->sod_lockp); 1199 SOD_UIOAFINI(sodp); 1200 mutex_exit(sodp->sod_lockp); 1201 1202 return (so->so_rcvbuf - so->so_rcv_queued); 1203 } 1204 1205 mutex_enter(&so->so_lock); 1206 if (so->so_state & (SS_FALLBACK_PENDING | SS_FALLBACK_COMP)) { 1207 SOD_DISABLE(sodp); 1208 mutex_exit(&so->so_lock); 1209 *errorp = EOPNOTSUPP; 1210 return (-1); 1211 } 1212 if (so->so_state & SS_CANTRCVMORE) { 1213 freemsg(mp); 1214 SOD_DISABLE(sodp); 1215 mutex_exit(&so->so_lock); 1216 return (0); 1217 } 1218 1219 /* process the mblk via I/OAT if capable */ 1220 if (sodp != NULL && (sodp->sod_state & SOD_ENABLED)) { 1221 if (DB_TYPE(mp) == M_DATA) { 1222 (void) sod_uioa_mblk_init(sodp, mp, msg_size); 1223 } else { 1224 SOD_UIOAFINI(sodp); 1225 } 1226 } 1227 1228 if (mp->b_next == NULL) { 1229 so_enqueue_msg(so, mp, msg_size); 1230 } else { 1231 do { 1232 mblk_t *nmp; 1233 1234 if ((nmp = mp->b_next) != NULL) { 1235 mp->b_next = NULL; 1236 } 1237 so_enqueue_msg(so, mp, msgdsize(mp)); 1238 mp = nmp; 1239 } while (mp != NULL); 1240 } 1241 1242 space_left = so->so_rcvbuf - so->so_rcv_queued; 1243 if (space_left <= 0) { 1244 so->so_flowctrld = B_TRUE; 1245 *errorp = ENOSPC; 1246 space_left = -1; 1247 } 1248 1249 if (force_push || so->so_rcv_queued >= so->so_rcv_thresh || 1250 so->so_rcv_queued >= so->so_rcv_wanted || 1251 (sodp != NULL && so->so_rcv_queued >= sodp->sod_want)) { 1252 SOCKET_TIMER_CANCEL(so); 1253 /* 1254 * so_notify_data will release the lock 1255 */ 1256 so_notify_data(so, so->so_rcv_queued); 1257 1258 if (force_pushp != NULL) 1259 *force_pushp = B_TRUE; 1260 goto done; 1261 } else if (so->so_rcv_timer_tid == 0) { 1262 /* Make sure the recv push timer is running */ 1263 SOCKET_TIMER_START(so); 1264 } 1265 1266 done_unlock: 1267 mutex_exit(&so->so_lock); 1268 done: 1269 return (space_left); 1270 } 1271 1272 /* 1273 * Set the offset of where the oob data is relative to the bytes in 1274 * queued. Also generate SIGURG 1275 */ 1276 void 1277 so_signal_oob(sock_upper_handle_t sock_handle, ssize_t offset) 1278 { 1279 struct sonode *so; 1280 1281 ASSERT(offset >= 0); 1282 so = (struct sonode *)sock_handle; 1283 mutex_enter(&so->so_lock); 1284 SOD_UIOAFINI(so->so_direct); 1285 1286 /* 1287 * New urgent data on the way so forget about any old 1288 * urgent data. 1289 */ 1290 so->so_state &= ~(SS_HAVEOOBDATA|SS_HADOOBDATA); 1291 1292 /* 1293 * Record that urgent data is pending. 1294 */ 1295 so->so_state |= SS_OOBPEND; 1296 1297 if (so->so_oobmsg != NULL) { 1298 dprintso(so, 1, ("sock: discarding old oob\n")); 1299 freemsg(so->so_oobmsg); 1300 so->so_oobmsg = NULL; 1301 } 1302 1303 /* 1304 * set the offset where the urgent byte is 1305 */ 1306 so->so_oobmark = so->so_rcv_queued + offset; 1307 if (so->so_oobmark == 0) 1308 so->so_state |= SS_RCVATMARK; 1309 else 1310 so->so_state &= ~SS_RCVATMARK; 1311 1312 so_notify_oobsig(so); 1313 } 1314 1315 /* 1316 * Queue the OOB byte 1317 */ 1318 static void 1319 so_queue_oob(sock_upper_handle_t sock_handle, mblk_t *mp, size_t len) 1320 { 1321 struct sonode *so; 1322 1323 so = (struct sonode *)sock_handle; 1324 mutex_enter(&so->so_lock); 1325 SOD_UIOAFINI(so->so_direct); 1326 1327 ASSERT(mp != NULL); 1328 if (!IS_SO_OOB_INLINE(so)) { 1329 so->so_oobmsg = mp; 1330 so->so_state |= SS_HAVEOOBDATA; 1331 } else { 1332 so_enqueue_msg(so, mp, len); 1333 } 1334 1335 so_notify_oobdata(so, IS_SO_OOB_INLINE(so)); 1336 } 1337 1338 int 1339 so_close(struct sonode *so, int flag, struct cred *cr) 1340 { 1341 int error; 1342 1343 error = (*so->so_downcalls->sd_close)(so->so_proto_handle, flag, cr); 1344 1345 /* 1346 * At this point there will be no more upcalls from the protocol 1347 */ 1348 mutex_enter(&so->so_lock); 1349 1350 ASSERT(so_verify_oobstate(so)); 1351 1352 so_rcv_flush(so); 1353 mutex_exit(&so->so_lock); 1354 1355 return (error); 1356 } 1357 1358 void 1359 so_zcopy_notify(sock_upper_handle_t sock_handle) 1360 { 1361 struct sonode *so = (struct sonode *)sock_handle; 1362 1363 mutex_enter(&so->so_lock); 1364 so->so_copyflag |= STZCNOTIFY; 1365 cv_broadcast(&so->so_copy_cv); 1366 mutex_exit(&so->so_lock); 1367 } 1368 1369 void 1370 so_set_error(sock_upper_handle_t sock_handle, int error) 1371 { 1372 struct sonode *so = (struct sonode *)sock_handle; 1373 1374 mutex_enter(&so->so_lock); 1375 1376 soseterror(so, error); 1377 1378 so_notify_error(so); 1379 } 1380 1381 /* 1382 * so_recvmsg - read data from the socket 1383 * 1384 * There are two ways of obtaining data; either we ask the protocol to 1385 * copy directly into the supplied buffer, or we copy data from the 1386 * sonode's receive queue. The decision which one to use depends on 1387 * whether the protocol has a sd_recv_uio down call. 1388 */ 1389 int 1390 so_recvmsg(struct sonode *so, struct nmsghdr *msg, struct uio *uiop, 1391 struct cred *cr) 1392 { 1393 rval_t rval; 1394 int flags = 0; 1395 t_uscalar_t controllen, namelen; 1396 int error = 0; 1397 int ret; 1398 mblk_t *mctlp = NULL; 1399 union T_primitives *tpr; 1400 void *control; 1401 ssize_t saved_resid; 1402 struct uio *suiop; 1403 1404 SO_BLOCK_FALLBACK(so, SOP_RECVMSG(so, msg, uiop, cr)); 1405 1406 if ((so->so_state & (SS_ISCONNECTED|SS_CANTRCVMORE)) == 0 && 1407 (so->so_mode & SM_CONNREQUIRED)) { 1408 SO_UNBLOCK_FALLBACK(so); 1409 return (ENOTCONN); 1410 } 1411 1412 if (msg->msg_flags & MSG_PEEK) 1413 msg->msg_flags &= ~MSG_WAITALL; 1414 1415 if (so->so_mode & SM_ATOMIC) 1416 msg->msg_flags |= MSG_TRUNC; 1417 1418 if (msg->msg_flags & MSG_OOB) { 1419 if ((so->so_mode & SM_EXDATA) == 0) { 1420 error = EOPNOTSUPP; 1421 } else if (so->so_downcalls->sd_recv_uio != NULL) { 1422 error = (*so->so_downcalls->sd_recv_uio) 1423 (so->so_proto_handle, uiop, msg, cr); 1424 } else { 1425 error = sorecvoob(so, msg, uiop, msg->msg_flags, 1426 IS_SO_OOB_INLINE(so)); 1427 } 1428 SO_UNBLOCK_FALLBACK(so); 1429 return (error); 1430 } 1431 1432 /* 1433 * If the protocol has the recv down call, then pass the request 1434 * down. 1435 */ 1436 if (so->so_downcalls->sd_recv_uio != NULL) { 1437 error = (*so->so_downcalls->sd_recv_uio) 1438 (so->so_proto_handle, uiop, msg, cr); 1439 SO_UNBLOCK_FALLBACK(so); 1440 return (error); 1441 } 1442 1443 /* 1444 * Reading data from the socket buffer 1445 */ 1446 flags = msg->msg_flags; 1447 msg->msg_flags = 0; 1448 1449 /* 1450 * Set msg_controllen and msg_namelen to zero here to make it 1451 * simpler in the cases that no control or name is returned. 1452 */ 1453 controllen = msg->msg_controllen; 1454 namelen = msg->msg_namelen; 1455 msg->msg_controllen = 0; 1456 msg->msg_namelen = 0; 1457 1458 mutex_enter(&so->so_lock); 1459 /* Set SOREADLOCKED */ 1460 error = so_lock_read_intr(so, 1461 uiop->uio_fmode | ((flags & MSG_DONTWAIT) ? FNONBLOCK : 0)); 1462 mutex_exit(&so->so_lock); 1463 if (error) { 1464 SO_UNBLOCK_FALLBACK(so); 1465 return (error); 1466 } 1467 1468 suiop = sod_rcv_init(so, flags, &uiop); 1469 retry: 1470 saved_resid = uiop->uio_resid; 1471 error = so_dequeue_msg(so, &mctlp, uiop, &rval, flags); 1472 if (error != 0) { 1473 goto out; 1474 } 1475 /* 1476 * For datagrams the MOREDATA flag is used to set MSG_TRUNC. 1477 * For non-datagrams MOREDATA is used to set MSG_EOR. 1478 */ 1479 ASSERT(!(rval.r_val1 & MORECTL)); 1480 if ((rval.r_val1 & MOREDATA) && (so->so_mode & SM_ATOMIC)) 1481 msg->msg_flags |= MSG_TRUNC; 1482 if (mctlp == NULL) { 1483 dprintso(so, 1, ("so_recvmsg: got M_DATA\n")); 1484 1485 mutex_enter(&so->so_lock); 1486 /* Set MSG_EOR based on MOREDATA */ 1487 if (!(rval.r_val1 & MOREDATA)) { 1488 if (so->so_state & SS_SAVEDEOR) { 1489 msg->msg_flags |= MSG_EOR; 1490 so->so_state &= ~SS_SAVEDEOR; 1491 } 1492 } 1493 /* 1494 * If some data was received (i.e. not EOF) and the 1495 * read/recv* has not been satisfied wait for some more. 1496 */ 1497 if ((flags & MSG_WAITALL) && !(msg->msg_flags & MSG_EOR) && 1498 uiop->uio_resid != saved_resid && uiop->uio_resid > 0) { 1499 mutex_exit(&so->so_lock); 1500 goto retry; 1501 } 1502 1503 goto out_locked; 1504 } 1505 /* strsock_proto has already verified length and alignment */ 1506 tpr = (union T_primitives *)mctlp->b_rptr; 1507 dprintso(so, 1, ("so_recvmsg: type %d\n", tpr->type)); 1508 switch (tpr->type) { 1509 case T_DATA_IND: { 1510 /* 1511 * Set msg_flags to MSG_EOR based on 1512 * MORE_flag and MOREDATA. 1513 */ 1514 mutex_enter(&so->so_lock); 1515 so->so_state &= ~SS_SAVEDEOR; 1516 if (!(tpr->data_ind.MORE_flag & 1)) { 1517 if (!(rval.r_val1 & MOREDATA)) 1518 msg->msg_flags |= MSG_EOR; 1519 else 1520 so->so_state |= SS_SAVEDEOR; 1521 } 1522 freemsg(mctlp); 1523 /* 1524 * If some data was received (i.e. not EOF) and the 1525 * read/recv* has not been satisfied wait for some more. 1526 */ 1527 if ((flags & MSG_WAITALL) && !(msg->msg_flags & MSG_EOR) && 1528 uiop->uio_resid != saved_resid && uiop->uio_resid > 0) { 1529 mutex_exit(&so->so_lock); 1530 goto retry; 1531 } 1532 goto out_locked; 1533 } 1534 case T_UNITDATA_IND: { 1535 void *addr; 1536 t_uscalar_t addrlen; 1537 void *abuf; 1538 t_uscalar_t optlen; 1539 void *opt; 1540 1541 if (namelen != 0) { 1542 /* Caller wants source address */ 1543 addrlen = tpr->unitdata_ind.SRC_length; 1544 addr = sogetoff(mctlp, tpr->unitdata_ind.SRC_offset, 1545 addrlen, 1); 1546 if (addr == NULL) { 1547 freemsg(mctlp); 1548 error = EPROTO; 1549 eprintsoline(so, error); 1550 goto out; 1551 } 1552 ASSERT(so->so_family != AF_UNIX); 1553 } 1554 optlen = tpr->unitdata_ind.OPT_length; 1555 if (optlen != 0) { 1556 t_uscalar_t ncontrollen; 1557 1558 /* 1559 * Extract any source address option. 1560 * Determine how large cmsg buffer is needed. 1561 */ 1562 opt = sogetoff(mctlp, tpr->unitdata_ind.OPT_offset, 1563 optlen, __TPI_ALIGN_SIZE); 1564 1565 if (opt == NULL) { 1566 freemsg(mctlp); 1567 error = EPROTO; 1568 eprintsoline(so, error); 1569 goto out; 1570 } 1571 if (so->so_family == AF_UNIX) 1572 so_getopt_srcaddr(opt, optlen, &addr, &addrlen); 1573 ncontrollen = so_cmsglen(mctlp, opt, optlen, 1574 !(flags & MSG_XPG4_2)); 1575 if (controllen != 0) 1576 controllen = ncontrollen; 1577 else if (ncontrollen != 0) 1578 msg->msg_flags |= MSG_CTRUNC; 1579 } else { 1580 controllen = 0; 1581 } 1582 1583 if (namelen != 0) { 1584 /* 1585 * Return address to caller. 1586 * Caller handles truncation if length 1587 * exceeds msg_namelen. 1588 * NOTE: AF_UNIX NUL termination is ensured by 1589 * the sender's copyin_name(). 1590 */ 1591 abuf = kmem_alloc(addrlen, KM_SLEEP); 1592 1593 bcopy(addr, abuf, addrlen); 1594 msg->msg_name = abuf; 1595 msg->msg_namelen = addrlen; 1596 } 1597 1598 if (controllen != 0) { 1599 /* 1600 * Return control msg to caller. 1601 * Caller handles truncation if length 1602 * exceeds msg_controllen. 1603 */ 1604 control = kmem_zalloc(controllen, KM_SLEEP); 1605 1606 error = so_opt2cmsg(mctlp, opt, optlen, 1607 !(flags & MSG_XPG4_2), control, controllen); 1608 if (error) { 1609 freemsg(mctlp); 1610 if (msg->msg_namelen != 0) 1611 kmem_free(msg->msg_name, 1612 msg->msg_namelen); 1613 kmem_free(control, controllen); 1614 eprintsoline(so, error); 1615 goto out; 1616 } 1617 msg->msg_control = control; 1618 msg->msg_controllen = controllen; 1619 } 1620 1621 freemsg(mctlp); 1622 goto out; 1623 } 1624 case T_OPTDATA_IND: { 1625 struct T_optdata_req *tdr; 1626 void *opt; 1627 t_uscalar_t optlen; 1628 1629 tdr = (struct T_optdata_req *)mctlp->b_rptr; 1630 optlen = tdr->OPT_length; 1631 if (optlen != 0) { 1632 t_uscalar_t ncontrollen; 1633 /* 1634 * Determine how large cmsg buffer is needed. 1635 */ 1636 opt = sogetoff(mctlp, 1637 tpr->optdata_ind.OPT_offset, optlen, 1638 __TPI_ALIGN_SIZE); 1639 1640 if (opt == NULL) { 1641 freemsg(mctlp); 1642 error = EPROTO; 1643 eprintsoline(so, error); 1644 goto out; 1645 } 1646 1647 ncontrollen = so_cmsglen(mctlp, opt, optlen, 1648 !(flags & MSG_XPG4_2)); 1649 if (controllen != 0) 1650 controllen = ncontrollen; 1651 else if (ncontrollen != 0) 1652 msg->msg_flags |= MSG_CTRUNC; 1653 } else { 1654 controllen = 0; 1655 } 1656 1657 if (controllen != 0) { 1658 /* 1659 * Return control msg to caller. 1660 * Caller handles truncation if length 1661 * exceeds msg_controllen. 1662 */ 1663 control = kmem_zalloc(controllen, KM_SLEEP); 1664 1665 error = so_opt2cmsg(mctlp, opt, optlen, 1666 !(flags & MSG_XPG4_2), control, controllen); 1667 if (error) { 1668 freemsg(mctlp); 1669 kmem_free(control, controllen); 1670 eprintsoline(so, error); 1671 goto out; 1672 } 1673 msg->msg_control = control; 1674 msg->msg_controllen = controllen; 1675 } 1676 1677 /* 1678 * Set msg_flags to MSG_EOR based on 1679 * DATA_flag and MOREDATA. 1680 */ 1681 mutex_enter(&so->so_lock); 1682 so->so_state &= ~SS_SAVEDEOR; 1683 if (!(tpr->data_ind.MORE_flag & 1)) { 1684 if (!(rval.r_val1 & MOREDATA)) 1685 msg->msg_flags |= MSG_EOR; 1686 else 1687 so->so_state |= SS_SAVEDEOR; 1688 } 1689 freemsg(mctlp); 1690 /* 1691 * If some data was received (i.e. not EOF) and the 1692 * read/recv* has not been satisfied wait for some more. 1693 * Not possible to wait if control info was received. 1694 */ 1695 if ((flags & MSG_WAITALL) && !(msg->msg_flags & MSG_EOR) && 1696 controllen == 0 && 1697 uiop->uio_resid != saved_resid && uiop->uio_resid > 0) { 1698 mutex_exit(&so->so_lock); 1699 goto retry; 1700 } 1701 goto out_locked; 1702 } 1703 default: 1704 cmn_err(CE_CONT, "so_recvmsg bad type %x \n", 1705 tpr->type); 1706 freemsg(mctlp); 1707 error = EPROTO; 1708 ASSERT(0); 1709 } 1710 out: 1711 mutex_enter(&so->so_lock); 1712 out_locked: 1713 /* The sod_lockp pointers to the sonode so_lock */ 1714 ret = sod_rcv_done(so, suiop, uiop); 1715 if (ret != 0 && error == 0) 1716 error = ret; 1717 1718 so_unlock_read(so); /* Clear SOREADLOCKED */ 1719 mutex_exit(&so->so_lock); 1720 1721 SO_UNBLOCK_FALLBACK(so); 1722 1723 return (error); 1724 } 1725 1726 sonodeops_t so_sonodeops = { 1727 so_init, /* sop_init */ 1728 so_accept, /* sop_accept */ 1729 so_bind, /* sop_bind */ 1730 so_listen, /* sop_listen */ 1731 so_connect, /* sop_connect */ 1732 so_recvmsg, /* sop_recvmsg */ 1733 so_sendmsg, /* sop_sendmsg */ 1734 so_sendmblk, /* sop_sendmblk */ 1735 so_getpeername, /* sop_getpeername */ 1736 so_getsockname, /* sop_getsockname */ 1737 so_shutdown, /* sop_shutdown */ 1738 so_getsockopt, /* sop_getsockopt */ 1739 so_setsockopt, /* sop_setsockopt */ 1740 so_ioctl, /* sop_ioctl */ 1741 so_poll, /* sop_poll */ 1742 so_close, /* sop_close */ 1743 }; 1744 1745 sock_upcalls_t so_upcalls = { 1746 so_newconn, 1747 so_connected, 1748 so_disconnected, 1749 so_opctl, 1750 so_queue_msg, 1751 so_set_prop, 1752 so_txq_full, 1753 so_signal_oob, 1754 so_zcopy_notify, 1755 so_set_error 1756 }; 1757