1 | /* |
2 | * Copyright (c) 2000-2013 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 | * Copyright (c) 1982, 1986, 1990, 1993 |
30 | * The Regents of the University of California. All rights reserved. |
31 | * |
32 | * Redistribution and use in source and binary forms, with or without |
33 | * modification, are permitted provided that the following conditions |
34 | * are met: |
35 | * 1. Redistributions of source code must retain the above copyright |
36 | * notice, this list of conditions and the following disclaimer. |
37 | * 2. Redistributions in binary form must reproduce the above copyright |
38 | * notice, this list of conditions and the following disclaimer in the |
39 | * documentation and/or other materials provided with the distribution. |
40 | * 3. All advertising materials mentioning features or use of this software |
41 | * must display the following acknowledgement: |
42 | * This product includes software developed by the University of |
43 | * California, Berkeley and its contributors. |
44 | * 4. Neither the name of the University nor the names of its contributors |
45 | * may be used to endorse or promote products derived from this software |
46 | * without specific prior written permission. |
47 | * |
48 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
49 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
50 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
51 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
52 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
53 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
54 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
55 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
56 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
57 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
58 | * SUCH DAMAGE. |
59 | * |
60 | * @(#)sys_socket.c 8.1 (Berkeley) 6/10/93 |
61 | */ |
62 | /* |
63 | * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce |
64 | * support for mandatory and extensible security protections. This notice |
65 | * is included in support of clause 2.2 (b) of the Apple Public License, |
66 | * Version 2.0. |
67 | */ |
68 | |
69 | #include <sys/param.h> |
70 | #include <sys/systm.h> |
71 | #include <sys/file_internal.h> |
72 | #include <sys/event.h> |
73 | #include <sys/protosw.h> |
74 | #include <sys/socket.h> |
75 | #include <sys/socketvar.h> |
76 | #include <sys/filio.h> /* XXX */ |
77 | #include <sys/sockio.h> |
78 | #include <sys/stat.h> |
79 | #include <sys/uio.h> |
80 | #include <sys/filedesc.h> |
81 | #include <sys/kauth.h> |
82 | #include <sys/signalvar.h> |
83 | #include <sys/vnode.h> |
84 | |
85 | #include <net/if.h> |
86 | #include <net/route.h> |
87 | |
88 | #if CONFIG_MACF |
89 | #include <security/mac_framework.h> |
90 | #endif |
91 | |
92 | /* |
93 | * File operations on sockets. |
94 | */ |
95 | static int soo_read(struct fileproc *, struct uio *, int, vfs_context_t ctx); |
96 | static int soo_write(struct fileproc *, struct uio *, int, vfs_context_t ctx); |
97 | static int soo_close(struct fileglob *, vfs_context_t ctx); |
98 | static int soo_drain(struct fileproc *, vfs_context_t ctx); |
99 | |
100 | const struct fileops socketops = { |
101 | .fo_type = DTYPE_SOCKET, |
102 | .fo_read = soo_read, |
103 | .fo_write = soo_write, |
104 | .fo_ioctl = soo_ioctl, |
105 | .fo_select = soo_select, |
106 | .fo_close = soo_close, |
107 | .fo_drain = soo_drain, |
108 | .fo_kqfilter = soo_kqfilter, |
109 | }; |
110 | |
111 | /* ARGSUSED */ |
112 | static int |
113 | soo_read(struct fileproc *fp, struct uio *uio, __unused int flags, |
114 | __unused vfs_context_t ctx) |
115 | { |
116 | struct socket *so; |
117 | int stat; |
118 | |
119 | int (*fsoreceive)(struct socket *so2, struct sockaddr **paddr, |
120 | struct uio *uio2, struct mbuf **mp0, struct mbuf **controlp, |
121 | int *flagsp); |
122 | |
123 | if ((so = (struct socket *)fp_get_data(fp)) == NULL) { |
124 | /* This is not a valid open file descriptor */ |
125 | return EBADF; |
126 | } |
127 | |
128 | fsoreceive = so->so_proto->pr_usrreqs->pru_soreceive; |
129 | |
130 | stat = (*fsoreceive)(so, 0, uio, 0, 0, 0); |
131 | return stat; |
132 | } |
133 | |
134 | /* ARGSUSED */ |
135 | static int |
136 | soo_write(struct fileproc *fp, struct uio *uio, __unused int flags, |
137 | vfs_context_t ctx) |
138 | { |
139 | struct socket *so; |
140 | int stat; |
141 | int (*fsosend)(struct socket *so2, struct sockaddr *addr, |
142 | struct uio *uio2, struct mbuf *top, struct mbuf *control, |
143 | int flags2); |
144 | proc_t procp; |
145 | |
146 | if ((so = (struct socket *)fp_get_data(fp)) == NULL) { |
147 | /* This is not a valid open file descriptor */ |
148 | return EBADF; |
149 | } |
150 | |
151 | fsosend = so->so_proto->pr_usrreqs->pru_sosend; |
152 | |
153 | stat = (*fsosend)(so, 0, uio, 0, 0, 0); |
154 | |
155 | /* Generation of SIGPIPE can be controlled per socket */ |
156 | procp = vfs_context_proc(ctx); |
157 | if (stat == EPIPE && !(so->so_flags & SOF_NOSIGPIPE)) { |
158 | psignal(p: procp, SIGPIPE); |
159 | } |
160 | |
161 | return stat; |
162 | } |
163 | |
164 | __private_extern__ int |
165 | soioctl(struct socket *so, u_long cmd, caddr_t data, struct proc *p) |
166 | { |
167 | int error = 0; |
168 | int int_arg; |
169 | |
170 | #if CONFIG_MACF_SOCKET_SUBSET |
171 | error = mac_socket_check_ioctl(cred: kauth_cred_get(), so, cmd); |
172 | if (error) { |
173 | return error; |
174 | } |
175 | #endif |
176 | |
177 | socket_lock(so, refcount: 1); |
178 | |
179 | /* call the socket filter's ioctl handler anything but ours */ |
180 | if (IOCGROUP(cmd) != 'i' && IOCGROUP(cmd) != 'r') { |
181 | switch (cmd) { |
182 | case SIOCGASSOCIDS32: |
183 | case SIOCGASSOCIDS64: |
184 | case SIOCGCONNIDS32: |
185 | case SIOCGCONNIDS64: |
186 | case SIOCGCONNINFO32: |
187 | case SIOCGCONNINFO64: |
188 | case SIOCSCONNORDER: |
189 | case SIOCGCONNORDER: |
190 | /* don't pass to filter */ |
191 | break; |
192 | |
193 | default: |
194 | error = sflt_ioctl(so, cmd, data); |
195 | if (error != 0) { |
196 | goto out; |
197 | } |
198 | break; |
199 | } |
200 | } |
201 | |
202 | switch (cmd) { |
203 | case FIONBIO: /* int */ |
204 | bcopy(src: data, dst: &int_arg, n: sizeof(int_arg)); |
205 | if (int_arg) { |
206 | so->so_state |= SS_NBIO; |
207 | } else { |
208 | so->so_state &= ~SS_NBIO; |
209 | } |
210 | |
211 | goto out; |
212 | |
213 | case FIOASYNC: /* int */ |
214 | bcopy(src: data, dst: &int_arg, n: sizeof(int_arg)); |
215 | if (int_arg) { |
216 | so->so_state |= SS_ASYNC; |
217 | so->so_rcv.sb_flags |= SB_ASYNC; |
218 | so->so_snd.sb_flags |= SB_ASYNC; |
219 | } else { |
220 | so->so_state &= ~SS_ASYNC; |
221 | so->so_rcv.sb_flags &= ~SB_ASYNC; |
222 | so->so_snd.sb_flags &= ~SB_ASYNC; |
223 | } |
224 | goto out; |
225 | |
226 | case FIONREAD: /* int */ |
227 | bcopy(src: &so->so_rcv.sb_cc, dst: data, n: sizeof(u_int32_t)); |
228 | goto out; |
229 | |
230 | case SIOCSPGRP: /* int */ |
231 | bcopy(src: data, dst: &so->so_pgid, n: sizeof(pid_t)); |
232 | goto out; |
233 | |
234 | case SIOCGPGRP: /* int */ |
235 | bcopy(src: &so->so_pgid, dst: data, n: sizeof(pid_t)); |
236 | goto out; |
237 | |
238 | case SIOCATMARK: /* int */ |
239 | int_arg = (so->so_state & SS_RCVATMARK) != 0; |
240 | bcopy(src: &int_arg, dst: data, n: sizeof(int_arg)); |
241 | goto out; |
242 | |
243 | case SIOCSETOT: /* int; deprecated */ |
244 | error = EOPNOTSUPP; |
245 | goto out; |
246 | |
247 | case SIOCGASSOCIDS32: /* so_aidreq32 */ |
248 | case SIOCGASSOCIDS64: /* so_aidreq64 */ |
249 | case SIOCGCONNIDS32: /* so_cidreq32 */ |
250 | case SIOCGCONNIDS64: /* so_cidreq64 */ |
251 | case SIOCGCONNINFO32: /* so_cinforeq32 */ |
252 | case SIOCGCONNINFO64: /* so_cinforeq64 */ |
253 | case SIOCSCONNORDER: /* so_cordreq */ |
254 | case SIOCGCONNORDER: /* so_cordreq */ |
255 | error = (*so->so_proto->pr_usrreqs->pru_control)(so, |
256 | cmd, data, NULL, p); |
257 | goto out; |
258 | } |
259 | |
260 | /* |
261 | * Interface/routing/protocol specific ioctls: |
262 | * interface and routing ioctls should have a |
263 | * different entry since a socket's unnecessary |
264 | */ |
265 | if (IOCGROUP(cmd) == 'i') { |
266 | error = ifioctllocked(so, cmd, data, p); |
267 | } else { |
268 | if (IOCGROUP(cmd) == 'r') { |
269 | error = rtioctl(cmd, data, p); |
270 | } else { |
271 | error = (*so->so_proto->pr_usrreqs->pru_control)(so, |
272 | cmd, data, NULL, p); |
273 | } |
274 | } |
275 | |
276 | out: |
277 | socket_unlock(so, refcount: 1); |
278 | |
279 | if (error == EJUSTRETURN) { |
280 | error = 0; |
281 | } |
282 | |
283 | return error; |
284 | } |
285 | |
286 | int |
287 | soo_ioctl(struct fileproc *fp, u_long cmd, caddr_t data, vfs_context_t ctx) |
288 | { |
289 | struct socket *so; |
290 | proc_t procp = vfs_context_proc(ctx); |
291 | |
292 | if ((so = (struct socket *)fp_get_data(fp)) == NULL) { |
293 | /* This is not a valid open file descriptor */ |
294 | return EBADF; |
295 | } |
296 | |
297 | return soioctl(so, cmd, data, p: procp); |
298 | } |
299 | |
300 | int |
301 | soo_select(struct fileproc *fp, int which, void *wql, vfs_context_t ctx) |
302 | { |
303 | struct socket *so = (struct socket *)fp_get_data(fp); |
304 | int retnum = 0; |
305 | proc_t procp; |
306 | |
307 | if (so == NULL || so == (struct socket *)-1) { |
308 | return 0; |
309 | } |
310 | |
311 | procp = vfs_context_proc(ctx); |
312 | |
313 | socket_lock(so, refcount: 1); |
314 | switch (which) { |
315 | case FREAD: |
316 | so->so_rcv.sb_flags |= SB_SEL; |
317 | if (soreadable(so)) { |
318 | retnum = 1; |
319 | so->so_rcv.sb_flags &= ~SB_SEL; |
320 | goto done; |
321 | } |
322 | selrecord(selector: procp, &so->so_rcv.sb_sel, wql); |
323 | break; |
324 | |
325 | case FWRITE: |
326 | so->so_snd.sb_flags |= SB_SEL; |
327 | if (sowriteable(so)) { |
328 | retnum = 1; |
329 | so->so_snd.sb_flags &= ~SB_SEL; |
330 | goto done; |
331 | } |
332 | selrecord(selector: procp, &so->so_snd.sb_sel, wql); |
333 | break; |
334 | |
335 | case 0: |
336 | so->so_rcv.sb_flags |= SB_SEL; |
337 | if (so->so_oobmark || (so->so_state & SS_RCVATMARK)) { |
338 | retnum = 1; |
339 | so->so_rcv.sb_flags &= ~SB_SEL; |
340 | goto done; |
341 | } |
342 | selrecord(selector: procp, &so->so_rcv.sb_sel, wql); |
343 | break; |
344 | } |
345 | |
346 | done: |
347 | socket_unlock(so, refcount: 1); |
348 | return retnum; |
349 | } |
350 | |
351 | int |
352 | soo_stat(struct socket *so, void *ub, int isstat64) |
353 | { |
354 | int ret; |
355 | /* warning avoidance ; protected by isstat64 */ |
356 | struct stat *sb = (struct stat *)0; |
357 | /* warning avoidance ; protected by isstat64 */ |
358 | struct stat64 *sb64 = (struct stat64 *)0; |
359 | |
360 | #if CONFIG_MACF_SOCKET_SUBSET |
361 | ret = mac_socket_check_stat(cred: kauth_cred_get(), so); |
362 | if (ret) { |
363 | return ret; |
364 | } |
365 | #endif |
366 | |
367 | if (isstat64 != 0) { |
368 | sb64 = (struct stat64 *)ub; |
369 | bzero(s: (caddr_t)sb64, n: sizeof(*sb64)); |
370 | } else { |
371 | sb = (struct stat *)ub; |
372 | bzero(s: (caddr_t)sb, n: sizeof(*sb)); |
373 | } |
374 | |
375 | socket_lock(so, refcount: 1); |
376 | if (isstat64 != 0) { |
377 | sb64->st_mode = S_IFSOCK; |
378 | if ((so->so_state & SS_CANTRCVMORE) == 0 || |
379 | so->so_rcv.sb_cc != 0) { |
380 | sb64->st_mode |= S_IRUSR | S_IRGRP | S_IROTH; |
381 | } |
382 | if ((so->so_state & SS_CANTSENDMORE) == 0) { |
383 | sb64->st_mode |= S_IWUSR | S_IWGRP | S_IWOTH; |
384 | } |
385 | sb64->st_size = so->so_rcv.sb_cc - so->so_rcv.sb_ctl; |
386 | sb64->st_uid = kauth_cred_getuid(cred: so->so_cred); |
387 | sb64->st_gid = kauth_cred_getgid(cred: so->so_cred); |
388 | } else { |
389 | sb->st_mode = S_IFSOCK; |
390 | if ((so->so_state & SS_CANTRCVMORE) == 0 || |
391 | so->so_rcv.sb_cc != 0) { |
392 | sb->st_mode |= S_IRUSR | S_IRGRP | S_IROTH; |
393 | } |
394 | if ((so->so_state & SS_CANTSENDMORE) == 0) { |
395 | sb->st_mode |= S_IWUSR | S_IWGRP | S_IWOTH; |
396 | } |
397 | sb->st_size = so->so_rcv.sb_cc - so->so_rcv.sb_ctl; |
398 | sb->st_uid = kauth_cred_getuid(cred: so->so_cred); |
399 | sb->st_gid = kauth_cred_getgid(cred: so->so_cred); |
400 | } |
401 | |
402 | ret = (*so->so_proto->pr_usrreqs->pru_sense)(so, ub, isstat64); |
403 | socket_unlock(so, refcount: 1); |
404 | return ret; |
405 | } |
406 | |
407 | /* ARGSUSED */ |
408 | static int |
409 | soo_close(struct fileglob *fg, __unused vfs_context_t ctx) |
410 | { |
411 | int error = 0; |
412 | struct socket *sp; |
413 | |
414 | sp = (struct socket *)fg_get_data(fg); |
415 | fg_set_data(fg, NULL); |
416 | |
417 | if (sp) { |
418 | error = soclose(so: sp); |
419 | } |
420 | |
421 | return error; |
422 | } |
423 | |
424 | static int |
425 | soo_drain(struct fileproc *fp, __unused vfs_context_t ctx) |
426 | { |
427 | int error = 0; |
428 | struct socket *so = (struct socket *)fp_get_data(fp); |
429 | |
430 | if (so) { |
431 | socket_lock(so, refcount: 1); |
432 | so->so_state |= SS_DRAINING; |
433 | |
434 | wakeup(chan: (caddr_t)&so->so_timeo); |
435 | sorwakeup(so); |
436 | sowwakeup(so); |
437 | soevent(so, SO_FILT_HINT_LOCKED); |
438 | |
439 | socket_unlock(so, refcount: 1); |
440 | } |
441 | |
442 | return error; |
443 | } |
444 | |
445 | /* |
446 | * 's' group ioctls. |
447 | * |
448 | * The switch statement below does nothing at runtime, as it serves as a |
449 | * compile time check to ensure that all of the socket 's' ioctls (those |
450 | * in the 's' group going thru soo_ioctl) that are made available by the |
451 | * networking stack is unique. This works as long as this routine gets |
452 | * updated each time a new interface ioctl gets added. |
453 | * |
454 | * Any failures at compile time indicates duplicated ioctl values. |
455 | */ |
456 | static __attribute__((unused)) void |
457 | soioctl_cassert(void) |
458 | { |
459 | /* |
460 | * This is equivalent to _CASSERT() and the compiler wouldn't |
461 | * generate any instructions, thus for compile time only. |
462 | */ |
463 | switch ((u_long)0) { |
464 | case 0: |
465 | |
466 | /* bsd/sys/sockio.h */ |
467 | case SIOCSHIWAT: |
468 | case SIOCGHIWAT: |
469 | case SIOCSLOWAT: |
470 | case SIOCGLOWAT: |
471 | case SIOCATMARK: |
472 | case SIOCSPGRP: |
473 | case SIOCGPGRP: |
474 | case SIOCSETOT: |
475 | case SIOCGASSOCIDS32: |
476 | case SIOCGASSOCIDS64: |
477 | case SIOCGCONNIDS32: |
478 | case SIOCGCONNIDS64: |
479 | case SIOCGCONNINFO32: |
480 | case SIOCGCONNINFO64: |
481 | case SIOCSCONNORDER: |
482 | case SIOCGCONNORDER: |
483 | ; |
484 | } |
485 | } |
486 | |