Lines Matching defs:so
279 struct sonode *so;
287 * The request is for an NCA socket so for NL7C use the
306 so = kmem_cache_alloc(cp, KM_SLEEP);
307 if (so == NULL) {
312 sonode_init(so, sp, family, type, protocol, &sotpi_sonodeops);
313 sotpi_info_init(so);
316 SOTOTPI(so)->sti_nl7c_flags = NL7C_AF_NCA;
322 so->so_version = (short)version;
325 return (so);
329 sotpi_destroy(struct sonode *so)
339 ASSERT(so->so_ops == &sotpi_sonodeops);
341 origsp = SOTOTPI(so)->sti_orig_sp;
343 sotpi_info_fini(so);
345 if (so->so_state & SS_FALLBACK_COMP) {
352 sotpi_info_destroy(so);
355 origsp->sp_smod_info->smod_sock_destroy_func(so);
358 sonode_fini(so);
359 cp = (so->so_family == AF_UNIX) ? socktpi_unix_cache :
361 kmem_cache_free(cp, so);
367 sotpi_init(struct sonode *so, struct sonode *tso, struct cred *cr, int flags)
375 sotpi_info_t *sti = SOTOTPI(so);
389 so->so_flag |= SOCLONE;
391 if ((so->so_type == SOCK_STREAM || so->so_type == SOCK_DGRAM) &&
392 (so->so_family == AF_INET || so->so_family == AF_INET6) &&
393 (so->so_protocol == IPPROTO_TCP || so->so_protocol == IPPROTO_UDP ||
394 so->so_protocol == IPPROTO_IP)) {
405 ASSERT(so->so_type != SOCK_DGRAM || tso == NULL);
406 if (so->so_type == SOCK_STREAM && tso != NULL) {
430 if (so->so_family == AF_UNIX) {
434 vp = SOTOV(so);
443 if (so->so_flag & SOCLONE)
445 mutex_enter(&so->so_lock);
448 mutex_exit(&so->so_lock);
455 (void) sotpi_close(so, flags, cr);
481 ASSERT(so->so_family == AF_INET ||
482 so->so_family == AF_INET6);
483 ASSERT(so->so_protocol == IPPROTO_UDP ||
484 so->so_protocol == IPPROTO_TCP ||
485 so->so_protocol == IPPROTO_IP);
486 ASSERT(so->so_type == SOCK_DGRAM ||
487 so->so_type == SOCK_STREAM);
515 (void) sotpi_close(so, flags,
530 if (error = so_strinit(so, tso)) {
531 (void) sotpi_close(so, flags, cr);
536 if (so->so_protocol != so->so_sockparams->sp_protocol) {
537 int protocol = so->so_protocol;
541 error = sotpi_setsockopt(so, SOL_SOCKET, SO_PROTOTYPE,
544 (void) sotpi_close(so, flags, cr);
567 (void) sotpi_close(so, flags, cr);
574 "sockfs open:maj %d vp %p so %p error %d",
575 maj, vp, so, error);
585 so_automatic_bind(struct sonode *so)
587 sotpi_info_t *sti = SOTOTPI(so);
588 ASSERT(so->so_family == AF_INET || so->so_family == AF_INET6);
590 ASSERT(MUTEX_HELD(&so->so_lock));
591 ASSERT(!(so->so_state & SS_ISBOUND));
596 sti->sti_laddr_sa->sa_family = so->so_family;
597 so->so_state |= SS_ISBOUND;
625 sotpi_bindlisten(struct sonode *so, struct sockaddr *name,
641 sotpi_info_t *sti = SOTOTPI(so);
643 dprintso(so, 1, ("sotpi_bindlisten(%p, %p, %d, %d, 0x%x) %s\n",
644 (void *)so, (void *)name, namelen, backlog, flags,
645 pr_state(so->so_state, so->so_mode)));
647 tcp_udp_xport = so->so_type == SOCK_STREAM || so->so_type == SOCK_DGRAM;
650 mutex_enter(&so->so_lock);
651 so_lock_single(so); /* Set SOLOCKED */
653 ASSERT(MUTEX_HELD(&so->so_lock));
654 ASSERT(so->so_flag & SOLOCKED);
663 dprintso(so, 1, ("sobind: allocating unbind_req\n"));
677 if (so->so_family == AF_UNIX) {
681 dprintso(so, 1, ("sobind rebind UNIX: addrlen %d, "
697 if (so->so_state & SS_ISBOUND) {
703 switch (so->so_family) {
713 sti->sti_laddr_sa->sa_family = so->so_family;
732 sti->sti_laddr_len = (so->so_family == AF_INET) ?
737 sti->sti_laddr_sa->sa_family = so->so_family;
759 if (so->so_state & SS_ISBOUND) {
776 eprintsoline(so, error);
779 if ((so->so_mode & SM_CONNREQUIRED) &&
780 (so->so_state & SS_CANTREBIND)) {
783 eprintsoline(so, error);
786 error = sotpi_unbind(so, 0);
788 eprintsoline(so, error);
791 ASSERT(!(so->so_state & SS_ISBOUND));
793 so->so_state &=
800 if ((so->so_state & SS_CANTSENDMORE) && !xnet_skip_checks) {
809 switch (so->so_family) {
813 * when copied (copyin_name) in so the minimum
819 eprintsoline(so, error);
827 if (name->sa_family != so->so_family) {
835 eprintsoline(so, error);
839 error = name->sa_family != so->so_family ?
841 eprintsoline(so, error);
845 (name->sa_family != so->so_family)) {
853 eprintsoline(so, error);
866 name->sa_family = so->so_family;
876 eprintsoline(so, error);
880 error = name->sa_family != so->so_family ?
882 eprintsoline(so, error);
885 if (name->sa_family != so->so_family) {
891 eprintsoline(so, error);
924 eprintsoline(so, error);
932 eprintsoline(so, error);
944 switch (so->so_family) {
968 eprintsoline(so, error);
980 eprintsoline(so, error);
997 ASSERT(SOTOV(so)->v_stream);
999 vp->v_stream = SOTOV(so)->v_stream;
1013 dprintso(so, 1, ("sobind UNIX: addrlen %d, addr %p\n",
1018 } /* end switch (so->so_family) */
1028 if ((so->so_state & SS_ACCEPTCONN) == 0)
1030 save_so_backlog = so->so_backlog;
1032 so->so_state |= SS_ACCEPTCONN;
1033 so->so_backlog = backlog;
1040 * NL7C supports the TCP transport only so check AF_INET and AF_INET6
1044 (so->so_family == AF_INET || so->so_family == AF_INET6) &&
1051 if (so->so_zoneid == GLOBAL_ZONEID) {
1056 * Was an AF_NCA bind() so add it to the
1070 (so->so_family == AF_INET || so->so_family == AF_INET6))
1083 mutex_exit(&so->so_lock);
1085 error = kstrputmsg(SOTOV(so), mp, NULL, 0, 0,
1088 eprintsoline(so, error);
1089 mutex_enter(&so->so_lock);
1093 mutex_enter(&so->so_lock);
1094 error = sowaitprim(so, PRIM_type, T_BIND_ACK,
1097 eprintsoline(so, error);
1109 ASSERT(so->so_family == AF_UNIX);
1112 ASSERT(!(so->so_state & SS_ISBOUND) || (flags & _SOBIND_REBIND));
1113 so->so_state |= SS_ISBOUND;
1123 addrlen = (t_uscalar_t)(so->so_family == AF_UNIX ?
1138 eprintsoline(so, error);
1200 eprintsoline(so, error);
1204 switch (so->so_family) {
1242 eprintsoline(so, error);
1253 if (so->so_family == AF_INET) {
1258 eprintsoline(so, error);
1269 eprintsoline(so, error);
1279 eprintsoline(so, error);
1280 eprintso(so,
1296 eprintsoline(so, error);
1319 switch (so->so_family) {
1347 nl7c_listener_addr(nl7c, so);
1356 so->so_state &= ~SS_ACCEPTCONN;
1358 so->so_backlog = save_so_backlog;
1360 if (unbind_on_err && so->so_state & SS_ISBOUND) {
1363 err = sotpi_unbind(so, 0);
1366 eprintsoline(so, error);
1368 ASSERT(!(so->so_state & SS_ISBOUND));
1373 so_unlock_single(so, SOLOCKED);
1374 mutex_exit(&so->so_lock);
1376 ASSERT(MUTEX_HELD(&so->so_lock));
1377 ASSERT(so->so_flag & SOLOCKED);
1384 sotpi_bind(struct sonode *so, struct sockaddr *name, socklen_t namelen,
1388 return (sotpi_bindlisten(so, name, namelen, 0, flags, cr));
1391 return (sotpi_bindlisten(so, name, namelen, 1, flags, cr));
1398 * so that a sobind can pick them up.
1401 sotpi_unbind(struct sonode *so, int flags)
1406 sotpi_info_t *sti = SOTOTPI(so);
1408 dprintso(so, 1, ("sotpi_unbind(%p, 0x%x) %s\n",
1409 (void *)so, flags, pr_state(so->so_state, so->so_mode)));
1411 ASSERT(MUTEX_HELD(&so->so_lock));
1412 ASSERT(so->so_flag & SOLOCKED);
1414 if (!(so->so_state & SS_ISBOUND)) {
1416 eprintsoline(so, error);
1420 mutex_exit(&so->so_lock);
1426 (void) putnextctl1(strvp2wq(SOTOV(so)), M_FLUSH, FLUSHRW);
1431 error = kstrputmsg(SOTOV(so), mp, NULL, 0, 0,
1433 mutex_enter(&so->so_lock);
1435 eprintsoline(so, error);
1439 error = sowaitokack(so, T_UNBIND_REQ);
1441 eprintsoline(so, error);
1463 so->so_state &= ~(SS_ISBOUND|SS_ACCEPTCONN);
1469 ASSERT(MUTEX_HELD(&so->so_lock));
1470 ASSERT(so->so_flag & SOLOCKED);
1482 sotpi_listen(struct sonode *so, int backlog, struct cred *cr)
1485 sotpi_info_t *sti = SOTOTPI(so);
1487 dprintso(so, 1, ("sotpi_listen(%p, %d) %s\n",
1488 (void *)so, backlog, pr_state(so->so_state, so->so_mode)));
1500 if (so->so_state & SS_ACCEPTCONN &&
1501 !((so->so_family == AF_INET || so->so_family == AF_INET6) &&
1506 if (so->so_state & SS_ISCONNECTED)
1509 mutex_enter(&so->so_lock);
1510 so_lock_single(so); /* Set SOLOCKED */
1516 if ((so->so_state & SS_ACCEPTCONN) &&
1517 so->so_backlog == backlog)
1520 if (!(so->so_state & SS_ISBOUND)) {
1524 if (so->so_family == AF_UNIX) {
1528 error = sotpi_bindlisten(so, NULL, 0, backlog,
1537 if (!((so->so_family == AF_INET || so->so_family == AF_INET6) &&
1540 error = sotpi_unbind(so, _SOUNBIND_REBIND);
1544 error = sotpi_bindlisten(so, NULL, 0, backlog,
1547 so->so_state |= SS_ACCEPTCONN;
1548 so->so_backlog = backlog;
1552 ASSERT(so->so_state & SS_ACCEPTCONN);
1554 so_unlock_single(so, SOLOCKED);
1555 mutex_exit(&so->so_lock);
1565 * so there is no point (and potentially incorrect) to unbind.
1568 sodisconnect(struct sonode *so, t_scalar_t seqno, int flags)
1574 dprintso(so, 1, ("sodisconnect(%p, %d, 0x%x) %s\n",
1575 (void *)so, seqno, flags, pr_state(so->so_state, so->so_mode)));
1578 mutex_enter(&so->so_lock);
1579 so_lock_single(so); /* Set SOLOCKED */
1581 ASSERT(MUTEX_HELD(&so->so_lock));
1582 ASSERT(so->so_flag & SOLOCKED);
1585 if (!(so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING|SS_ACCEPTCONN))) {
1587 eprintsoline(so, error);
1591 mutex_exit(&so->so_lock);
1598 if (!(so->so_state & SS_ACCEPTCONN))
1599 (void) putnextctl1(strvp2wq(SOTOV(so)), M_FLUSH, FLUSHW);
1605 error = kstrputmsg(SOTOV(so), mp, NULL, 0, 0,
1607 mutex_enter(&so->so_lock);
1609 eprintsoline(so, error);
1613 error = sowaitokack(so, T_DISCON_REQ);
1615 eprintsoline(so, error);
1624 so->so_state &= ~(SS_ISCONNECTED|SS_ISCONNECTING);
1625 SOTOTPI(so)->sti_laddr_valid = 0;
1626 SOTOTPI(so)->sti_faddr_valid = 0;
1629 so_unlock_single(so, SOLOCKED);
1630 mutex_exit(&so->so_lock);
1633 ASSERT(MUTEX_HELD(&so->so_lock));
1634 ASSERT(so->so_flag & SOLOCKED);
1641 sotpi_accept(struct sonode *so, int fflag, struct cred *cr,
1657 sotpi_info_t *sti = SOTOTPI(so);
1660 dprintso(so, 1, ("sotpi_accept(%p, 0x%x, %p) %s\n",
1661 (void *)so, fflag, (void *)nsop,
1662 pr_state(so->so_state, so->so_mode)));
1671 if ((so->so_state & SS_ACCEPTCONN) == 0)
1674 if ((error = sowaitconnind(so, fflag, &mp)) != 0)
1690 eprintsoline(so, error);
1694 switch (so->so_family) {
1720 (void) strioctl(SOTOV(so), _SIOCSOCKFALLBACK,
1735 eprintsoline(so, error);
1739 if (so->so_family == AF_UNIX) {
1754 nso = socket_newconn(so, NULL, NULL, SOCKET_SLEEP, &error);
1760 * so return EINTR.
1775 nso->so_options |= so->so_options & SO_DEBUG;
1789 eprintsoline(so, error);
1818 * A signal was caught so return EINTR.
1821 eprintsoline(so, error);
1870 * so that any data arriving on the new socket will cause the
1876 nso->so_pgrp = so->so_pgrp;
1877 nso->so_state |= so->so_state & SS_ASYNC;
1894 nso->so_options = so->so_options & (SO_DEBUG|SO_REUSEADDR|SO_KEEPALIVE|
1897 nso->so_sndbuf = so->so_sndbuf;
1898 nso->so_rcvbuf = so->so_rcvbuf;
1900 nso->so_linger = so->so_linger;
1923 mutex_enter(&so->so_lock);
1924 so_lock_single(so);
1925 eprintsoline(so, error);
1933 mutex_enter(&so->so_lock);
1934 so_lock_single(so);
1935 eprintsoline(so, error);
1961 * A NL7C marked listen()er so the new socket
1970 if (so->so_state & (SS_NONBLOCK|SS_NDELAY)) {
2006 mutex_enter(&so->so_lock);
2007 so_lock_single(so);
2008 eprintsoline(so, error);
2064 mutex_enter(&so->so_lock);
2065 so_lock_single(so); /* Set SOLOCKED */
2066 mutex_exit(&so->so_lock);
2068 error = kstrputmsg(SOTOV(so), mp, NULL,
2070 mutex_enter(&so->so_lock);
2072 eprintsoline(so, error);
2075 error = sowaitprim(so, PRIM_type, T_OK_ACK,
2078 eprintsoline(so, error);
2081 mutex_exit(&so->so_lock);
2103 ASSERT(so->so_family == AF_UNIX);
2120 mutex_enter(&so->so_lock);
2121 so_unlock_single(so, SOLOCKED);
2122 mutex_exit(&so->so_lock);
2136 eprintsoline(so, error);
2140 eprintsoline(so, error);
2145 (void) sodisconnect(so, SEQ_number, 0);
2149 eprintsoline(so, error);
2151 (void) sodisconnect(so, SEQ_number, _SODISCONNECT_LOCK_HELD);
2152 so_unlock_single(so, SOLOCKED);
2153 mutex_exit(&so->so_lock);
2159 error = (so->so_type == SOCK_DGRAM || so->so_type == SOCK_RAW)
2162 eprintsoline(so, error);
2173 sotpi_connect(struct sonode *so,
2188 sotpi_info_t *sti = SOTOTPI(so);
2190 dprintso(so, 1, ("sotpi_connect(%p, %p, %d, 0x%x, 0x%x) %s\n",
2191 (void *)so, (void *)name, namelen, fflag, flags,
2192 pr_state(so->so_state, so->so_mode)));
2208 * caught so return EINTR.
2211 eprintsoline(so, error);
2215 mutex_enter(&so->so_lock);
2225 so_lock_single(so); /* Set SOLOCKED */
2229 dprintso(so, 1, ("sotpi_connect: allocating unbind_req\n"));
2242 if (so->so_state & SS_ACCEPTCONN) {
2250 if (!(so->so_state & SS_ISBOUND)) {
2251 if ((so->so_family == AF_INET || so->so_family == AF_INET6) &&
2253 so->so_type == SOCK_STREAM && !soconnect_tpi_tcp) {
2258 so_automatic_bind(so);
2260 error = sotpi_bind(so, NULL, 0,
2265 ASSERT(so->so_state & SS_ISBOUND);
2287 if (so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) {
2289 if (so->so_mode & SM_CONNREQUIRED) {
2291 error = so->so_state & SS_ISCONNECTED ?
2304 if ((so->so_family == AF_INET ||
2305 so->so_family == AF_INET6) &&
2306 (so->so_type == SOCK_DGRAM ||
2307 so->so_type == SOCK_RAW) &&
2311 error = sodisconnect(so, -1,
2314 so->so_state &=
2321 so_unlock_single(so, SOLOCKED);
2322 mutex_exit(&so->so_lock);
2325 (void) sotpi_setsockopt(so, SOL_SOCKET,
2329 mutex_enter(&so->so_lock);
2330 so_lock_single(so); /* Set SOLOCKED */
2334 ASSERT(so->so_state & SS_ISBOUND);
2347 ASSERT(so->so_family == AF_UNIX);
2361 error = so_addr_verify(so, name, namelen);
2379 if (so->so_family == AF_UNIX) {
2397 dprintso(so, 1,
2400 error = so_ux_addr_xlate(so,
2427 if (!(so->so_mode & SM_CONNREQUIRED)) {
2433 so_unlock_single(so, SOLOCKED);
2434 mutex_exit(&so->so_lock);
2437 (void) sotpi_setsockopt(so, SOL_SOCKET, SO_DGRAM_ERRIND,
2440 mutex_enter(&so->so_lock);
2441 so_lock_single(so); /* Set SOLOCKED */
2442 if ((so->so_family != AF_INET && so->so_family != AF_INET6) ||
2443 (so->so_type != SOCK_DGRAM && so->so_type != SOCK_RAW) ||
2445 soisconnected(so);
2453 ASSERT(so->so_family != AF_UNIX);
2461 switch (so->so_family) {
2489 if (so->so_error != 0)
2531 soisconnecting(so);
2532 mutex_exit(&so->so_lock);
2535 audit_sock(T_CONN_REQ, strvp2wq(SOTOV(so)), mp, 0);
2537 error = kstrputmsg(SOTOV(so), mp, NULL, 0, 0,
2540 mutex_enter(&so->so_lock);
2544 if ((error = sowaitokack(so, T_CONN_REQ)) != 0)
2548 so_unlock_single(so, SOLOCKED);
2554 if ((error = sowaitconnected(so, fflag, 0)) != 0) {
2555 so_lock_single(so); /* Set SOLOCKED */
2577 so->so_state &= ~SS_ISCONNECTING;
2581 (so->so_state & SS_ISBOUND)) {
2584 err = sotpi_unbind(so, 0);
2587 eprintsoline(so, err);
2593 so_unlock_single(so, SOLOCKED);
2594 mutex_exit(&so->so_lock);
2597 so_bad: error = sogeterr(so, B_TRUE);
2598 bad: eprintsoline(so, error);
2604 sotpi_shutdown(struct sonode *so, int how, struct cred *cr)
2610 sotpi_info_t *sti = SOTOTPI(so);
2612 dprintso(so, 1, ("sotpi_shutdown(%p, %d) %s\n",
2613 (void *)so, how, pr_state(so->so_state, so->so_mode)));
2615 mutex_enter(&so->so_lock);
2616 so_lock_single(so); /* Set SOLOCKED */
2623 if (!(so->so_state & SS_ISCONNECTED)) {
2640 old_state = so->so_state;
2644 socantrcvmore(so);
2647 socantsendmore(so);
2650 socantsendmore(so);
2651 socantrcvmore(so);
2661 state_change = (so->so_state & (SS_CANTRCVMORE|SS_CANTSENDMORE)) -
2667 dprintso(so, 1,
2669 so->so_state));
2673 mutex_exit(&so->so_lock);
2674 strseteof(SOTOV(so), 1);
2683 mutex_enter(&so->so_lock);
2684 (void) so_lock_read(so, 0); /* Set SOREADLOCKED */
2685 mutex_exit(&so->so_lock);
2688 strflushrq(SOTOV(so), FLUSHALL);
2690 mutex_enter(&so->so_lock);
2691 so_unlock_read(so); /* Clear SOREADLOCKED */
2695 mutex_exit(&so->so_lock);
2696 strsetwerror(SOTOV(so), 0, 0, sogetwrerr);
2697 mutex_enter(&so->so_lock);
2701 mutex_exit(&so->so_lock);
2702 strsetwerror(SOTOV(so), 0, 0, sogetwrerr);
2703 strseteof(SOTOV(so), 1);
2712 mutex_enter(&so->so_lock);
2713 (void) so_lock_read(so, 0); /* Set SOREADLOCKED */
2714 mutex_exit(&so->so_lock);
2717 strflushrq(SOTOV(so), FLUSHALL);
2719 mutex_enter(&so->so_lock);
2720 so_unlock_read(so); /* Clear SOREADLOCKED */
2724 ASSERT(MUTEX_HELD(&so->so_lock));
2737 if ((so->so_state & (SS_CANTRCVMORE|SS_CANTSENDMORE)) ==
2743 if (so->so_family == AF_UNIX && sti->sti_serv_type != T_CLTS)
2744 so_unix_close(so);
2747 error = sodisconnect(so, -1, _SODISCONNECT_LOCK_HELD);
2754 mutex_exit(&so->so_lock);
2762 error = kstrputmsg(SOTOV(so), mp, NULL, 0, 0,
2764 mutex_enter(&so->so_lock);
2766 eprintsoline(so, error);
2772 so_unlock_single(so, SOLOCKED);
2773 mutex_exit(&so->so_lock);
2797 so_unix_close(struct sonode *so)
2802 sotpi_info_t *sti = SOTOTPI(so);
2804 ASSERT(MUTEX_HELD(&so->so_lock));
2806 ASSERT(so->so_family == AF_UNIX);
2808 if ((so->so_state & (SS_ISCONNECTED|SS_ISBOUND)) !=
2812 dprintso(so, 1, ("so_unix_close(%p) %s\n",
2813 (void *)so, pr_state(so->so_state, so->so_mode)));
2822 if (so->so_type == SOCK_STREAM || so->so_type == SOCK_SEQPACKET) {
2853 error = so_addr_verify(so, sti->sti_faddr_sa,
2856 eprintsoline(so, error);
2876 dprintso(so, 1,
2879 error = so_ux_addr_xlate(so,
2884 eprintsoline(so, error);
2931 mutex_exit(&so->so_lock);
2932 error = kstrputmsg(SOTOV(so), mp, NULL, 0, 0,
2934 mutex_enter(&so->so_lock);
2941 * if (so->so_state & (SS_OOBPEND|SS_HAVEOOBDATA|SS_RCVATMARK))
2955 sorecv_update_oobstate(struct sonode *so)
2957 sotpi_info_t *sti = SOTOTPI(so);
2959 mutex_enter(&so->so_lock);
2960 ASSERT(so_verify_oobstate(so));
2961 dprintso(so, 1,
2964 sti->sti_oobcnt, pr_state(so->so_state, so->so_mode)));
2967 so->so_state &= ~(SS_OOBPEND|SS_HAVEOOBDATA|SS_RCVATMARK);
2968 freemsg(so->so_oobmsg);
2969 so->so_oobmsg = NULL;
2971 ASSERT(so_verify_oobstate(so));
2972 mutex_exit(&so->so_lock);
2976 * Handle recv* calls for an so which has NL7C saved recv mblk_t(s).
2979 nl7c_sorecv(struct sonode *so, mblk_t **rmp, uio_t *uiop, rval_t *rp)
2981 sotpi_info_t *sti = SOTOTPI(so);
3029 /* Last mblk_t so return the saved kstrgetmsg() rval/error */
3039 /* More mblk_t(s) to process so no rval to return */
3055 sotpi_recvmsg(struct sonode *so, struct nmsghdr *msg, struct uio *uiop,
3065 int so_state = so->so_state; /* Snapshot */
3071 sotpi_info_t *sti = SOTOTPI(so);
3076 dprintso(so, 1, ("sotpi_recvmsg(%p, %p, 0x%x) state %s err %d\n",
3077 (void *)so, (void *)msg, flags,
3078 pr_state(so->so_state, so->so_mode), so->so_error));
3080 if (so->so_version == SOV_STREAM) {
3081 so_update_attrs(so, SOACC);
3083 return (strread(SOTOV(so), uiop, cr));
3097 (so->so_mode & SM_CONNREQUIRED)) {
3110 if (!(so->so_mode & SM_EXDATA))
3112 so_update_attrs(so, SOACC);
3113 return (sorecvoob(so, msg, uiop, flags,
3114 (so->so_options & SO_OOBINLINE)));
3117 so_update_attrs(so, SOACC);
3128 dprintso(so, 1, ("sotpi_recvmsg: namelen %d controllen %d\n",
3131 mutex_enter(&so->so_lock);
3139 nl7c_close(so);
3144 mutex_exit(&so->so_lock);
3150 ret = nl7c_process(so,
3151 (so->so_state & (SS_NONBLOCK|SS_NDELAY)));
3156 mutex_exit(&so->so_lock);
3165 mutex_exit(&so->so_lock);
3176 * Not persistent so no further NL7C processing.
3199 error = so_lock_read_intr(so,
3201 mutex_exit(&so->so_lock);
3220 if (so->so_mode & SM_ATOMIC)
3225 else if (so->so_rcvtimeo != 0)
3226 timout = TICK_TO_MSEC(so->so_rcvtimeo);
3236 error = nl7c_sorecv(so, &mp, uiop, &rval);
3238 error = kstrgetmsg(SOTOV(so), &mp, uiop, &pri, &pflag,
3252 if ((rval.r_val1 & MOREDATA) && (so->so_mode & SM_ATOMIC))
3256 dprintso(so, 1, ("sotpi_recvmsg: got M_DATA\n"));
3262 if ((so->so_state &
3266 sorecv_update_oobstate(so);
3269 mutex_enter(&so->so_lock);
3272 if (so->so_state & SS_SAVEDEOR) {
3274 so->so_state &= ~SS_SAVEDEOR;
3283 mutex_exit(&so->so_lock);
3292 dprintso(so, 1, ("sotpi_recvmsg: type %d\n", tpr->type));
3296 if ((so->so_state &
3300 sorecv_update_oobstate(so);
3307 mutex_enter(&so->so_lock);
3308 so->so_state &= ~SS_SAVEDEOR;
3313 so->so_state |= SS_SAVEDEOR;
3322 mutex_exit(&so->so_lock);
3335 if ((so->so_state &
3339 sorecv_update_oobstate(so);
3351 eprintsoline(so, error);
3354 if (so->so_family == AF_UNIX) {
3380 eprintsoline(so, error);
3383 if (so->so_family == AF_UNIX)
3427 eprintsoline(so, error);
3442 if ((so->so_state &
3446 sorecv_update_oobstate(so);
3463 eprintsoline(so, error);
3491 eprintsoline(so, error);
3502 mutex_enter(&so->so_lock);
3503 so->so_state &= ~SS_SAVEDEOR;
3508 so->so_state |= SS_SAVEDEOR;
3519 mutex_exit(&so->so_lock);
3526 dprintso(so, 1,
3531 pr_state(so->so_state, so->so_mode)));
3533 * kstrgetmsg handles MSGMARK so there is nothing to
3556 dprintso(so, 1,
3561 pr_state(so->so_state, so->so_mode)));
3564 if (so->so_mode & SM_ATOMIC)
3570 error = kstrgetmsg(SOTOV(so), &mp, uiop,
3577 eprintsoline(so, error);
3597 mutex_enter(&so->so_lock);
3598 ASSERT(so_verify_oobstate(so));
3612 so->so_state |= SS_RCVATMARK;
3613 mutex_exit(&so->so_lock);
3614 dprintso(so, 1,
3617 pr_state(so->so_state, so->so_mode)));
3622 cmn_err(CE_CONT, "sotpi_recvmsg: so %p prim %d mp %p\n",
3623 (void *)so, tpr->type, (void *)mp);
3627 eprintsoline(so, error);
3632 mutex_enter(&so->so_lock);
3634 so_unlock_read(so); /* Clear SOREADLOCKED */
3635 mutex_exit(&so->so_lock);
3644 sosend_dgramcmsg(struct sonode *so, struct sockaddr *name, socklen_t namelen,
3661 sotpi_info_t *sti = SOTOTPI(so);
3681 error = so_addr_verify(so, name, namelen);
3683 eprintsoline(so, error);
3686 if (so->so_family == AF_UNIX) {
3709 dprintso(so, 1,
3712 error = so_ux_addr_xlate(so, name, namelen,
3716 eprintsoline(so, error);
3749 if (!(so->so_mode & SM_FDPASSING))
3803 audit_sock(T_UNITDATA_REQ, strvp2wq(SOTOV(so)), mp, 0);
3805 error = kstrputmsg(SOTOV(so), mp, uiop, len, 0, MSG_BAND, 0);
3808 eprintsoline(so, error);
3819 sosend_svccmsg(struct sonode *so, struct uio *uiop, int more, void *control,
3832 sotpi_info_t *sti = SOTOTPI(so);
3834 dprintso(so, 1,
3844 if (!(so->so_mode & SM_OPTDATA))
3866 dprintso(so, 1, ("sosend_svccmsg: sending %d, %ld bytes\n",
3882 if (!(so->so_mode & SM_FDPASSING))
3919 error = kstrputmsg(SOTOV(so), mp, uiop, iosize,
3922 eprintsoline(so, error);
3932 if (so->so_state & SS_CANTSENDMORE) {
3933 eprintsoline(so, error);
3936 if (so->so_error != 0) {
3937 mutex_enter(&so->so_lock);
3938 error = sogeterr(so, B_TRUE);
3939 mutex_exit(&so->so_lock);
3941 eprintsoline(so, error);
3958 sosend_dgram(struct sonode *so, struct sockaddr *name, socklen_t namelen,
3969 sotpi_info_t *sti = SOTOTPI(so);
3980 error = so_addr_verify(so, name, namelen);
3985 return (sodgram_direct(so, name, namelen, uiop, flags));
3987 if (so->so_family == AF_UNIX) {
4010 dprintso(so, 1,
4013 error = so_ux_addr_xlate(so, name, namelen,
4017 eprintsoline(so, error);
4081 audit_sock(T_UNITDATA_REQ, strvp2wq(SOTOV(so)), mp, 0);
4083 error = kstrputmsg(SOTOV(so), mp, uiop, len, 0, MSG_BAND, 0);
4087 eprintsoline(so, error);
4098 sosend_svc(struct sonode *so, struct uio *uiop, t_scalar_t prim, int more,
4105 sotpi_info_t *sti = SOTOTPI(so);
4107 dprintso(so, 1,
4109 (void *)so, uiop->uio_resid, prim, sflag));
4136 dprintso(so, 1, ("sosend_svc: sending 0x%x %d, %ld bytes\n",
4147 error = kstrputmsg(SOTOV(so), mp, uiop, iosize,
4150 eprintsoline(so, error);
4159 if (so->so_state & SS_CANTSENDMORE) {
4160 eprintsoline(so, error);
4163 if (so->so_error != 0) {
4164 mutex_enter(&so->so_lock);
4165 error = sogeterr(so, B_TRUE);
4166 mutex_exit(&so->so_lock);
4168 eprintsoline(so, error);
4185 sotpi_sendmsg(struct sonode *so, struct nmsghdr *msg, struct uio *uiop,
4195 sotpi_info_t *sti = SOTOTPI(so);
4197 dprintso(so, 1, ("sotpi_sendmsg(%p, %p, 0x%x) state %s, error %d\n",
4198 (void *)so, (void *)msg, msg->msg_flags,
4199 pr_state(so->so_state, so->so_mode), so->so_error));
4201 if (so->so_version == SOV_STREAM) {
4203 so_update_attrs(so, SOMOD);
4204 return (strwrite(SOTOV(so), uiop, cr));
4207 mutex_enter(&so->so_lock);
4208 so_state = so->so_state;
4211 mutex_exit(&so->so_lock);
4215 if (so->so_error != 0) {
4216 error = sogeterr(so, B_TRUE);
4218 mutex_exit(&so->so_lock);
4226 so_mode = so->so_mode;
4230 mutex_exit(&so->so_lock);
4255 mutex_exit(&so->so_lock);
4268 mutex_exit(&so->so_lock);
4272 so_lock_single(so); /* Set SOLOCKED */
4273 error = sotpi_bind(so, NULL, 0,
4275 so_unlock_single(so, SOLOCKED);
4277 mutex_exit(&so->so_lock);
4278 eprintsoline(so, error);
4305 switch (so->so_family) {
4341 mutex_exit(&so->so_lock);
4343 dprintso(so, 0,
4346 pr_addr(so->so_family, name, namelen)));
4354 mutex_exit(&so->so_lock);
4358 if ((flags & MSG_DONTROUTE) && !(so->so_options & SO_DONTROUTE)) {
4362 error = sotpi_setsockopt(so, SOL_SOCKET, SO_DONTROUTE,
4375 so_update_attrs(so, SOMOD);
4376 error = sosend_dgramcmsg(so, name, namelen, uiop,
4384 so_update_attrs(so, SOMOD);
4385 error = sosend_svccmsg(so, uiop,
4393 so_update_attrs(so, SOMOD);
4400 return (sosend_dgram(so, name, namelen, uiop, flags));
4402 error = sosend_dgram(so, name, namelen, uiop, flags);
4418 dprintso(so, 1, ("sotpi_sendmsg: write\n"));
4422 (error = nl7c_data(so, uiop)) >= 0) {
4432 canputnext(SOTOV(so)->v_stream->sd_wrq)) {
4433 return (sostream_direct(so, uiop,
4436 error = strwrite(SOTOV(so), uiop, cr);
4447 return (sosend_svc(so, uiop, prim,
4449 error = sosend_svc(so, uiop, prim,
4458 (void) sotpi_setsockopt(so, SOL_SOCKET, SO_DONTROUTE,
4485 struct sonode *so;
4491 so = VTOSO(vp);
4492 direct = _SOTOTPI(so)->sti_direct;
4496 * not be accurate so we don't grab the sd_lock here. If
4503 return (sostream_direct(so, NULL, mp, CRED()));
4558 sotpi_sendmblk(struct sonode *so, struct nmsghdr *msg, int fflag,
4563 if (so->so_family != AF_INET && so->so_family != AF_INET6)
4566 if (so->so_state & SS_CANTSENDMORE)
4569 if (so->so_type != SOCK_STREAM)
4572 if ((so->so_state & SS_ISCONNECTED) == 0)
4575 error = kstrwritemp(so->so_vnode, *mpp, fflag);
4587 sodgram_direct(struct sonode *so, struct sockaddr *name,
4596 struct stdata *stp = SOTOV(so)->v_stream;
4601 sotpi_info_t *sti = SOTOTPI(so);
4605 ASSERT(!(so->so_mode & SM_CONNREQUIRED));
4606 ASSERT(!(so->so_mode & SM_EXDATA));
4607 ASSERT(so->so_family == AF_INET || so->so_family == AF_INET6);
4608 ASSERT(SOTOV(so)->v_type == VSOCK);
4615 ASSERT(name->sa_family == so->so_family);
4616 ASSERT(so->so_family == AF_INET ||
4618 ASSERT(so->so_family == AF_INET6 ||
4628 so_state = so->so_state;
4668 audit_sock(T_UNITDATA_REQ, strvp2wq(SOTOV(so)), mp, 0);
4685 return (strwrite(SOTOV(so), uiop, CRED()));
4688 audit_sock(T_UNITDATA_REQ, strvp2wq(SOTOV(so)), mp, 0);
4690 error = kstrputmsg(SOTOV(so), mp, uiop, len, 0, MSG_BAND, 0);
4694 eprintsoline(so, error);
4701 sostream_direct(struct sonode *so, struct uio *uiop, mblk_t *mp, cred_t *cr)
4703 struct stdata *stp = SOTOV(so)->v_stream;
4709 ASSERT(so->so_mode & SM_BYTESTREAM);
4710 ASSERT(SOTOV(so)->v_type == VSOCK);
4725 newmp = (stp->sd_wputdatafunc)(SOTOV(so), mp, NULL,
4739 return (strwrite(SOTOV(so), uiop, cr));
4776 newmp = (stp->sd_wputdatafunc)(SOTOV(so), mp, NULL,
4801 * written so far back to the app. This is the
4807 return (strwrite_common(SOTOV(so), uiop, cr, wflag));
4818 sotpi_getpeername(struct sonode *so, struct sockaddr *name, socklen_t *namelen,
4826 sotpi_info_t *sti = SOTOTPI(so);
4828 dprintso(so, 1, ("sotpi_getpeername(%p) %s\n",
4829 (void *)so, pr_state(so->so_state, so->so_mode)));
4832 mutex_enter(&so->so_lock);
4833 so_lock_single(so); /* Set SOLOCKED */
4842 if (!(so->so_state & SS_ISCONNECTED)) {
4847 if ((so->so_state & SS_CANTSENDMORE) && !xnet_skip_checks) {
4863 dprintso(so, 1, ("sotpi_getpeername (local): %s\n",
4864 pr_addr(so->so_family, sti->sti_faddr_sa,
4868 if (so->so_family == AF_UNIX) {
4876 ASSERT(so->so_family != AF_UNIX && sti->sti_faddr_noxlate == 0);
4881 mutex_exit(&so->so_lock);
4886 * Put the result in sti_faddr_sa so that getpeername works after
4898 error = strioctl(SOTOV(so), TI_GETPEERNAME, (intptr_t)&strbuf,
4902 mutex_enter(&so->so_lock);
4929 (so->so_state & SS_ISCONNECTED)) {
4940 dprintso(so, 1, ("sotpi_getpeername (tp): %s\n",
4941 pr_addr(so->so_family, sti->sti_faddr_sa,
4945 so_unlock_single(so, SOLOCKED);
4946 mutex_exit(&so->so_lock);
4954 sotpi_getsockname(struct sonode *so, struct sockaddr *name, socklen_t *namelen,
4962 sotpi_info_t *sti = SOTOTPI(so);
4964 dprintso(so, 1, ("sotpi_getsockname(%p) %s\n",
4965 (void *)so, pr_state(so->so_state, so->so_mode)));
4968 mutex_enter(&so->so_lock);
4969 so_lock_single(so); /* Set SOLOCKED */
4973 dprintso(so, 1, ("sotpi_getsockname (local): %s\n",
4974 pr_addr(so->so_family, sti->sti_laddr_sa,
4984 if (so->so_family == AF_UNIX) {
4998 if (!(so->so_state & SS_ISBOUND)) {
5006 mutex_exit(&so->so_lock);
5011 * Put the result in sti_laddr_sa so that getsockname works after
5023 error = strioctl(SOTOV(so), TI_GETMYNAME, (intptr_t)&strbuf,
5027 mutex_enter(&so->so_lock);
5051 (so->so_state & SS_ISBOUND)) {
5062 dprintso(so, 1, ("sotpi_getsockname (tp): %s\n",
5063 pr_addr(so->so_family, sti->sti_laddr_sa,
5067 so_unlock_single(so, SOLOCKED);
5068 mutex_exit(&so->so_lock);
5081 sotpi_getsockopt(struct sonode *so, int level, int option_name,
5098 dprintso(so, 1, ("sotpi_getsockopt(%p, 0x%x, 0x%x, %p, %p) %s\n",
5099 (void *)so, level, option_name, optval, (void *)optlenp,
5100 pr_state(so->so_state, so->so_mode)));
5102 mutex_enter(&so->so_lock);
5103 so_lock_single(so); /* Set SOLOCKED */
5135 eprintsoline(so, error);
5145 eprintsoline(so, error);
5151 eprintsoline(so, error);
5160 eprintsoline(so, error);
5168 eprintsoline(so, error);
5178 value = so->so_type;
5183 value = sogeterr(so, B_TRUE);
5188 if (so->so_state & SS_ACCEPTCONN)
5194 dprintso(so, 1,
5198 dprintso(so, 1,
5215 value = (so->so_options & option_name);
5218 dprintso(so, 1,
5222 dprintso(so, 1,
5235 option = &so->so_linger;
5247 lvalue = so->so_sndbuf;
5249 mutex_exit(&so->so_lock);
5250 (void) strqget(strvp2wq(SOTOV(so))->q_next,
5252 mutex_enter(&so->so_lock);
5253 dprintso(so, 1,
5258 len = (t_uscalar_t)sizeof (so->so_sndbuf);
5277 lvalue = so->so_rcvbuf;
5279 mutex_exit(&so->so_lock);
5280 (void) strqget(RD(strvp2wq(SOTOV(so))),
5282 mutex_enter(&so->so_lock);
5283 dprintso(so, 1,
5292 len = (t_uscalar_t)sizeof (so->so_rcvbuf);
5296 value = so->so_family;
5306 value = so->so_sndlowat;
5310 value = so->so_rcvlowat;
5319 val = drv_hztousec(so->so_rcvtimeo);
5321 val = drv_hztousec(so->so_sndtimeo);
5337 (so->so_proto_props).sopp_wroff;
5339 (so->so_proto_props).sopp_maxblk;
5341 (so->so_proto_props).sopp_maxpsz;
5343 (so->so_proto_props).sopp_tail;
5351 mutex_exit(&so->so_lock);
5366 error = kstrputmsg(SOTOV(so), mp, NULL, 0, 0,
5369 mutex_enter(&so->so_lock);
5371 eprintsoline(so, error);
5374 error = sowaitprim(so, T_SVR4_OPTMGMT_REQ, T_OPTMGMT_ACK,
5382 eprintsoline(so, error);
5396 eprintsoline(so, error);
5410 eprintsoline(so, error);
5424 so_unlock_single(so, SOLOCKED);
5425 mutex_exit(&so->so_lock);
5438 sotpi_setsockopt(struct sonode *so, int level, int option_name,
5447 dprintso(so, 1, ("sotpi_setsockopt(%p, 0x%x, 0x%x, %p, %d) %s\n",
5448 (void *)so, level, option_name, optval, optlen,
5449 pr_state(so->so_state, so->so_mode)));
5452 if ((so->so_state & SS_CANTSENDMORE) && !xnet_skip_checks) {
5458 mutex_enter(&so->so_lock);
5459 so_lock_single(so); /* Set SOLOCKED */
5460 mutex_exit(&so->so_lock);
5474 error = kstrputmsg(SOTOV(so), mp, NULL, 0, 0,
5477 mutex_enter(&so->so_lock);
5479 eprintsoline(so, error);
5482 error = sowaitprim(so, T_SVR4_OPTMGMT_REQ, T_OPTMGMT_ACK,
5485 eprintsoline(so, error);
5518 eprintsoline(so, error);
5530 eprintsoline(so, error);
5536 eprintsoline(so, error);
5546 eprintsoline(so, error);
5566 so->so_linger.l_linger = l->l_linger;
5568 so->so_linger.l_onoff = SO_LINGER;
5569 so->so_options |= SO_LINGER;
5571 so->so_linger.l_onoff = 0;
5572 so->so_options &= ~SO_LINGER;
5599 dprintso(so, 1,
5602 so->so_options |= option_name;
5604 dprintso(so, 1,
5607 so->so_options &= ~option_name;
5618 so->so_sndbuf = intvalue;
5621 so->so_rcvbuf = intvalue;
5624 so->so_rcv_timer_interval = intvalue;
5632 so->so_sndlowat = intvalue;
5635 so->so_rcvlowat = intvalue;
5652 so->so_rcvtimeo = drv_usectohz(val);
5654 so->so_sndtimeo = drv_usectohz(val);
5663 dprintso(so, 1,
5671 so_unlock_single(so, SOLOCKED);
5672 mutex_exit(&so->so_lock);
5681 sotpi_close(struct sonode *so, int flag, struct cred *cr)
5683 struct vnode *vp = SOTOV(so);
5686 sotpi_info_t *sti = SOTOTPI(so);
5688 dprintso(so, 1, ("sotpi_close(%p, %x) %s\n",
5689 (void *)vp, flag, pr_state(so->so_state, so->so_mode)));
5695 mutex_enter(&so->so_lock);
5696 so_lock_single(so); /* Set SOLOCKED */
5698 ASSERT(so_verify_oobstate(so));
5702 nl7c_close(so);
5708 if (so->so_family == AF_UNIX) {
5710 so_unix_close(so);
5713 mutex_exit(&so->so_lock);
5727 mutex_enter(&so->so_lock);
5733 so_flush_discon_ind(so);
5735 so_unlock_single(so, SOLOCKED);
5736 mutex_exit(&so->so_lock);
5744 if (so->so_flag & SOCLONE)
5751 sotpi_ioctl(struct sonode *so, int cmd, intptr_t arg, int mode,
5754 struct vnode *vp = SOTOV(so);
5755 sotpi_info_t *sti = SOTOTPI(so);
5758 dprintso(so, 0, ("sotpi_ioctl: cmd 0x%x, arg 0x%lx, state %s\n",
5759 cmd, arg, pr_state(so->so_state, so->so_mode)));
5771 * on sockets, and doing so would increase the complexity
5793 if (so->so_version != SOV_STREAM)
5802 ASSERT(so->so_version != SOV_STREAM);
5815 mutex_enter(&so->so_lock);
5817 so->so_state |= SS_NDELAY;
5819 so->so_state &= ~SS_NDELAY;
5821 mutex_exit(&so->so_lock);
5832 mutex_enter(&so->so_lock);
5835 * (!value != !(so->so_state & SS_ASYNC))
5838 if (value == 0 && (so->so_state & SS_ASYNC) != 0 ||
5839 value != 0 && (so->so_state & SS_ASYNC) == 0)
5840 error = so_flip_async(so, vp, mode, cr);
5841 mutex_exit(&so->so_lock);
5853 mutex_enter(&so->so_lock);
5854 dprintso(so, 1, ("setown: new %d old %d\n", pgrp, so->so_pgrp));
5856 if (pgrp != so->so_pgrp)
5857 error = so_set_siggrp(so, vp, pgrp, mode, cr);
5858 mutex_exit(&so->so_lock);
5863 if (so_copyout(&so->so_pgrp, (void *)arg,
5882 mutex_enter(&so->so_lock);
5883 so_state = so->so_state;
5884 mutex_exit(&so->so_lock);
5899 * STRNOTATMARK flag is used so that the
5946 mutex_enter(&so->so_lock);
5947 if ((so->so_mode & SM_CONNREQUIRED) == 0) {
5949 } else if ((so->so_state & SS_ISCONNECTED) == 0) {
5951 } else if (so->so_peercred != NULL) {
5953 kp->pc_cr = so->so_peercred;
5954 kp->pc_cpid = so->so_cpid;
5955 crhold(so->so_peercred);
5959 mutex_exit(&so->so_lock);
5968 so->so_version == SOV_SOCKBSD) {
5988 struct sonode *so = VTOSO(vp);
5991 sotpi_info_t *sti = SOTOTPI(so);
5995 if (so->so_version == SOV_SOCKBSD)
5998 if (so->so_version == SOV_STREAM) {
6008 dprintso(so, 0, ("socktpi_ioctl: going to "
6010 so_stream2sock(so);
6020 mutex_enter(&so->so_lock);
6021 so_lock_single(so);
6022 mutex_exit(&so->so_lock);
6027 mutex_enter(&so->so_lock);
6030 so_unlock_single(so, SOLOCKED);
6031 mutex_exit(&so->so_lock);
6045 dprintso(so, 0,
6047 return (so_sock2stream(so));
6183 struct sonode *so,
6190 struct vnode *vp = SOTOV(so);
6192 int so_state = so->so_state; /* snapshot */
6193 sotpi_info_t *sti = SOTOTPI(so);
6195 dprintso(so, 0, ("socktpi_poll(%p): state %s err %d\n",
6196 (void *)vp, pr_state(so_state, so->so_mode), so->so_error));
6201 if (so->so_version == SOV_STREAM) {
6208 (so->so_mode & SM_CONNREQUIRED)) {
6217 if (so->so_error != 0 &&
6262 * may have already returned EWOULDBLOCK, so not be waiting to
6279 if (so->so_state & SS_CANTRCVMORE) {
6282 if (so->so_state & SS_CANTSENDMORE)
6286 if (so->so_state & SS_OOBPEND)
6339 struct sonode *so = (struct sonode *)buf;
6340 sotpi_info_t *sti = SOTOTPI(so);
6347 SOTOTPI(sti->sti_next_so)->sti_prev_so = so;
6348 socklist.sl_list = so;
6359 struct sonode *so = (struct sonode *)buf;
6360 sotpi_info_t *sti = SOTOTPI(so);
6380 * Create sonode caches. We create a special one for AF_UNIX so
6400 sotpi_convert_sonode(struct sonode *so, struct sockparams *newsp,
6404 struct sockparams *origsp = so->so_sockparams;
6405 sock_lower_handle_t handle = so->so_proto_handle;
6411 ASSERT((so->so_state & (SS_FALLBACK_PENDING|SS_FALLBACK_COMP)) ==
6413 ASSERT(SOCK_IS_NONSTR(so));
6417 so->so_sockparams = newsp;
6421 (void) sotpi_info_create(so, KM_SLEEP);
6422 sotpi_info_init(so);
6424 if ((error = sotpi_init(so, NULL, cr, SO_FALLBACK)) != 0) {
6425 sotpi_info_fini(so);
6426 sotpi_info_destroy(so);
6429 ASSERT(handle == so->so_proto_handle);
6430 sti = SOTOTPI(so);
6435 * Keep the original sp around so we can properly dispose of the
6440 so_basic_strinit(so); /* skips the T_CAPABILITY_REQ */
6441 so_alloc_addr(so, so->so_max_addr_len);
6453 if (so->so_pgrp != 0) {
6454 if (so_set_events(so, so->so_vnode, cr) != 0)
6455 so->so_pgrp = 0;
6461 vp = SOTOV(so);
6475 so->so_not_str = B_FALSE;
6485 sotpi_revert_sonode(struct sonode *so, struct cred *cr)
6487 vnode_t *vp = SOTOV(so);
6489 ASSERT((so->so_state & (SS_FALLBACK_PENDING|SS_FALLBACK_COMP)) ==
6491 ASSERT(!SOCK_IS_NONSTR(so));
6501 so->so_sockparams = SOTOTPI(so)->sti_orig_sp;
6503 sotpi_info_fini(so);
6504 sotpi_info_destroy(so);
6507 so->so_not_str = B_TRUE;
6511 sotpi_update_state(struct sonode *so, struct T_capability_ack *tcap,
6515 sotpi_info_t *sti = SOTOTPI(so);
6517 so_proc_tcapability_ack(so, tcap);
6519 so->so_options |= opts;
6528 sti->sti_laddr_valid = (so->so_state & SS_ISBOUND);
6535 sti->sti_faddr_valid = (so->so_state & SS_ISCONNECTED);
6544 so_alloc_addr(struct sonode *so, t_uscalar_t maxlen)
6546 sotpi_info_t *sti = SOTOTPI(so);
6552 so->so_max_addr_len = sti->sti_laddr_maxlen;
6557 if (so->so_family == AF_UNIX) {
6568 sotpi_sototpi(struct sonode *so)
6572 ASSERT(so != NULL);
6574 sti = (sotpi_info_t *)so->so_priv;
6634 sotpi_info_create(struct sonode *so, int kmflags)
6638 ASSERT(so->so_priv == NULL);
6648 so->so_priv = (void *)sti;
6656 sotpi_info_init(struct sonode *so)
6658 struct vnode *vp = SOTOV(so);
6659 sotpi_info_t *sti = SOTOTPI(so);
6662 sti->sti_dev = so->so_sockparams->sp_sdev_info.sd_vnode->v_rdev;
6707 sotpi_info_fini(struct sonode *so)
6709 sotpi_info_t *sti = SOTOTPI(so);
6727 * Protect so->so_[lf]addr_sa so that sockfs_snapshot() can safely
6730 mutex_enter(&so->so_lock);
6745 mutex_exit(&so->so_lock);
6764 nl7c_urifree(so);
6782 sotpi_info_destroy(struct sonode *so)
6784 sotpi_info_t *sti = SOTOTPI(so);
6789 so->so_priv = NULL;
6804 * Initialize the smod_refcnt to 1 so it will never be freed.