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 (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Copyright 2015, Joyent, Inc.
25  * Copyright 2017 Sebastian Wiedenroth
26  * Copyright 2022 Garrett D'Amore
27  */
28 
29 #include <sys/types.h>
30 #include <sys/param.h>
31 #include <sys/systm.h>
32 #include <sys/sysmacros.h>
33 #include <sys/debug.h>
34 #include <sys/cmn_err.h>
35 #include <sys/vfs.h>
36 #include <sys/policy.h>
37 #include <sys/modctl.h>
38 
39 #include <sys/sunddi.h>
40 
41 #include <sys/strsun.h>
42 #include <sys/stropts.h>
43 #include <sys/strsubr.h>
44 #include <sys/socket.h>
45 #include <sys/socketvar.h>
46 #include <sys/uio.h>
47 
48 #include <inet/ipclassifier.h>
49 #include <fs/sockfs/sockcommon.h>
50 #include <fs/sockfs/sockfilter_impl.h>
51 #include <fs/sockfs/socktpi.h>
52 #include <fs/sockfs/sodirect.h>
53 #include <inet/ip.h>
54 
55 extern int xnet_skip_checks, xnet_check_print, xnet_truncate_print;
56 
57 /*
58  * Common socket access functions.
59  *
60  * Instead of accessing the sonode switch directly (i.e., SOP_xxx()),
61  * the socket_xxx() function should be used.
62  */
63 
64 /*
65  * Try to create a new sonode of the requested <family, type, protocol>.
66  */
67 /* ARGSUSED */
68 struct sonode *
socket_create(int family,int type,int protocol,char * devpath,char * mod,int flags,int version,struct cred * cr,int * errorp)69 socket_create(int family, int type, int protocol, char *devpath, char *mod,
70     int flags, int version, struct cred *cr, int *errorp)
71 {
72 	struct sonode *so;
73 	struct sockparams *sp = NULL;
74 	int saved_error;
75 
76 	/*
77 	 * Look for a sockparams entry that match the given criteria.
78 	 * solookup() returns with the entry held.
79 	 */
80 	*errorp = solookup(family, type, protocol, &sp);
81 	saved_error = *errorp;
82 	if (sp == NULL) {
83 		int kmflags = (flags == SOCKET_SLEEP) ? KM_SLEEP : KM_NOSLEEP;
84 		/*
85 		 * There is no matching sockparams entry. An ephemeral entry is
86 		 * created if the caller specifies a device or a socket module.
87 		 */
88 		if (devpath != NULL) {
89 			saved_error = 0;
90 			sp = sockparams_hold_ephemeral_bydev(family, type,
91 			    protocol, devpath, kmflags, errorp);
92 		} else if (mod != NULL) {
93 			saved_error = 0;
94 			sp = sockparams_hold_ephemeral_bymod(family, type,
95 			    protocol, mod, kmflags, errorp);
96 		} else {
97 			*errorp = solookup(family, type, 0, &sp);
98 		}
99 
100 		if (sp == NULL) {
101 			if (saved_error && (*errorp == EPROTONOSUPPORT ||
102 			    *errorp == EPROTOTYPE || *errorp == ENOPROTOOPT))
103 				*errorp = saved_error;
104 			return (NULL);
105 		}
106 	}
107 
108 	ASSERT(sp->sp_smod_info != NULL);
109 	ASSERT(flags == SOCKET_SLEEP || flags == SOCKET_NOSLEEP);
110 	sp->sp_stats.sps_ncreate.value.ui64++;
111 	so = sp->sp_smod_info->smod_sock_create_func(sp, family, type,
112 	    protocol, version, flags, errorp, cr);
113 	if (so == NULL) {
114 		SOCKPARAMS_DEC_REF(sp);
115 	} else {
116 		if ((*errorp = SOP_INIT(so, NULL, cr, flags)) == 0) {
117 			/* Cannot fail, only bumps so_count */
118 			(void) VOP_OPEN(&SOTOV(so), FREAD|FWRITE, cr, NULL);
119 		} else {
120 			if (saved_error && (*errorp == EPROTONOSUPPORT ||
121 			    *errorp == EPROTOTYPE || *errorp == ENOPROTOOPT))
122 				*errorp = saved_error;
123 			socket_destroy(so);
124 			so = NULL;
125 		}
126 	}
127 	return (so);
128 }
129 
130 struct sonode *
socket_newconn(struct sonode * parent,sock_lower_handle_t lh,sock_downcalls_t * dc,int flags,int * errorp)131 socket_newconn(struct sonode *parent, sock_lower_handle_t lh,
132     sock_downcalls_t *dc, int flags, int *errorp)
133 {
134 	struct sonode *so;
135 	struct sockparams *sp;
136 	struct cred *cr;
137 
138 	if ((cr = CRED()) == NULL)
139 		cr = kcred;
140 
141 	sp = parent->so_sockparams;
142 	ASSERT(sp != NULL);
143 
144 	sp->sp_stats.sps_ncreate.value.ui64++;
145 	so = sp->sp_smod_info->smod_sock_create_func(sp, parent->so_family,
146 	    parent->so_type, parent->so_protocol, parent->so_version, flags,
147 	    errorp, cr);
148 	if (so != NULL) {
149 		SOCKPARAMS_INC_REF(sp);
150 
151 		so->so_proto_handle = lh;
152 		so->so_downcalls = dc;
153 		/*
154 		 * This function may be called in interrupt context, and CRED()
155 		 * will be NULL. In this case, pass in kcred.
156 		 */
157 		if ((*errorp = SOP_INIT(so, parent, cr, flags)) == 0) {
158 			/* Cannot fail, only bumps so_count */
159 			(void) VOP_OPEN(&SOTOV(so), FREAD|FWRITE, cr, NULL);
160 		} else  {
161 			socket_destroy(so);
162 			so = NULL;
163 		}
164 	}
165 
166 	return (so);
167 }
168 
169 /*
170  * Bind local endpoint.
171  */
172 int
socket_bind(struct sonode * so,struct sockaddr * name,socklen_t namelen,int flags,cred_t * cr)173 socket_bind(struct sonode *so, struct sockaddr *name, socklen_t namelen,
174     int flags, cred_t *cr)
175 {
176 	return (SOP_BIND(so, name, namelen, flags, cr));
177 }
178 
179 /*
180  * Turn socket into a listen socket.
181  */
182 int
socket_listen(struct sonode * so,int backlog,cred_t * cr)183 socket_listen(struct sonode *so, int backlog, cred_t *cr)
184 {
185 	if (backlog < 0) {
186 		backlog = 0;
187 	}
188 
189 	/*
190 	 * Use the same qlimit as in BSD. BSD checks the qlimit
191 	 * before queuing the next connection implying that a
192 	 * listen(sock, 0) allows one connection to be queued.
193 	 * BSD also uses 1.5 times the requested backlog.
194 	 *
195 	 * XNS Issue 4 required a strict interpretation of the backlog.
196 	 * This has been waived subsequently for Issue 4 and the change
197 	 * incorporated in XNS Issue 5. So we aren't required to do
198 	 * anything special for XPG apps.
199 	 */
200 	if (backlog >= (INT_MAX - 1) / 3)
201 		backlog = INT_MAX;
202 	else
203 		backlog = backlog * 3 / 2 + 1;
204 
205 	return (SOP_LISTEN(so, backlog, cr));
206 }
207 
208 /*
209  * Accept incoming connection.
210  */
211 int
socket_accept(struct sonode * lso,int fflag,cred_t * cr,struct sonode ** nsop)212 socket_accept(struct sonode *lso, int fflag, cred_t *cr, struct sonode **nsop)
213 {
214 	return (SOP_ACCEPT(lso, fflag, cr, nsop));
215 }
216 
217 /*
218  * Active open.
219  */
220 int
socket_connect(struct sonode * so,struct sockaddr * name,socklen_t namelen,int fflag,int flags,cred_t * cr)221 socket_connect(struct sonode *so, struct sockaddr *name,
222     socklen_t namelen, int fflag, int flags, cred_t *cr)
223 {
224 	int error;
225 
226 	/*
227 	 * Handle a connect to a name parameter of type AF_UNSPEC like a
228 	 * connect to a null address. This is the portable method to
229 	 * unconnect a socket.
230 	 */
231 	if ((namelen >= sizeof (sa_family_t)) &&
232 	    (name->sa_family == AF_UNSPEC)) {
233 		name = NULL;
234 		namelen = 0;
235 	}
236 
237 	error = SOP_CONNECT(so, name, namelen, fflag, flags, cr);
238 
239 	if (error == EHOSTUNREACH && flags & _SOCONNECT_XPG4_2) {
240 		/*
241 		 * X/Open specification contains a requirement that
242 		 * ENETUNREACH be returned but does not require
243 		 * EHOSTUNREACH. In order to keep the test suite
244 		 * happy we mess with the errno here.
245 		 */
246 		error = ENETUNREACH;
247 	}
248 
249 	return (error);
250 }
251 
252 /*
253  * Get address of remote node.
254  */
255 int
socket_getpeername(struct sonode * so,struct sockaddr * addr,socklen_t * addrlen,boolean_t accept,cred_t * cr)256 socket_getpeername(struct sonode *so, struct sockaddr *addr,
257     socklen_t *addrlen, boolean_t accept, cred_t *cr)
258 {
259 	ASSERT(*addrlen > 0);
260 	return (SOP_GETPEERNAME(so, addr, addrlen, accept, cr));
261 
262 }
263 
264 /*
265  * Get local address.
266  */
267 int
socket_getsockname(struct sonode * so,struct sockaddr * addr,socklen_t * addrlen,cred_t * cr)268 socket_getsockname(struct sonode *so, struct sockaddr *addr,
269     socklen_t *addrlen, cred_t *cr)
270 {
271 	return (SOP_GETSOCKNAME(so, addr, addrlen, cr));
272 
273 }
274 
275 /*
276  * Called from shutdown().
277  */
278 int
socket_shutdown(struct sonode * so,int how,cred_t * cr)279 socket_shutdown(struct sonode *so, int how, cred_t *cr)
280 {
281 	return (SOP_SHUTDOWN(so, how, cr));
282 }
283 
284 /*
285  * Get socket options.
286  */
287 /*ARGSUSED*/
288 int
socket_getsockopt(struct sonode * so,int level,int option_name,void * optval,socklen_t * optlenp,int flags,cred_t * cr)289 socket_getsockopt(struct sonode *so, int level, int option_name,
290     void *optval, socklen_t *optlenp, int flags, cred_t *cr)
291 {
292 	return (SOP_GETSOCKOPT(so, level, option_name, optval,
293 	    optlenp, flags, cr));
294 }
295 
296 /*
297  * Set socket options
298  */
299 int
socket_setsockopt(struct sonode * so,int level,int option_name,const void * optval,t_uscalar_t optlen,cred_t * cr)300 socket_setsockopt(struct sonode *so, int level, int option_name,
301     const void *optval, t_uscalar_t optlen, cred_t *cr)
302 {
303 	int val = 1;
304 	/* Caller allocates aligned optval, or passes null */
305 	ASSERT(((uintptr_t)optval & (sizeof (t_scalar_t) - 1)) == 0);
306 	/* If optval is null optlen is 0, and vice-versa */
307 	ASSERT(optval != NULL || optlen == 0);
308 	ASSERT(optlen != 0 || optval == NULL);
309 
310 	if (optval == NULL && optlen == 0)
311 		optval = &val;
312 
313 	return (SOP_SETSOCKOPT(so, level, option_name, optval, optlen, cr));
314 }
315 
316 int
socket_sendmsg(struct sonode * so,struct nmsghdr * msg,struct uio * uiop,cred_t * cr)317 socket_sendmsg(struct sonode *so, struct nmsghdr *msg, struct uio *uiop,
318     cred_t *cr)
319 {
320 	int error = 0;
321 	ssize_t orig_resid = uiop->uio_resid;
322 
323 	/*
324 	 * Do not bypass the cache if we are doing a local (AF_UNIX) write.
325 	 */
326 	if (so->so_family == AF_UNIX)
327 		uiop->uio_extflg |= UIO_COPY_CACHED;
328 	else
329 		uiop->uio_extflg &= ~UIO_COPY_CACHED;
330 
331 	error = SOP_SENDMSG(so, msg, uiop, cr);
332 	switch (error) {
333 	default:
334 		break;
335 	case EINTR:
336 	case ENOMEM:
337 	/* EAGAIN is EWOULDBLOCK */
338 	case EWOULDBLOCK:
339 		/* We did a partial send */
340 		if (uiop->uio_resid != orig_resid)
341 			error = 0;
342 		break;
343 	case EPIPE:
344 		if (((so->so_mode & SM_KERNEL) == 0) &&
345 		    ((msg->msg_flags & MSG_NOSIGNAL) == 0)) {
346 			tsignal(curthread, SIGPIPE);
347 		}
348 		break;
349 	}
350 
351 	return (error);
352 }
353 
354 int
socket_sendmblk(struct sonode * so,struct nmsghdr * msg,int fflag,struct cred * cr,mblk_t ** mpp)355 socket_sendmblk(struct sonode *so, struct nmsghdr *msg, int fflag,
356     struct cred *cr, mblk_t **mpp)
357 {
358 	int error = 0;
359 
360 	error = SOP_SENDMBLK(so, msg, fflag, cr, mpp);
361 	if (error == EPIPE) {
362 		tsignal(curthread, SIGPIPE);
363 	}
364 	return (error);
365 }
366 
367 int
socket_recvmsg(struct sonode * so,struct nmsghdr * msg,struct uio * uiop,cred_t * cr)368 socket_recvmsg(struct sonode *so, struct nmsghdr *msg, struct uio *uiop,
369     cred_t *cr)
370 {
371 	int error;
372 	ssize_t orig_resid = uiop->uio_resid;
373 
374 	/*
375 	 * Do not bypass the cache when reading data, as the application
376 	 * is likely to access the data shortly.
377 	 */
378 	uiop->uio_extflg |= UIO_COPY_CACHED;
379 
380 	error = SOP_RECVMSG(so, msg, uiop, cr);
381 
382 	switch (error) {
383 	case EINTR:
384 	/* EAGAIN is EWOULDBLOCK */
385 	case EWOULDBLOCK:
386 		/* We did a partial read */
387 		if (uiop->uio_resid != orig_resid)
388 			error = 0;
389 		break;
390 	default:
391 		break;
392 	}
393 	return (error);
394 }
395 
396 int
socket_ioctl(struct sonode * so,int cmd,intptr_t arg,int mode,struct cred * cr,int32_t * rvalp)397 socket_ioctl(struct sonode *so, int cmd, intptr_t arg, int mode,
398     struct cred *cr, int32_t *rvalp)
399 {
400 	return (SOP_IOCTL(so, cmd, arg, mode, cr, rvalp));
401 }
402 
403 int
socket_poll(struct sonode * so,short events,int anyyet,short * reventsp,struct pollhead ** phpp)404 socket_poll(struct sonode *so, short events, int anyyet, short *reventsp,
405     struct pollhead **phpp)
406 {
407 	return (SOP_POLL(so, events, anyyet, reventsp, phpp));
408 }
409 
410 int
socket_close(struct sonode * so,int flag,struct cred * cr)411 socket_close(struct sonode *so, int flag, struct cred *cr)
412 {
413 	return (VOP_CLOSE(SOTOV(so), flag, 1, 0, cr, NULL));
414 }
415 
416 int
socket_close_internal(struct sonode * so,int flag,cred_t * cr)417 socket_close_internal(struct sonode *so, int flag, cred_t *cr)
418 {
419 	ASSERT(so->so_count == 0);
420 
421 	return (SOP_CLOSE(so, flag, cr));
422 }
423 
424 void
socket_destroy(struct sonode * so)425 socket_destroy(struct sonode *so)
426 {
427 	vn_invalid(SOTOV(so));
428 	VN_RELE(SOTOV(so));
429 }
430 
431 /* ARGSUSED */
432 void
socket_destroy_internal(struct sonode * so,cred_t * cr)433 socket_destroy_internal(struct sonode *so, cred_t *cr)
434 {
435 	struct sockparams *sp = so->so_sockparams;
436 	ASSERT(so->so_count == 0 && sp != NULL);
437 
438 	sp->sp_smod_info->smod_sock_destroy_func(so);
439 
440 	SOCKPARAMS_DEC_REF(sp);
441 }
442 
443 /*
444  * TODO Once the common vnode ops is available, then the vnops argument
445  * should be removed.
446  */
447 /*ARGSUSED*/
448 int
sonode_constructor(void * buf,void * cdrarg,int kmflags)449 sonode_constructor(void *buf, void *cdrarg, int kmflags)
450 {
451 	struct sonode *so = buf;
452 	struct vnode *vp;
453 
454 	vp = so->so_vnode = vn_alloc(kmflags);
455 	if (vp == NULL) {
456 		return (-1);
457 	}
458 	vp->v_data = so;
459 	vn_setops(vp, socket_vnodeops);
460 
461 	so->so_priv		= NULL;
462 	so->so_oobmsg		= NULL;
463 
464 	so->so_proto_handle	= NULL;
465 
466 	so->so_peercred		= NULL;
467 
468 	so->so_rcv_queued	= 0;
469 	so->so_rcv_q_head	= NULL;
470 	so->so_rcv_q_last_head	= NULL;
471 	so->so_rcv_head		= NULL;
472 	so->so_rcv_last_head	= NULL;
473 	so->so_rcv_wanted	= 0;
474 	so->so_rcv_timer_interval = SOCKET_NO_RCVTIMER;
475 	so->so_rcv_timer_tid	= 0;
476 	so->so_rcv_thresh	= 0;
477 
478 	list_create(&so->so_acceptq_list, sizeof (struct sonode),
479 	    offsetof(struct sonode, so_acceptq_node));
480 	list_create(&so->so_acceptq_defer, sizeof (struct sonode),
481 	    offsetof(struct sonode, so_acceptq_node));
482 	list_link_init(&so->so_acceptq_node);
483 	so->so_acceptq_len	= 0;
484 	so->so_backlog		= 0;
485 	so->so_listener		= NULL;
486 
487 	so->so_snd_qfull	= B_FALSE;
488 
489 	so->so_filter_active	= 0;
490 	so->so_filter_tx	= 0;
491 	so->so_filter_defertime = 0;
492 	so->so_filter_top	= NULL;
493 	so->so_filter_bottom	= NULL;
494 
495 	mutex_init(&so->so_lock, NULL, MUTEX_DEFAULT, NULL);
496 	mutex_init(&so->so_acceptq_lock, NULL, MUTEX_DEFAULT, NULL);
497 	rw_init(&so->so_fallback_rwlock, NULL, RW_DEFAULT, NULL);
498 	cv_init(&so->so_state_cv, NULL, CV_DEFAULT, NULL);
499 	cv_init(&so->so_single_cv, NULL, CV_DEFAULT, NULL);
500 	cv_init(&so->so_read_cv, NULL, CV_DEFAULT, NULL);
501 
502 	cv_init(&so->so_acceptq_cv, NULL, CV_DEFAULT, NULL);
503 	cv_init(&so->so_snd_cv, NULL, CV_DEFAULT, NULL);
504 	cv_init(&so->so_rcv_cv, NULL, CV_DEFAULT, NULL);
505 	cv_init(&so->so_copy_cv, NULL, CV_DEFAULT, NULL);
506 	cv_init(&so->so_closing_cv, NULL, CV_DEFAULT, NULL);
507 
508 	so->so_krecv_cb = NULL;
509 	so->so_krecv_arg = NULL;
510 
511 	return (0);
512 }
513 
514 /*ARGSUSED*/
515 void
sonode_destructor(void * buf,void * cdrarg)516 sonode_destructor(void *buf, void *cdrarg)
517 {
518 	struct sonode *so = buf;
519 	struct vnode *vp = SOTOV(so);
520 
521 	ASSERT(so->so_priv == NULL);
522 	ASSERT(so->so_peercred == NULL);
523 
524 	ASSERT(so->so_oobmsg == NULL);
525 
526 	ASSERT(so->so_rcv_q_head == NULL);
527 
528 	list_destroy(&so->so_acceptq_list);
529 	list_destroy(&so->so_acceptq_defer);
530 	ASSERT(!list_link_active(&so->so_acceptq_node));
531 	ASSERT(so->so_listener == NULL);
532 
533 	ASSERT(so->so_filter_active == 0);
534 	ASSERT(so->so_filter_tx == 0);
535 	ASSERT(so->so_filter_top == NULL);
536 	ASSERT(so->so_filter_bottom == NULL);
537 
538 	ASSERT(vp->v_data == so);
539 	ASSERT(vn_matchops(vp, socket_vnodeops));
540 
541 	vn_free(vp);
542 
543 	mutex_destroy(&so->so_lock);
544 	mutex_destroy(&so->so_acceptq_lock);
545 	rw_destroy(&so->so_fallback_rwlock);
546 
547 	cv_destroy(&so->so_state_cv);
548 	cv_destroy(&so->so_single_cv);
549 	cv_destroy(&so->so_read_cv);
550 	cv_destroy(&so->so_acceptq_cv);
551 	cv_destroy(&so->so_snd_cv);
552 	cv_destroy(&so->so_rcv_cv);
553 	cv_destroy(&so->so_closing_cv);
554 }
555 
556 void
sonode_init(struct sonode * so,struct sockparams * sp,int family,int type,int protocol,sonodeops_t * sops)557 sonode_init(struct sonode *so, struct sockparams *sp, int family,
558     int type, int protocol, sonodeops_t *sops)
559 {
560 	vnode_t *vp;
561 
562 	vp = SOTOV(so);
563 
564 	so->so_flag	= 0;
565 
566 	so->so_state	= 0;
567 	so->so_mode	= 0;
568 
569 	so->so_count	= 0;
570 
571 	so->so_family	= family;
572 	so->so_type	= type;
573 	so->so_protocol	= protocol;
574 
575 	SOCK_CONNID_INIT(so->so_proto_connid);
576 
577 	so->so_options	= 0;
578 	so->so_linger.l_onoff   = 0;
579 	so->so_linger.l_linger = 0;
580 	so->so_sndbuf	= 0;
581 	so->so_error	= 0;
582 	so->so_rcvtimeo	= 0;
583 	so->so_sndtimeo = 0;
584 	so->so_xpg_rcvbuf = 0;
585 
586 	ASSERT(so->so_oobmsg == NULL);
587 	so->so_oobmark	= 0;
588 	so->so_pgrp	= 0;
589 
590 	ASSERT(so->so_peercred == NULL);
591 
592 	so->so_zoneid = getzoneid();
593 
594 	so->so_sockparams = sp;
595 
596 	so->so_ops = sops;
597 
598 	so->so_not_str = (sops != &sotpi_sonodeops);
599 
600 	so->so_proto_handle = NULL;
601 
602 	so->so_downcalls = NULL;
603 
604 	so->so_copyflag = 0;
605 
606 	vn_reinit(vp);
607 	vp->v_vfsp	= rootvfs;
608 	vp->v_type	= VSOCK;
609 	vp->v_rdev	= sockdev;
610 
611 	so->so_snd_qfull = B_FALSE;
612 	so->so_minpsz = 0;
613 
614 	so->so_rcv_wakeup = B_FALSE;
615 	so->so_snd_wakeup = B_FALSE;
616 	so->so_flowctrld = B_FALSE;
617 
618 	so->so_pollev = 0;
619 	bzero(&so->so_poll_list, sizeof (so->so_poll_list));
620 	bzero(&so->so_proto_props, sizeof (struct sock_proto_props));
621 
622 	bzero(&(so->so_ksock_callbacks), sizeof (ksocket_callbacks_t));
623 	so->so_ksock_cb_arg = NULL;
624 
625 	so->so_max_addr_len = sizeof (struct sockaddr_storage);
626 
627 	so->so_direct = NULL;
628 
629 	vn_exists(vp);
630 }
631 
632 void
sonode_fini(struct sonode * so)633 sonode_fini(struct sonode *so)
634 {
635 	vnode_t *vp;
636 
637 	ASSERT(so->so_count == 0);
638 
639 	if (so->so_rcv_timer_tid) {
640 		ASSERT(MUTEX_NOT_HELD(&so->so_lock));
641 		(void) untimeout(so->so_rcv_timer_tid);
642 		so->so_rcv_timer_tid = 0;
643 	}
644 
645 	if (so->so_poll_list.ph_list != NULL) {
646 		pollwakeup(&so->so_poll_list, POLLERR);
647 		pollhead_clean(&so->so_poll_list);
648 	}
649 
650 	if (so->so_direct != NULL)
651 		sod_sock_fini(so);
652 
653 	vp = SOTOV(so);
654 	vn_invalid(vp);
655 
656 	if (so->so_peercred != NULL) {
657 		crfree(so->so_peercred);
658 		so->so_peercred = NULL;
659 	}
660 	/* Detach and destroy filters */
661 	if (so->so_filter_top != NULL)
662 		sof_sonode_cleanup(so);
663 
664 	/* Clean up any remnants of krecv callbacks */
665 	so->so_krecv_cb = NULL;
666 	so->so_krecv_arg = NULL;
667 
668 	ASSERT(list_is_empty(&so->so_acceptq_list));
669 	ASSERT(list_is_empty(&so->so_acceptq_defer));
670 	ASSERT(!list_link_active(&so->so_acceptq_node));
671 
672 	ASSERT(so->so_rcv_queued == 0);
673 	ASSERT(so->so_rcv_q_head == NULL);
674 	ASSERT(so->so_rcv_q_last_head == NULL);
675 	ASSERT(so->so_rcv_head == NULL);
676 	ASSERT(so->so_rcv_last_head == NULL);
677 }
678