1 | /* |
2 | * Copyright (c) 2003-2017 Apple Inc. All rights reserved. |
3 | * |
4 | * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ |
5 | * |
6 | * This file contains Original Code and/or Modifications of Original Code |
7 | * as defined in and that are subject to the Apple Public Source License |
8 | * Version 2.0 (the 'License'). You may not use this file except in |
9 | * compliance with the License. The rights granted to you under the License |
10 | * may not be used to create, or enable the creation or redistribution of, |
11 | * unlawful or unlicensed copies of an Apple operating system, or to |
12 | * circumvent, violate, or enable the circumvention or violation of, any |
13 | * terms of an Apple operating system software license agreement. |
14 | * |
15 | * Please obtain a copy of the License at |
16 | * http://www.opensource.apple.com/apsl/ and read it before using this file. |
17 | * |
18 | * The Original Code and all software distributed under the License are |
19 | * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER |
20 | * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, |
21 | * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, |
22 | * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. |
23 | * Please see the License for the specific language governing rights and |
24 | * limitations under the License. |
25 | * |
26 | * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ |
27 | */ |
28 | |
29 | #define __KPI__ |
30 | #include <sys/systm.h> |
31 | #include <sys/kernel.h> |
32 | #include <sys/types.h> |
33 | #include <sys/socket.h> |
34 | #include <sys/socketvar.h> |
35 | #include <sys/param.h> |
36 | #include <sys/proc.h> |
37 | #include <sys/errno.h> |
38 | #include <sys/malloc.h> |
39 | #include <sys/protosw.h> |
40 | #include <sys/domain.h> |
41 | #include <sys/mbuf.h> |
42 | #include <sys/mcache.h> |
43 | #include <sys/fcntl.h> |
44 | #include <sys/filio.h> |
45 | #include <sys/uio_internal.h> |
46 | #include <kern/locks.h> |
47 | #include <net/net_api_stats.h> |
48 | #include <netinet/in.h> |
49 | #include <libkern/OSAtomic.h> |
50 | #include <stdbool.h> |
51 | |
52 | static errno_t sock_send_internal(socket_t, const struct msghdr *, |
53 | mbuf_t, int, size_t *); |
54 | |
55 | #undef sock_accept |
56 | #undef sock_socket |
57 | errno_t sock_accept(socket_t so, struct sockaddr *from, int fromlen, |
58 | int flags, sock_upcall callback, void *cookie, socket_t *new_so); |
59 | errno_t sock_socket(int domain, int type, int protocol, sock_upcall callback, |
60 | void *context, socket_t *new_so); |
61 | |
62 | static errno_t sock_accept_common(socket_t sock, struct sockaddr *from, |
63 | int fromlen, int flags, sock_upcall callback, void *cookie, |
64 | socket_t *new_sock, bool is_internal); |
65 | static errno_t sock_socket_common(int domain, int type, int protocol, |
66 | sock_upcall callback, void *context, socket_t *new_so, bool is_internal); |
67 | |
68 | errno_t |
69 | sock_accept_common(socket_t sock, struct sockaddr *from, int fromlen, int flags, |
70 | sock_upcall callback, void *cookie, socket_t *new_sock, bool is_internal) |
71 | { |
72 | struct sockaddr *sa; |
73 | struct socket *new_so; |
74 | lck_mtx_t *mutex_held; |
75 | int dosocklock; |
76 | errno_t error = 0; |
77 | |
78 | if (sock == NULL || new_sock == NULL) |
79 | return (EINVAL); |
80 | |
81 | socket_lock(sock, 1); |
82 | if ((sock->so_options & SO_ACCEPTCONN) == 0) { |
83 | socket_unlock(sock, 1); |
84 | return (EINVAL); |
85 | } |
86 | if ((flags & ~(MSG_DONTWAIT)) != 0) { |
87 | socket_unlock(sock, 1); |
88 | return (ENOTSUP); |
89 | } |
90 | check_again: |
91 | if (((flags & MSG_DONTWAIT) != 0 || (sock->so_state & SS_NBIO) != 0) && |
92 | sock->so_comp.tqh_first == NULL) { |
93 | socket_unlock(sock, 1); |
94 | return (EWOULDBLOCK); |
95 | } |
96 | |
97 | if (sock->so_proto->pr_getlock != NULL) { |
98 | mutex_held = (*sock->so_proto->pr_getlock)(sock, PR_F_WILLUNLOCK); |
99 | dosocklock = 1; |
100 | } else { |
101 | mutex_held = sock->so_proto->pr_domain->dom_mtx; |
102 | dosocklock = 0; |
103 | } |
104 | |
105 | while (TAILQ_EMPTY(&sock->so_comp) && sock->so_error == 0) { |
106 | if (sock->so_state & SS_CANTRCVMORE) { |
107 | sock->so_error = ECONNABORTED; |
108 | break; |
109 | } |
110 | error = msleep((caddr_t)&sock->so_timeo, mutex_held, |
111 | PSOCK | PCATCH, "sock_accept" , NULL); |
112 | if (error != 0) { |
113 | socket_unlock(sock, 1); |
114 | return (error); |
115 | } |
116 | } |
117 | if (sock->so_error != 0) { |
118 | error = sock->so_error; |
119 | sock->so_error = 0; |
120 | socket_unlock(sock, 1); |
121 | return (error); |
122 | } |
123 | |
124 | so_acquire_accept_list(sock, NULL); |
125 | if (TAILQ_EMPTY(&sock->so_comp)) { |
126 | so_release_accept_list(sock); |
127 | goto check_again; |
128 | } |
129 | new_so = TAILQ_FIRST(&sock->so_comp); |
130 | TAILQ_REMOVE(&sock->so_comp, new_so, so_list); |
131 | new_so->so_state &= ~SS_COMP; |
132 | new_so->so_head = NULL; |
133 | sock->so_qlen--; |
134 | |
135 | so_release_accept_list(sock); |
136 | |
137 | /* |
138 | * Count the accepted socket as an in-kernel socket |
139 | */ |
140 | new_so->so_flags1 |= SOF1_IN_KERNEL_SOCKET; |
141 | INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_in_kernel_total); |
142 | if (is_internal) { |
143 | INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_in_kernel_os_total); |
144 | } |
145 | |
146 | /* |
147 | * Pass the pre-accepted socket to any interested socket filter(s). |
148 | * Upon failure, the socket would have been closed by the callee. |
149 | */ |
150 | if (new_so->so_filt != NULL) { |
151 | /* |
152 | * Temporarily drop the listening socket's lock before we |
153 | * hand off control over to the socket filter(s), but keep |
154 | * a reference so that it won't go away. We'll grab it |
155 | * again once we're done with the filter(s). |
156 | */ |
157 | socket_unlock(sock, 0); |
158 | if ((error = soacceptfilter(new_so, sock)) != 0) { |
159 | /* Drop reference on listening socket */ |
160 | sodereference(sock); |
161 | return (error); |
162 | } |
163 | socket_lock(sock, 0); |
164 | } |
165 | |
166 | if (dosocklock) { |
167 | LCK_MTX_ASSERT(new_so->so_proto->pr_getlock(new_so, 0), |
168 | LCK_MTX_ASSERT_NOTOWNED); |
169 | socket_lock(new_so, 1); |
170 | } |
171 | |
172 | (void) soacceptlock(new_so, &sa, 0); |
173 | |
174 | socket_unlock(sock, 1); /* release the head */ |
175 | |
176 | /* see comments in sock_setupcall() */ |
177 | if (callback != NULL) { |
178 | #if CONFIG_EMBEDDED |
179 | sock_setupcalls_locked(new_so, callback, cookie, callback, cookie, 0); |
180 | #else |
181 | sock_setupcalls_locked(new_so, callback, cookie, NULL, NULL, 0); |
182 | #endif /* !CONFIG_EMBEDDED */ |
183 | } |
184 | |
185 | if (sa != NULL && from != NULL) { |
186 | if (fromlen > sa->sa_len) |
187 | fromlen = sa->sa_len; |
188 | memcpy(from, sa, fromlen); |
189 | } |
190 | if (sa != NULL) |
191 | FREE(sa, M_SONAME); |
192 | |
193 | /* |
194 | * If the socket has been marked as inactive by sosetdefunct(), |
195 | * disallow further operations on it. |
196 | */ |
197 | if (new_so->so_flags & SOF_DEFUNCT) { |
198 | (void) sodefunct(current_proc(), new_so, |
199 | SHUTDOWN_SOCKET_LEVEL_DISCONNECT_INTERNAL); |
200 | } |
201 | *new_sock = new_so; |
202 | if (dosocklock) |
203 | socket_unlock(new_so, 1); |
204 | return (error); |
205 | } |
206 | |
207 | errno_t |
208 | sock_accept(socket_t sock, struct sockaddr *from, int fromlen, int flags, |
209 | sock_upcall callback, void *cookie, socket_t *new_sock) |
210 | { |
211 | return (sock_accept_common(sock, from, fromlen, flags, |
212 | callback, cookie, new_sock, false)); |
213 | } |
214 | |
215 | errno_t |
216 | sock_accept_internal(socket_t sock, struct sockaddr *from, int fromlen, int flags, |
217 | sock_upcall callback, void *cookie, socket_t *new_sock) |
218 | { |
219 | return (sock_accept_common(sock, from, fromlen, flags, |
220 | callback, cookie, new_sock, true)); |
221 | } |
222 | |
223 | errno_t |
224 | sock_bind(socket_t sock, const struct sockaddr *to) |
225 | { |
226 | int error = 0; |
227 | struct sockaddr *sa = NULL; |
228 | struct sockaddr_storage ss; |
229 | boolean_t want_free = TRUE; |
230 | |
231 | if (sock == NULL || to == NULL) |
232 | return (EINVAL); |
233 | |
234 | if (to->sa_len > sizeof (ss)) { |
235 | MALLOC(sa, struct sockaddr *, to->sa_len, M_SONAME, M_WAITOK); |
236 | if (sa == NULL) |
237 | return (ENOBUFS); |
238 | } else { |
239 | sa = (struct sockaddr *)&ss; |
240 | want_free = FALSE; |
241 | } |
242 | memcpy(sa, to, to->sa_len); |
243 | |
244 | error = sobindlock(sock, sa, 1); /* will lock socket */ |
245 | |
246 | if (sa != NULL && want_free == TRUE) |
247 | FREE(sa, M_SONAME); |
248 | |
249 | return (error); |
250 | } |
251 | |
252 | errno_t |
253 | sock_connect(socket_t sock, const struct sockaddr *to, int flags) |
254 | { |
255 | int error = 0; |
256 | lck_mtx_t *mutex_held; |
257 | struct sockaddr *sa = NULL; |
258 | struct sockaddr_storage ss; |
259 | boolean_t want_free = TRUE; |
260 | |
261 | if (sock == NULL || to == NULL) |
262 | return (EINVAL); |
263 | |
264 | if (to->sa_len > sizeof (ss)) { |
265 | MALLOC(sa, struct sockaddr *, to->sa_len, M_SONAME, |
266 | (flags & MSG_DONTWAIT) ? M_NOWAIT : M_WAITOK); |
267 | if (sa == NULL) |
268 | return (ENOBUFS); |
269 | } else { |
270 | sa = (struct sockaddr *)&ss; |
271 | want_free = FALSE; |
272 | } |
273 | memcpy(sa, to, to->sa_len); |
274 | |
275 | socket_lock(sock, 1); |
276 | |
277 | if ((sock->so_state & SS_ISCONNECTING) && |
278 | ((sock->so_state & SS_NBIO) != 0 || (flags & MSG_DONTWAIT) != 0)) { |
279 | error = EALREADY; |
280 | goto out; |
281 | } |
282 | error = soconnectlock(sock, sa, 0); |
283 | if (!error) { |
284 | if ((sock->so_state & SS_ISCONNECTING) && |
285 | ((sock->so_state & SS_NBIO) != 0 || |
286 | (flags & MSG_DONTWAIT) != 0)) { |
287 | error = EINPROGRESS; |
288 | goto out; |
289 | } |
290 | |
291 | if (sock->so_proto->pr_getlock != NULL) |
292 | mutex_held = (*sock->so_proto->pr_getlock)(sock, PR_F_WILLUNLOCK); |
293 | else |
294 | mutex_held = sock->so_proto->pr_domain->dom_mtx; |
295 | |
296 | while ((sock->so_state & SS_ISCONNECTING) && |
297 | sock->so_error == 0) { |
298 | error = msleep((caddr_t)&sock->so_timeo, |
299 | mutex_held, PSOCK | PCATCH, "sock_connect" , NULL); |
300 | if (error != 0) |
301 | break; |
302 | } |
303 | |
304 | if (error == 0) { |
305 | error = sock->so_error; |
306 | sock->so_error = 0; |
307 | } |
308 | } else { |
309 | sock->so_state &= ~SS_ISCONNECTING; |
310 | } |
311 | out: |
312 | socket_unlock(sock, 1); |
313 | |
314 | if (sa != NULL && want_free == TRUE) |
315 | FREE(sa, M_SONAME); |
316 | |
317 | return (error); |
318 | } |
319 | |
320 | errno_t |
321 | sock_connectwait(socket_t sock, const struct timeval *tv) |
322 | { |
323 | lck_mtx_t *mutex_held; |
324 | errno_t retval = 0; |
325 | struct timespec ts; |
326 | |
327 | socket_lock(sock, 1); |
328 | |
329 | /* Check if we're already connected or if we've already errored out */ |
330 | if ((sock->so_state & SS_ISCONNECTING) == 0 || sock->so_error != 0) { |
331 | if (sock->so_error != 0) { |
332 | retval = sock->so_error; |
333 | sock->so_error = 0; |
334 | } else { |
335 | if ((sock->so_state & SS_ISCONNECTED) != 0) |
336 | retval = 0; |
337 | else |
338 | retval = EINVAL; |
339 | } |
340 | goto done; |
341 | } |
342 | |
343 | /* copied translation from timeval to hertz from SO_RCVTIMEO handling */ |
344 | if (tv->tv_sec < 0 || tv->tv_sec > SHRT_MAX / hz || |
345 | tv->tv_usec < 0 || tv->tv_usec >= 1000000) { |
346 | retval = EDOM; |
347 | goto done; |
348 | } |
349 | |
350 | ts.tv_sec = tv->tv_sec; |
351 | ts.tv_nsec = (tv->tv_usec * (integer_t)NSEC_PER_USEC); |
352 | if ((ts.tv_sec + (ts.tv_nsec/(long)NSEC_PER_SEC))/100 > SHRT_MAX) { |
353 | retval = EDOM; |
354 | goto done; |
355 | } |
356 | |
357 | if (sock->so_proto->pr_getlock != NULL) |
358 | mutex_held = (*sock->so_proto->pr_getlock)(sock, PR_F_WILLUNLOCK); |
359 | else |
360 | mutex_held = sock->so_proto->pr_domain->dom_mtx; |
361 | |
362 | msleep((caddr_t)&sock->so_timeo, mutex_held, |
363 | PSOCK, "sock_connectwait" , &ts); |
364 | |
365 | /* Check if we're still waiting to connect */ |
366 | if ((sock->so_state & SS_ISCONNECTING) && sock->so_error == 0) { |
367 | retval = EINPROGRESS; |
368 | goto done; |
369 | } |
370 | |
371 | if (sock->so_error != 0) { |
372 | retval = sock->so_error; |
373 | sock->so_error = 0; |
374 | } |
375 | |
376 | done: |
377 | socket_unlock(sock, 1); |
378 | return (retval); |
379 | } |
380 | |
381 | errno_t |
382 | sock_nointerrupt(socket_t sock, int on) |
383 | { |
384 | socket_lock(sock, 1); |
385 | |
386 | if (on) { |
387 | sock->so_rcv.sb_flags |= SB_NOINTR; /* This isn't safe */ |
388 | sock->so_snd.sb_flags |= SB_NOINTR; /* This isn't safe */ |
389 | } else { |
390 | sock->so_rcv.sb_flags &= ~SB_NOINTR; /* This isn't safe */ |
391 | sock->so_snd.sb_flags &= ~SB_NOINTR; /* This isn't safe */ |
392 | } |
393 | |
394 | socket_unlock(sock, 1); |
395 | |
396 | return (0); |
397 | } |
398 | |
399 | errno_t |
400 | sock_getpeername(socket_t sock, struct sockaddr *peername, int peernamelen) |
401 | { |
402 | int error; |
403 | struct sockaddr *sa = NULL; |
404 | |
405 | if (sock == NULL || peername == NULL || peernamelen < 0) |
406 | return (EINVAL); |
407 | |
408 | socket_lock(sock, 1); |
409 | if (!(sock->so_state & (SS_ISCONNECTED|SS_ISCONFIRMING))) { |
410 | socket_unlock(sock, 1); |
411 | return (ENOTCONN); |
412 | } |
413 | error = sogetaddr_locked(sock, &sa, 1); |
414 | socket_unlock(sock, 1); |
415 | if (error == 0) { |
416 | if (peernamelen > sa->sa_len) |
417 | peernamelen = sa->sa_len; |
418 | memcpy(peername, sa, peernamelen); |
419 | FREE(sa, M_SONAME); |
420 | } |
421 | return (error); |
422 | } |
423 | |
424 | errno_t |
425 | sock_getsockname(socket_t sock, struct sockaddr *sockname, int socknamelen) |
426 | { |
427 | int error; |
428 | struct sockaddr *sa = NULL; |
429 | |
430 | if (sock == NULL || sockname == NULL || socknamelen < 0) |
431 | return (EINVAL); |
432 | |
433 | socket_lock(sock, 1); |
434 | error = sogetaddr_locked(sock, &sa, 0); |
435 | socket_unlock(sock, 1); |
436 | if (error == 0) { |
437 | if (socknamelen > sa->sa_len) |
438 | socknamelen = sa->sa_len; |
439 | memcpy(sockname, sa, socknamelen); |
440 | FREE(sa, M_SONAME); |
441 | } |
442 | return (error); |
443 | } |
444 | |
445 | __private_extern__ int |
446 | sogetaddr_locked(struct socket *so, struct sockaddr **psa, int peer) |
447 | { |
448 | int error; |
449 | |
450 | if (so == NULL || psa == NULL) |
451 | return (EINVAL); |
452 | |
453 | *psa = NULL; |
454 | error = peer ? so->so_proto->pr_usrreqs->pru_peeraddr(so, psa) : |
455 | so->so_proto->pr_usrreqs->pru_sockaddr(so, psa); |
456 | |
457 | if (error == 0 && *psa == NULL) { |
458 | error = ENOMEM; |
459 | } else if (error != 0 && *psa != NULL) { |
460 | FREE(*psa, M_SONAME); |
461 | *psa = NULL; |
462 | } |
463 | return (error); |
464 | } |
465 | |
466 | errno_t |
467 | sock_getaddr(socket_t sock, struct sockaddr **psa, int peer) |
468 | { |
469 | int error; |
470 | |
471 | if (sock == NULL || psa == NULL) |
472 | return (EINVAL); |
473 | |
474 | socket_lock(sock, 1); |
475 | error = sogetaddr_locked(sock, psa, peer); |
476 | socket_unlock(sock, 1); |
477 | |
478 | return (error); |
479 | } |
480 | |
481 | void |
482 | sock_freeaddr(struct sockaddr *sa) |
483 | { |
484 | if (sa != NULL) |
485 | FREE(sa, M_SONAME); |
486 | } |
487 | |
488 | errno_t |
489 | sock_getsockopt(socket_t sock, int level, int optname, void *optval, |
490 | int *optlen) |
491 | { |
492 | int error = 0; |
493 | struct sockopt sopt; |
494 | |
495 | if (sock == NULL || optval == NULL || optlen == NULL) |
496 | return (EINVAL); |
497 | |
498 | sopt.sopt_dir = SOPT_GET; |
499 | sopt.sopt_level = level; |
500 | sopt.sopt_name = optname; |
501 | sopt.sopt_val = CAST_USER_ADDR_T(optval); |
502 | sopt.sopt_valsize = *optlen; |
503 | sopt.sopt_p = kernproc; |
504 | error = sogetoptlock(sock, &sopt, 1); /* will lock socket */ |
505 | if (error == 0) |
506 | *optlen = sopt.sopt_valsize; |
507 | return (error); |
508 | } |
509 | |
510 | errno_t |
511 | sock_ioctl(socket_t sock, unsigned long request, void *argp) |
512 | { |
513 | return (soioctl(sock, request, argp, kernproc)); /* will lock socket */ |
514 | } |
515 | |
516 | errno_t |
517 | sock_setsockopt(socket_t sock, int level, int optname, const void *optval, |
518 | int optlen) |
519 | { |
520 | struct sockopt sopt; |
521 | |
522 | if (sock == NULL || optval == NULL) |
523 | return (EINVAL); |
524 | |
525 | sopt.sopt_dir = SOPT_SET; |
526 | sopt.sopt_level = level; |
527 | sopt.sopt_name = optname; |
528 | sopt.sopt_val = CAST_USER_ADDR_T(optval); |
529 | sopt.sopt_valsize = optlen; |
530 | sopt.sopt_p = kernproc; |
531 | return (sosetoptlock(sock, &sopt, 1)); /* will lock socket */ |
532 | } |
533 | |
534 | /* |
535 | * This follows the recommended mappings between DSCP code points |
536 | * and WMM access classes. |
537 | */ |
538 | static u_int32_t so_tc_from_dscp(u_int8_t dscp); |
539 | static u_int32_t |
540 | so_tc_from_dscp(u_int8_t dscp) |
541 | { |
542 | u_int32_t tc; |
543 | |
544 | if (dscp >= 0x30 && dscp <= 0x3f) |
545 | tc = SO_TC_VO; |
546 | else if (dscp >= 0x20 && dscp <= 0x2f) |
547 | tc = SO_TC_VI; |
548 | else if (dscp >= 0x08 && dscp <= 0x17) |
549 | tc = SO_TC_BK_SYS; |
550 | else |
551 | tc = SO_TC_BE; |
552 | |
553 | return (tc); |
554 | } |
555 | |
556 | errno_t |
557 | sock_settclassopt(socket_t sock, const void *optval, size_t optlen) |
558 | { |
559 | errno_t error = 0; |
560 | struct sockopt sopt; |
561 | int sotc; |
562 | |
563 | if (sock == NULL || optval == NULL || optlen != sizeof (int)) |
564 | return (EINVAL); |
565 | |
566 | socket_lock(sock, 1); |
567 | if (!(sock->so_state & SS_ISCONNECTED)) { |
568 | /* |
569 | * If the socket is not connected then we don't know |
570 | * if the destination is on LAN or not. Skip |
571 | * setting traffic class in this case |
572 | */ |
573 | error = ENOTCONN; |
574 | goto out; |
575 | } |
576 | |
577 | if (sock->so_proto == NULL || sock->so_proto->pr_domain == NULL || |
578 | sock->so_pcb == NULL) { |
579 | error = EINVAL; |
580 | goto out; |
581 | } |
582 | |
583 | /* |
584 | * Set the socket traffic class based on the passed DSCP code point |
585 | * regardless of the scope of the destination |
586 | */ |
587 | sotc = so_tc_from_dscp((*(const int *)optval) >> 2); |
588 | |
589 | sopt.sopt_dir = SOPT_SET; |
590 | sopt.sopt_val = CAST_USER_ADDR_T(&sotc); |
591 | sopt.sopt_valsize = sizeof (sotc); |
592 | sopt.sopt_p = kernproc; |
593 | sopt.sopt_level = SOL_SOCKET; |
594 | sopt.sopt_name = SO_TRAFFIC_CLASS; |
595 | |
596 | error = sosetoptlock(sock, &sopt, 0); /* already locked */ |
597 | |
598 | if (error != 0) { |
599 | printf("%s: sosetopt SO_TRAFFIC_CLASS failed %d\n" , |
600 | __func__, error); |
601 | goto out; |
602 | } |
603 | |
604 | /* |
605 | * Check if the destination address is LAN or link local address. |
606 | * We do not want to set traffic class bits if the destination |
607 | * is not local. |
608 | */ |
609 | if (!so_isdstlocal(sock)) |
610 | goto out; |
611 | |
612 | sopt.sopt_dir = SOPT_SET; |
613 | sopt.sopt_val = CAST_USER_ADDR_T(optval); |
614 | sopt.sopt_valsize = optlen; |
615 | sopt.sopt_p = kernproc; |
616 | |
617 | switch (SOCK_DOM(sock)) { |
618 | case PF_INET: |
619 | sopt.sopt_level = IPPROTO_IP; |
620 | sopt.sopt_name = IP_TOS; |
621 | break; |
622 | case PF_INET6: |
623 | sopt.sopt_level = IPPROTO_IPV6; |
624 | sopt.sopt_name = IPV6_TCLASS; |
625 | break; |
626 | default: |
627 | error = EINVAL; |
628 | goto out; |
629 | } |
630 | |
631 | error = sosetoptlock(sock, &sopt, 0); /* already locked */ |
632 | socket_unlock(sock, 1); |
633 | return (error); |
634 | out: |
635 | socket_unlock(sock, 1); |
636 | return (error); |
637 | } |
638 | |
639 | errno_t |
640 | sock_gettclassopt(socket_t sock, void *optval, size_t *optlen) |
641 | { |
642 | errno_t error = 0; |
643 | struct sockopt sopt; |
644 | |
645 | if (sock == NULL || optval == NULL || optlen == NULL) |
646 | return (EINVAL); |
647 | |
648 | sopt.sopt_dir = SOPT_GET; |
649 | sopt.sopt_val = CAST_USER_ADDR_T(optval); |
650 | sopt.sopt_valsize = *optlen; |
651 | sopt.sopt_p = kernproc; |
652 | |
653 | socket_lock(sock, 1); |
654 | if (sock->so_proto == NULL || sock->so_proto->pr_domain == NULL) { |
655 | socket_unlock(sock, 1); |
656 | return (EINVAL); |
657 | } |
658 | |
659 | switch (SOCK_DOM(sock)) { |
660 | case PF_INET: |
661 | sopt.sopt_level = IPPROTO_IP; |
662 | sopt.sopt_name = IP_TOS; |
663 | break; |
664 | case PF_INET6: |
665 | sopt.sopt_level = IPPROTO_IPV6; |
666 | sopt.sopt_name = IPV6_TCLASS; |
667 | break; |
668 | default: |
669 | socket_unlock(sock, 1); |
670 | return (EINVAL); |
671 | |
672 | } |
673 | error = sogetoptlock(sock, &sopt, 0); /* already locked */ |
674 | socket_unlock(sock, 1); |
675 | if (error == 0) |
676 | *optlen = sopt.sopt_valsize; |
677 | return (error); |
678 | } |
679 | |
680 | errno_t |
681 | sock_listen(socket_t sock, int backlog) |
682 | { |
683 | if (sock == NULL) |
684 | return (EINVAL); |
685 | |
686 | return (solisten(sock, backlog)); /* will lock socket */ |
687 | } |
688 | |
689 | errno_t |
690 | sock_receive_internal(socket_t sock, struct msghdr *msg, mbuf_t *data, |
691 | int flags, size_t *recvdlen) |
692 | { |
693 | uio_t auio; |
694 | struct mbuf *control = NULL; |
695 | int error = 0; |
696 | int length = 0; |
697 | struct sockaddr *fromsa = NULL; |
698 | char uio_buf[ UIO_SIZEOF((msg != NULL) ? msg->msg_iovlen : 0) ]; |
699 | |
700 | if (sock == NULL) |
701 | return (EINVAL); |
702 | |
703 | auio = uio_createwithbuffer(((msg != NULL) ? msg->msg_iovlen : 0), |
704 | 0, UIO_SYSSPACE, UIO_READ, &uio_buf[0], sizeof (uio_buf)); |
705 | if (msg != NULL && data == NULL) { |
706 | int i; |
707 | struct iovec *tempp = msg->msg_iov; |
708 | |
709 | for (i = 0; i < msg->msg_iovlen; i++) { |
710 | uio_addiov(auio, |
711 | CAST_USER_ADDR_T((tempp + i)->iov_base), |
712 | (tempp + i)->iov_len); |
713 | } |
714 | if (uio_resid(auio) < 0) |
715 | return (EINVAL); |
716 | } else if (recvdlen != NULL) { |
717 | uio_setresid(auio, (uio_resid(auio) + *recvdlen)); |
718 | } |
719 | length = uio_resid(auio); |
720 | |
721 | if (recvdlen != NULL) |
722 | *recvdlen = 0; |
723 | |
724 | /* let pru_soreceive handle the socket locking */ |
725 | error = sock->so_proto->pr_usrreqs->pru_soreceive(sock, &fromsa, auio, |
726 | data, (msg && msg->msg_control) ? &control : NULL, &flags); |
727 | if (error != 0) |
728 | goto cleanup; |
729 | |
730 | if (recvdlen != NULL) |
731 | *recvdlen = length - uio_resid(auio); |
732 | if (msg != NULL) { |
733 | msg->msg_flags = flags; |
734 | |
735 | if (msg->msg_name != NULL) { |
736 | int salen; |
737 | salen = msg->msg_namelen; |
738 | if (msg->msg_namelen > 0 && fromsa != NULL) { |
739 | salen = MIN(salen, fromsa->sa_len); |
740 | memcpy(msg->msg_name, fromsa, |
741 | msg->msg_namelen > fromsa->sa_len ? |
742 | fromsa->sa_len : msg->msg_namelen); |
743 | } |
744 | } |
745 | |
746 | if (msg->msg_control != NULL) { |
747 | struct mbuf *m = control; |
748 | u_char *ctlbuf = msg->msg_control; |
749 | int clen = msg->msg_controllen; |
750 | |
751 | msg->msg_controllen = 0; |
752 | |
753 | while (m != NULL && clen > 0) { |
754 | unsigned int tocopy; |
755 | |
756 | if (clen >= m->m_len) { |
757 | tocopy = m->m_len; |
758 | } else { |
759 | msg->msg_flags |= MSG_CTRUNC; |
760 | tocopy = clen; |
761 | } |
762 | memcpy(ctlbuf, mtod(m, caddr_t), tocopy); |
763 | ctlbuf += tocopy; |
764 | clen -= tocopy; |
765 | m = m->m_next; |
766 | } |
767 | msg->msg_controllen = |
768 | (uintptr_t)ctlbuf - (uintptr_t)msg->msg_control; |
769 | } |
770 | } |
771 | |
772 | cleanup: |
773 | if (control != NULL) |
774 | m_freem(control); |
775 | if (fromsa != NULL) |
776 | FREE(fromsa, M_SONAME); |
777 | return (error); |
778 | } |
779 | |
780 | errno_t |
781 | sock_receive(socket_t sock, struct msghdr *msg, int flags, size_t *recvdlen) |
782 | { |
783 | if ((msg == NULL) || (msg->msg_iovlen < 1) || |
784 | (msg->msg_iov[0].iov_len == 0) || |
785 | (msg->msg_iov[0].iov_base == NULL)) |
786 | return (EINVAL); |
787 | |
788 | return (sock_receive_internal(sock, msg, NULL, flags, recvdlen)); |
789 | } |
790 | |
791 | errno_t |
792 | sock_receivembuf(socket_t sock, struct msghdr *msg, mbuf_t *data, int flags, |
793 | size_t *recvlen) |
794 | { |
795 | if (data == NULL || recvlen == 0 || *recvlen <= 0 || (msg != NULL && |
796 | (msg->msg_iov != NULL || msg->msg_iovlen != 0))) |
797 | return (EINVAL); |
798 | |
799 | return (sock_receive_internal(sock, msg, data, flags, recvlen)); |
800 | } |
801 | |
802 | errno_t |
803 | sock_send_internal(socket_t sock, const struct msghdr *msg, mbuf_t data, |
804 | int flags, size_t *sentlen) |
805 | { |
806 | uio_t auio = NULL; |
807 | struct mbuf *control = NULL; |
808 | int error = 0; |
809 | int datalen = 0; |
810 | char uio_buf[ UIO_SIZEOF((msg != NULL ? msg->msg_iovlen : 1)) ]; |
811 | |
812 | if (sock == NULL) { |
813 | error = EINVAL; |
814 | goto errorout; |
815 | } |
816 | |
817 | if (data == NULL && msg != NULL) { |
818 | struct iovec *tempp = msg->msg_iov; |
819 | |
820 | auio = uio_createwithbuffer(msg->msg_iovlen, 0, |
821 | UIO_SYSSPACE, UIO_WRITE, &uio_buf[0], sizeof (uio_buf)); |
822 | if (tempp != NULL) { |
823 | int i; |
824 | |
825 | for (i = 0; i < msg->msg_iovlen; i++) { |
826 | uio_addiov(auio, |
827 | CAST_USER_ADDR_T((tempp + i)->iov_base), |
828 | (tempp + i)->iov_len); |
829 | } |
830 | |
831 | if (uio_resid(auio) < 0) { |
832 | error = EINVAL; |
833 | goto errorout; |
834 | } |
835 | } |
836 | } |
837 | |
838 | if (sentlen != NULL) |
839 | *sentlen = 0; |
840 | |
841 | if (auio != NULL) |
842 | datalen = uio_resid(auio); |
843 | else |
844 | datalen = data->m_pkthdr.len; |
845 | |
846 | if (msg != NULL && msg->msg_control) { |
847 | if ((size_t)msg->msg_controllen < sizeof (struct cmsghdr)) { |
848 | error = EINVAL; |
849 | goto errorout; |
850 | } |
851 | |
852 | if ((size_t)msg->msg_controllen > MLEN) { |
853 | error = EINVAL; |
854 | goto errorout; |
855 | } |
856 | |
857 | control = m_get(M_NOWAIT, MT_CONTROL); |
858 | if (control == NULL) { |
859 | error = ENOMEM; |
860 | goto errorout; |
861 | } |
862 | memcpy(mtod(control, caddr_t), msg->msg_control, |
863 | msg->msg_controllen); |
864 | control->m_len = msg->msg_controllen; |
865 | } |
866 | |
867 | error = sock->so_proto->pr_usrreqs->pru_sosend(sock, msg != NULL ? |
868 | (struct sockaddr *)msg->msg_name : NULL, auio, data, |
869 | control, flags); |
870 | |
871 | /* |
872 | * Residual data is possible in the case of IO vectors but not |
873 | * in the mbuf case since the latter is treated as atomic send. |
874 | * If pru_sosend() consumed a portion of the iovecs data and |
875 | * the error returned is transient, treat it as success; this |
876 | * is consistent with sendit() behavior. |
877 | */ |
878 | if (auio != NULL && uio_resid(auio) != datalen && |
879 | (error == ERESTART || error == EINTR || error == EWOULDBLOCK)) |
880 | error = 0; |
881 | |
882 | if (error == 0 && sentlen != NULL) { |
883 | if (auio != NULL) |
884 | *sentlen = datalen - uio_resid(auio); |
885 | else |
886 | *sentlen = datalen; |
887 | } |
888 | |
889 | return (error); |
890 | |
891 | /* |
892 | * In cases where we detect an error before returning, we need to |
893 | * free the mbuf chain if there is one. sosend (and pru_sosend) will |
894 | * free the mbuf chain if they encounter an error. |
895 | */ |
896 | errorout: |
897 | if (control) |
898 | m_freem(control); |
899 | if (data) |
900 | m_freem(data); |
901 | if (sentlen) |
902 | *sentlen = 0; |
903 | return (error); |
904 | } |
905 | |
906 | errno_t |
907 | sock_send(socket_t sock, const struct msghdr *msg, int flags, size_t *sentlen) |
908 | { |
909 | if (msg == NULL || msg->msg_iov == NULL || msg->msg_iovlen < 1) |
910 | return (EINVAL); |
911 | |
912 | return (sock_send_internal(sock, msg, NULL, flags, sentlen)); |
913 | } |
914 | |
915 | errno_t |
916 | sock_sendmbuf(socket_t sock, const struct msghdr *msg, mbuf_t data, |
917 | int flags, size_t *sentlen) |
918 | { |
919 | if (data == NULL || (msg != NULL && (msg->msg_iov != NULL || |
920 | msg->msg_iovlen != 0))) { |
921 | if (data != NULL) |
922 | m_freem(data); |
923 | return (EINVAL); |
924 | } |
925 | return (sock_send_internal(sock, msg, data, flags, sentlen)); |
926 | } |
927 | |
928 | errno_t |
929 | sock_shutdown(socket_t sock, int how) |
930 | { |
931 | if (sock == NULL) |
932 | return (EINVAL); |
933 | |
934 | return (soshutdown(sock, how)); |
935 | } |
936 | |
937 | errno_t |
938 | sock_socket_common(int domain, int type, int protocol, sock_upcall callback, |
939 | void *context, socket_t *new_so, bool is_internal) |
940 | { |
941 | int error = 0; |
942 | |
943 | if (new_so == NULL) |
944 | return (EINVAL); |
945 | |
946 | /* socreate will create an initial so_count */ |
947 | error = socreate(domain, new_so, type, protocol); |
948 | if (error == 0) { |
949 | /* |
950 | * This is an in-kernel socket |
951 | */ |
952 | (*new_so)->so_flags1 |= SOF1_IN_KERNEL_SOCKET; |
953 | INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_in_kernel_total); |
954 | if (is_internal) { |
955 | INC_ATOMIC_INT64_LIM(net_api_stats.nas_socket_in_kernel_os_total); |
956 | } |
957 | |
958 | /* see comments in sock_setupcall() */ |
959 | if (callback != NULL) { |
960 | sock_setupcall(*new_so, callback, context); |
961 | } |
962 | /* |
963 | * last_pid and last_upid should be zero for sockets |
964 | * created using sock_socket |
965 | */ |
966 | (*new_so)->last_pid = 0; |
967 | (*new_so)->last_upid = 0; |
968 | } |
969 | return (error); |
970 | } |
971 | |
972 | errno_t |
973 | sock_socket_internal(int domain, int type, int protocol, sock_upcall callback, |
974 | void *context, socket_t *new_so) |
975 | { |
976 | return (sock_socket_common(domain, type, protocol, callback, |
977 | context, new_so, true)); |
978 | } |
979 | |
980 | errno_t |
981 | sock_socket(int domain, int type, int protocol, sock_upcall callback, |
982 | void *context, socket_t *new_so) |
983 | { |
984 | return (sock_socket_common(domain, type, protocol, callback, |
985 | context, new_so, false)); |
986 | } |
987 | |
988 | void |
989 | sock_close(socket_t sock) |
990 | { |
991 | if (sock == NULL) |
992 | return; |
993 | |
994 | soclose(sock); |
995 | } |
996 | |
997 | /* Do we want this to be APPLE_PRIVATE API?: YES (LD 12/23/04) */ |
998 | void |
999 | sock_retain(socket_t sock) |
1000 | { |
1001 | if (sock == NULL) |
1002 | return; |
1003 | |
1004 | socket_lock(sock, 1); |
1005 | sock->so_retaincnt++; |
1006 | sock->so_usecount++; /* add extra reference for holding the socket */ |
1007 | socket_unlock(sock, 1); |
1008 | } |
1009 | |
1010 | /* Do we want this to be APPLE_PRIVATE API? */ |
1011 | void |
1012 | sock_release(socket_t sock) |
1013 | { |
1014 | if (sock == NULL) |
1015 | return; |
1016 | |
1017 | socket_lock(sock, 1); |
1018 | if (sock->so_upcallusecount > 0) |
1019 | soclose_wait_locked(sock); |
1020 | |
1021 | sock->so_retaincnt--; |
1022 | if (sock->so_retaincnt < 0) { |
1023 | panic("%s: negative retain count (%d) for sock=%p\n" , |
1024 | __func__, sock->so_retaincnt, sock); |
1025 | /* NOTREACHED */ |
1026 | } |
1027 | /* |
1028 | * Check SS_NOFDREF in case a close happened as sock_retain() |
1029 | * was grabbing the lock |
1030 | */ |
1031 | if ((sock->so_retaincnt == 0) && (sock->so_usecount == 2) && |
1032 | (!(sock->so_state & SS_NOFDREF) || |
1033 | (sock->so_flags & SOF_MP_SUBFLOW))) { |
1034 | /* close socket only if the FD is not holding it */ |
1035 | soclose_locked(sock); |
1036 | } else { |
1037 | /* remove extra reference holding the socket */ |
1038 | VERIFY(sock->so_usecount > 1); |
1039 | sock->so_usecount--; |
1040 | } |
1041 | socket_unlock(sock, 1); |
1042 | } |
1043 | |
1044 | errno_t |
1045 | sock_setpriv(socket_t sock, int on) |
1046 | { |
1047 | if (sock == NULL) |
1048 | return (EINVAL); |
1049 | |
1050 | socket_lock(sock, 1); |
1051 | if (on) |
1052 | sock->so_state |= SS_PRIV; |
1053 | else |
1054 | sock->so_state &= ~SS_PRIV; |
1055 | socket_unlock(sock, 1); |
1056 | return (0); |
1057 | } |
1058 | |
1059 | int |
1060 | sock_isconnected(socket_t sock) |
1061 | { |
1062 | int retval; |
1063 | |
1064 | socket_lock(sock, 1); |
1065 | retval = ((sock->so_state & SS_ISCONNECTED) ? 1 : 0); |
1066 | socket_unlock(sock, 1); |
1067 | return (retval); |
1068 | } |
1069 | |
1070 | int |
1071 | sock_isnonblocking(socket_t sock) |
1072 | { |
1073 | int retval; |
1074 | |
1075 | socket_lock(sock, 1); |
1076 | retval = ((sock->so_state & SS_NBIO) ? 1 : 0); |
1077 | socket_unlock(sock, 1); |
1078 | return (retval); |
1079 | } |
1080 | |
1081 | errno_t |
1082 | sock_gettype(socket_t sock, int *outDomain, int *outType, int *outProtocol) |
1083 | { |
1084 | socket_lock(sock, 1); |
1085 | if (outDomain != NULL) |
1086 | *outDomain = SOCK_DOM(sock); |
1087 | if (outType != NULL) |
1088 | *outType = sock->so_type; |
1089 | if (outProtocol != NULL) |
1090 | *outProtocol = SOCK_PROTO(sock); |
1091 | socket_unlock(sock, 1); |
1092 | return (0); |
1093 | } |
1094 | |
1095 | /* |
1096 | * Return the listening socket of a pre-accepted socket. It returns the |
1097 | * listener (so_head) value of a given socket. This is intended to be |
1098 | * called by a socket filter during a filter attach (sf_attach) callback. |
1099 | * The value returned by this routine is safe to be used only in the |
1100 | * context of that callback, because we hold the listener's lock across |
1101 | * the sflt_initsock() call. |
1102 | */ |
1103 | socket_t |
1104 | sock_getlistener(socket_t sock) |
1105 | { |
1106 | return (sock->so_head); |
1107 | } |
1108 | |
1109 | static inline void |
1110 | sock_set_tcp_stream_priority(socket_t sock) |
1111 | { |
1112 | if ((SOCK_DOM(sock) == PF_INET || SOCK_DOM(sock) == PF_INET6) && |
1113 | SOCK_TYPE(sock) == SOCK_STREAM) { |
1114 | set_tcp_stream_priority(sock); |
1115 | } |
1116 | } |
1117 | |
1118 | /* |
1119 | * Caller must have ensured socket is valid and won't be going away. |
1120 | */ |
1121 | void |
1122 | socket_set_traffic_mgt_flags_locked(socket_t sock, u_int8_t flags) |
1123 | { |
1124 | u_int32_t soflags1 = 0; |
1125 | |
1126 | if ((flags & TRAFFIC_MGT_SO_BACKGROUND)) |
1127 | soflags1 |= SOF1_TRAFFIC_MGT_SO_BACKGROUND; |
1128 | if ((flags & TRAFFIC_MGT_TCP_RECVBG)) |
1129 | soflags1 |= SOF1_TRAFFIC_MGT_TCP_RECVBG; |
1130 | |
1131 | (void) OSBitOrAtomic(soflags1, &sock->so_flags1); |
1132 | |
1133 | sock_set_tcp_stream_priority(sock); |
1134 | } |
1135 | |
1136 | void |
1137 | socket_set_traffic_mgt_flags(socket_t sock, u_int8_t flags) |
1138 | { |
1139 | socket_lock(sock, 1); |
1140 | socket_set_traffic_mgt_flags_locked(sock, flags); |
1141 | socket_unlock(sock, 1); |
1142 | } |
1143 | |
1144 | /* |
1145 | * Caller must have ensured socket is valid and won't be going away. |
1146 | */ |
1147 | void |
1148 | socket_clear_traffic_mgt_flags_locked(socket_t sock, u_int8_t flags) |
1149 | { |
1150 | u_int32_t soflags1 = 0; |
1151 | |
1152 | if ((flags & TRAFFIC_MGT_SO_BACKGROUND)) |
1153 | soflags1 |= SOF1_TRAFFIC_MGT_SO_BACKGROUND; |
1154 | if ((flags & TRAFFIC_MGT_TCP_RECVBG)) |
1155 | soflags1 |= SOF1_TRAFFIC_MGT_TCP_RECVBG; |
1156 | |
1157 | (void) OSBitAndAtomic(~soflags1, &sock->so_flags1); |
1158 | |
1159 | sock_set_tcp_stream_priority(sock); |
1160 | } |
1161 | |
1162 | void |
1163 | socket_clear_traffic_mgt_flags(socket_t sock, u_int8_t flags) |
1164 | { |
1165 | socket_lock(sock, 1); |
1166 | socket_clear_traffic_mgt_flags_locked(sock, flags); |
1167 | socket_unlock(sock, 1); |
1168 | } |
1169 | |
1170 | |
1171 | /* |
1172 | * Caller must have ensured socket is valid and won't be going away. |
1173 | */ |
1174 | errno_t |
1175 | socket_defunct(struct proc *p, socket_t so, int level) |
1176 | { |
1177 | errno_t retval; |
1178 | |
1179 | if (level != SHUTDOWN_SOCKET_LEVEL_DISCONNECT_SVC && |
1180 | level != SHUTDOWN_SOCKET_LEVEL_DISCONNECT_ALL) |
1181 | return (EINVAL); |
1182 | |
1183 | socket_lock(so, 1); |
1184 | /* |
1185 | * SHUTDOWN_SOCKET_LEVEL_DISCONNECT_SVC level is meant to tear down |
1186 | * all of mDNSResponder IPC sockets, currently those of AF_UNIX; note |
1187 | * that this is an implementation artifact of mDNSResponder. We do |
1188 | * a quick test against the socket buffers for SB_UNIX, since that |
1189 | * would have been set by unp_attach() at socket creation time. |
1190 | */ |
1191 | if (level == SHUTDOWN_SOCKET_LEVEL_DISCONNECT_SVC && |
1192 | (so->so_rcv.sb_flags & so->so_snd.sb_flags & SB_UNIX) != SB_UNIX) { |
1193 | socket_unlock(so, 1); |
1194 | return (EOPNOTSUPP); |
1195 | } |
1196 | retval = sosetdefunct(p, so, level, TRUE); |
1197 | if (retval == 0) |
1198 | retval = sodefunct(p, so, level); |
1199 | socket_unlock(so, 1); |
1200 | return (retval); |
1201 | } |
1202 | |
1203 | void |
1204 | sock_setupcalls_locked(socket_t sock, sock_upcall rcallback, void *rcontext, |
1205 | sock_upcall wcallback, void *wcontext, int locked) |
1206 | { |
1207 | if (rcallback != NULL) { |
1208 | sock->so_rcv.sb_flags |= SB_UPCALL; |
1209 | if (locked) |
1210 | sock->so_rcv.sb_flags |= SB_UPCALL_LOCK; |
1211 | sock->so_rcv.sb_upcall = rcallback; |
1212 | sock->so_rcv.sb_upcallarg = rcontext; |
1213 | } else { |
1214 | sock->so_rcv.sb_flags &= ~(SB_UPCALL | SB_UPCALL_LOCK); |
1215 | sock->so_rcv.sb_upcall = NULL; |
1216 | sock->so_rcv.sb_upcallarg = NULL; |
1217 | } |
1218 | |
1219 | if (wcallback != NULL) { |
1220 | sock->so_snd.sb_flags |= SB_UPCALL; |
1221 | if (locked) |
1222 | sock->so_snd.sb_flags |= SB_UPCALL_LOCK; |
1223 | sock->so_snd.sb_upcall = wcallback; |
1224 | sock->so_snd.sb_upcallarg = wcontext; |
1225 | } else { |
1226 | sock->so_snd.sb_flags &= ~(SB_UPCALL | SB_UPCALL_LOCK); |
1227 | sock->so_snd.sb_upcall = NULL; |
1228 | sock->so_snd.sb_upcallarg = NULL; |
1229 | } |
1230 | } |
1231 | |
1232 | errno_t |
1233 | sock_setupcall(socket_t sock, sock_upcall callback, void *context) |
1234 | { |
1235 | if (sock == NULL) |
1236 | return (EINVAL); |
1237 | |
1238 | /* |
1239 | * Note that we don't wait for any in progress upcall to complete. |
1240 | * On embedded, sock_setupcall() causes both read and write |
1241 | * callbacks to be set; on desktop, only read callback is set |
1242 | * to maintain legacy KPI behavior. |
1243 | * |
1244 | * The newer sock_setupcalls() KPI should be used instead to set |
1245 | * the read and write callbacks and their respective parameters. |
1246 | */ |
1247 | socket_lock(sock, 1); |
1248 | #if CONFIG_EMBEDDED |
1249 | sock_setupcalls_locked(sock, callback, context, callback, context, 0); |
1250 | #else |
1251 | sock_setupcalls_locked(sock, callback, context, NULL, NULL, 0); |
1252 | #endif /* !CONFIG_EMBEDDED */ |
1253 | socket_unlock(sock, 1); |
1254 | |
1255 | return (0); |
1256 | } |
1257 | |
1258 | errno_t |
1259 | sock_setupcalls(socket_t sock, sock_upcall rcallback, void *rcontext, |
1260 | sock_upcall wcallback, void *wcontext) |
1261 | { |
1262 | if (sock == NULL) |
1263 | return (EINVAL); |
1264 | |
1265 | /* |
1266 | * Note that we don't wait for any in progress upcall to complete. |
1267 | */ |
1268 | socket_lock(sock, 1); |
1269 | sock_setupcalls_locked(sock, rcallback, rcontext, wcallback, wcontext, 0); |
1270 | socket_unlock(sock, 1); |
1271 | |
1272 | return (0); |
1273 | } |
1274 | |
1275 | void |
1276 | sock_catchevents_locked(socket_t sock, sock_evupcall ecallback, void *econtext, |
1277 | u_int32_t emask) |
1278 | { |
1279 | socket_lock_assert_owned(sock); |
1280 | |
1281 | /* |
1282 | * Note that we don't wait for any in progress upcall to complete. |
1283 | */ |
1284 | if (ecallback != NULL) { |
1285 | sock->so_event = ecallback; |
1286 | sock->so_eventarg = econtext; |
1287 | sock->so_eventmask = emask; |
1288 | } else { |
1289 | sock->so_event = sonullevent; |
1290 | sock->so_eventarg = NULL; |
1291 | sock->so_eventmask = 0; |
1292 | } |
1293 | } |
1294 | |
1295 | errno_t |
1296 | sock_catchevents(socket_t sock, sock_evupcall ecallback, void *econtext, |
1297 | u_int32_t emask) |
1298 | { |
1299 | if (sock == NULL) |
1300 | return (EINVAL); |
1301 | |
1302 | socket_lock(sock, 1); |
1303 | sock_catchevents_locked(sock, ecallback, econtext, emask); |
1304 | socket_unlock(sock, 1); |
1305 | |
1306 | return (0); |
1307 | } |
1308 | |
1309 | /* |
1310 | * Returns true whether or not a socket belongs to the kernel. |
1311 | */ |
1312 | int |
1313 | sock_iskernel(socket_t so) |
1314 | { |
1315 | return (so && so->last_pid == 0); |
1316 | } |
1317 | |