1 /* $NetBSD: uipc_accf.c,v 1.16 2024/12/06 18:44:00 riastradh Exp $ */
2
3 /*-
4 * Copyright (c) 2008 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software developed for The NetBSD Foundation
8 * by Andrew Doran.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 /*-
33 * Copyright (c) 2000 Paycounter, Inc.
34 * Copyright (c) 2005 Robert N. M. Watson
35 * Author: Alfred Perlstein <alfred@paycounter.com>, <alfred@FreeBSD.org>
36 * All rights reserved.
37 *
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
40 * are met:
41 * 1. Redistributions of source code must retain the above copyright
42 * notice, this list of conditions and the following disclaimer.
43 * 2. Redistributions in binary form must reproduce the above copyright
44 * notice, this list of conditions and the following disclaimer in the
45 * documentation and/or other materials provided with the distribution.
46 *
47 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
48 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
49 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
50 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
51 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
52 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
53 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
54 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
55 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
56 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
57 * SUCH DAMAGE.
58 */
59
60 #include <sys/cdefs.h>
61 __KERNEL_RCSID(0, "$NetBSD: uipc_accf.c,v 1.16 2024/12/06 18:44:00 riastradh Exp $");
62
63 #define ACCEPT_FILTER_MOD
64
65 #include <sys/param.h>
66 #include <sys/types.h>
67
68 #include <sys/atomic.h>
69 #include <sys/domain.h>
70 #include <sys/kernel.h>
71 #include <sys/kmem.h>
72 #include <sys/lock.h>
73 #include <sys/mbuf.h>
74 #include <sys/module.h>
75 #include <sys/once.h>
76 #include <sys/protosw.h>
77 #include <sys/queue.h>
78 #include <sys/rwlock.h>
79 #include <sys/sdt.h>
80 #include <sys/socket.h>
81 #include <sys/socketvar.h>
82 #include <sys/sysctl.h>
83 #include <sys/systm.h>
84
85 static krwlock_t accept_filter_lock;
86
87 static LIST_HEAD(, accept_filter) accept_filtlsthd =
88 LIST_HEAD_INITIALIZER(&accept_filtlsthd);
89
90 /*
91 * Names of Accept filter sysctl objects
92 */
93 static struct sysctllog *ctllog;
94 static void
sysctl_net_inet_accf_setup(void)95 sysctl_net_inet_accf_setup(void)
96 {
97
98 sysctl_createv(&ctllog, 0, NULL, NULL,
99 CTLFLAG_PERMANENT,
100 CTLTYPE_NODE, "inet", NULL,
101 NULL, 0, NULL, 0,
102 CTL_NET, PF_INET, CTL_EOL);
103 sysctl_createv(&ctllog, 0, NULL, NULL,
104 CTLFLAG_PERMANENT,
105 CTLTYPE_NODE, "accf",
106 SYSCTL_DESCR("Accept filters"),
107 NULL, 0, NULL, 0,
108 CTL_NET, PF_INET, SO_ACCEPTFILTER, CTL_EOL);
109 }
110
111 int
accept_filt_add(struct accept_filter * filt)112 accept_filt_add(struct accept_filter *filt)
113 {
114 struct accept_filter *p;
115
116 accept_filter_init();
117
118 rw_enter(&accept_filter_lock, RW_WRITER);
119 LIST_FOREACH(p, &accept_filtlsthd, accf_next) {
120 if (strcmp(p->accf_name, filt->accf_name) == 0) {
121 rw_exit(&accept_filter_lock);
122 return SET_ERROR(EEXIST);
123 }
124 }
125 LIST_INSERT_HEAD(&accept_filtlsthd, filt, accf_next);
126 rw_exit(&accept_filter_lock);
127
128 return 0;
129 }
130
131 int
accept_filt_del(struct accept_filter * p)132 accept_filt_del(struct accept_filter *p)
133 {
134
135 rw_enter(&accept_filter_lock, RW_WRITER);
136 if (p->accf_refcnt != 0) {
137 rw_exit(&accept_filter_lock);
138 return SET_ERROR(EBUSY);
139 }
140 LIST_REMOVE(p, accf_next);
141 rw_exit(&accept_filter_lock);
142
143 return 0;
144 }
145
146 struct accept_filter *
accept_filt_get(char * name)147 accept_filt_get(char *name)
148 {
149 struct accept_filter *p;
150 char buf[32];
151 u_int gen;
152
153 do {
154 rw_enter(&accept_filter_lock, RW_READER);
155 LIST_FOREACH(p, &accept_filtlsthd, accf_next) {
156 if (strcmp(p->accf_name, name) == 0) {
157 atomic_inc_uint(&p->accf_refcnt);
158 break;
159 }
160 }
161 rw_exit(&accept_filter_lock);
162 if (p != NULL) {
163 break;
164 }
165 /* Try to autoload a module to satisfy the request. */
166 strcpy(buf, "accf_");
167 strlcat(buf, name, sizeof(buf));
168 gen = module_gen;
169 (void)module_autoload(buf, MODULE_CLASS_ANY);
170 } while (gen != module_gen);
171
172 return p;
173 }
174
175 /*
176 * Accept filter initialization routine.
177 * This should be called only once.
178 */
179
180 static int
accept_filter_init0(void)181 accept_filter_init0(void)
182 {
183
184 rw_init(&accept_filter_lock);
185 sysctl_net_inet_accf_setup();
186
187 return 0;
188 }
189
190 /*
191 * Initialization routine: This can also be replaced with
192 * accept_filt_generic_mod_event for attaching new accept filter.
193 */
194
195 void
accept_filter_init(void)196 accept_filter_init(void)
197 {
198 static ONCE_DECL(accept_filter_init_once);
199
200 RUN_ONCE(&accept_filter_init_once, accept_filter_init0);
201 }
202
203 int
accept_filt_getopt(struct socket * so,struct sockopt * sopt)204 accept_filt_getopt(struct socket *so, struct sockopt *sopt)
205 {
206 struct accept_filter_arg afa;
207 int error;
208
209 KASSERT(solocked(so));
210
211 if ((so->so_options & SO_ACCEPTCONN) == 0) {
212 error = SET_ERROR(EINVAL);
213 goto out;
214 }
215 if ((so->so_options & SO_ACCEPTFILTER) == 0) {
216 error = SET_ERROR(EINVAL);
217 goto out;
218 }
219
220 memset(&afa, 0, sizeof(afa));
221 strcpy(afa.af_name, so->so_accf->so_accept_filter->accf_name);
222 if (so->so_accf->so_accept_filter_str != NULL)
223 strcpy(afa.af_arg, so->so_accf->so_accept_filter_str);
224 error = sockopt_set(sopt, &afa, sizeof(afa));
225 out:
226 return error;
227 }
228
229 /*
230 * Simple delete case, with socket locked.
231 */
232 int
accept_filt_clear(struct socket * so)233 accept_filt_clear(struct socket *so)
234 {
235 struct accept_filter_arg afa;
236 struct accept_filter *afp;
237 struct socket *so2, *next;
238 struct so_accf *af;
239
240 KASSERT(solocked(so));
241
242 if ((so->so_options & SO_ACCEPTCONN) == 0) {
243 return SET_ERROR(EINVAL);
244 }
245 if (so->so_accf != NULL) {
246 /* Break in-flight processing. */
247 for (so2 = TAILQ_FIRST(&so->so_q0); so2 != NULL; so2 = next) {
248 next = TAILQ_NEXT(so2, so_qe);
249 if (so2->so_upcall == NULL) {
250 continue;
251 }
252 so2->so_upcall = NULL;
253 so2->so_upcallarg = NULL;
254 so2->so_options &= ~SO_ACCEPTFILTER;
255 so2->so_rcv.sb_flags &= ~SB_UPCALL;
256 soisconnected(so2);
257 }
258 af = so->so_accf;
259 afp = af->so_accept_filter;
260 if (afp != NULL && afp->accf_destroy != NULL) {
261 (*afp->accf_destroy)(so);
262 }
263 if (af->so_accept_filter_str != NULL) {
264 kmem_free(af->so_accept_filter_str,
265 sizeof(afa.af_name));
266 }
267 kmem_free(af, sizeof(*af));
268 so->so_accf = NULL;
269 atomic_dec_uint(&afp->accf_refcnt);
270 }
271 so->so_options &= ~SO_ACCEPTFILTER;
272 return 0;
273 }
274
275 /*
276 * setsockopt() for accept filters. Called with the socket unlocked,
277 * will always return it locked.
278 */
279 int
accept_filt_setopt(struct socket * so,const struct sockopt * sopt)280 accept_filt_setopt(struct socket *so, const struct sockopt *sopt)
281 {
282 struct accept_filter_arg afa;
283 struct accept_filter *afp;
284 struct so_accf *newaf;
285 int error;
286
287 accept_filter_init();
288
289 if (sopt == NULL || sopt->sopt_size == 0) {
290 solock(so);
291 return accept_filt_clear(so);
292 }
293
294 /*
295 * Pre-allocate any memory we may need later to avoid blocking at
296 * untimely moments. This does not optimize for invalid arguments.
297 */
298 error = sockopt_get(sopt, &afa, sizeof(afa));
299 if (error) {
300 solock(so);
301 return error;
302 }
303 afa.af_name[sizeof(afa.af_name)-1] = '\0';
304 afa.af_arg[sizeof(afa.af_arg)-1] = '\0';
305 afp = accept_filt_get(afa.af_name);
306 if (afp == NULL) {
307 solock(so);
308 return SET_ERROR(ENOENT);
309 }
310 /*
311 * Allocate the new accept filter instance storage. We may
312 * have to free it again later if we fail to attach it. If
313 * attached properly, 'newaf' is NULLed to avoid a free()
314 * while in use.
315 */
316 newaf = kmem_zalloc(sizeof(*newaf), KM_SLEEP);
317 if (afp->accf_create != NULL && afa.af_name[0] != '\0') {
318 /*
319 * FreeBSD did a variable-size allocation here
320 * with the actual string length from afa.af_name
321 * but it is so short, why bother tracking it?
322 * XXX as others have noted, this is an API mistake;
323 * XXX accept_filter_arg should have a mandatory namelen.
324 * XXX (but it's a bit too late to fix that now)
325 */
326 newaf->so_accept_filter_str =
327 kmem_alloc(sizeof(afa.af_name), KM_SLEEP);
328 strcpy(newaf->so_accept_filter_str, afa.af_name);
329 }
330
331 /*
332 * Require a listen socket; don't try to replace an existing filter
333 * without first removing it.
334 */
335 solock(so);
336 if ((so->so_options & SO_ACCEPTCONN) == 0 || so->so_accf != NULL) {
337 error = SET_ERROR(EINVAL);
338 goto out;
339 }
340
341 /*
342 * Invoke the accf_create() method of the filter if required. The
343 * socket lock is held over this call, so create methods for filters
344 * shouldn't block.
345 */
346 if (afp->accf_create != NULL) {
347 newaf->so_accept_filter_arg =
348 (*afp->accf_create)(so, afa.af_arg);
349 if (newaf->so_accept_filter_arg == NULL) {
350 error = SET_ERROR(EINVAL);
351 goto out;
352 }
353 }
354 newaf->so_accept_filter = afp;
355 so->so_accf = newaf;
356 so->so_options |= SO_ACCEPTFILTER;
357 newaf = NULL;
358 out:
359 if (newaf != NULL) {
360 if (newaf->so_accept_filter_str != NULL)
361 kmem_free(newaf->so_accept_filter_str,
362 sizeof(afa.af_name));
363 kmem_free(newaf, sizeof(*newaf));
364 atomic_dec_uint(&afp->accf_refcnt);
365 }
366 return error;
367 }
368