pf_table.c revision 1.13 1 1.13 lukem /* $NetBSD: pf_table.c,v 1.13 2007/12/11 11:08:22 lukem Exp $ */
2 1.6 peter /* $OpenBSD: pf_table.c,v 1.62 2004/12/07 18:02:04 mcbride Exp $ */
3 1.1 itojun
4 1.1 itojun /*
5 1.1 itojun * Copyright (c) 2002 Cedric Berger
6 1.1 itojun * All rights reserved.
7 1.1 itojun *
8 1.1 itojun * Redistribution and use in source and binary forms, with or without
9 1.1 itojun * modification, are permitted provided that the following conditions
10 1.1 itojun * are met:
11 1.1 itojun *
12 1.1 itojun * - Redistributions of source code must retain the above copyright
13 1.1 itojun * notice, this list of conditions and the following disclaimer.
14 1.1 itojun * - Redistributions in binary form must reproduce the above
15 1.1 itojun * copyright notice, this list of conditions and the following
16 1.1 itojun * disclaimer in the documentation and/or other materials provided
17 1.1 itojun * with the distribution.
18 1.1 itojun *
19 1.1 itojun * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 1.1 itojun * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 1.1 itojun * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
22 1.1 itojun * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
23 1.1 itojun * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
24 1.1 itojun * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
25 1.1 itojun * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26 1.1 itojun * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
27 1.1 itojun * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 1.1 itojun * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
29 1.1 itojun * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 1.1 itojun * POSSIBILITY OF SUCH DAMAGE.
31 1.1 itojun *
32 1.1 itojun */
33 1.1 itojun
34 1.13 lukem #include <sys/cdefs.h>
35 1.13 lukem __KERNEL_RCSID(0, "$NetBSD: pf_table.c,v 1.13 2007/12/11 11:08:22 lukem Exp $");
36 1.13 lukem
37 1.2 itojun #ifdef _KERNEL_OPT
38 1.2 itojun #include "opt_inet.h"
39 1.2 itojun #endif
40 1.2 itojun
41 1.1 itojun #include <sys/param.h>
42 1.1 itojun #include <sys/systm.h>
43 1.1 itojun #include <sys/socket.h>
44 1.1 itojun #include <sys/mbuf.h>
45 1.1 itojun #include <sys/kernel.h>
46 1.1 itojun
47 1.1 itojun #include <net/if.h>
48 1.1 itojun #include <net/route.h>
49 1.1 itojun #include <netinet/in.h>
50 1.2 itojun #ifdef __OpenBSD__
51 1.1 itojun #include <netinet/ip_ipsp.h>
52 1.2 itojun #endif
53 1.1 itojun #include <net/pfvar.h>
54 1.1 itojun
55 1.1 itojun #define ACCEPT_FLAGS(oklist) \
56 1.1 itojun do { \
57 1.1 itojun if ((flags & ~(oklist)) & \
58 1.1 itojun PFR_FLAG_ALLMASK) \
59 1.1 itojun return (EINVAL); \
60 1.1 itojun } while (0)
61 1.1 itojun
62 1.1 itojun #define COPYIN(from, to, size) \
63 1.1 itojun ((flags & PFR_FLAG_USERIOCTL) ? \
64 1.1 itojun copyin((from), (to), (size)) : \
65 1.1 itojun (bcopy((from), (to), (size)), 0))
66 1.1 itojun
67 1.1 itojun #define COPYOUT(from, to, size) \
68 1.1 itojun ((flags & PFR_FLAG_USERIOCTL) ? \
69 1.1 itojun copyout((from), (to), (size)) : \
70 1.1 itojun (bcopy((from), (to), (size)), 0))
71 1.1 itojun
72 1.1 itojun #define FILLIN_SIN(sin, addr) \
73 1.1 itojun do { \
74 1.1 itojun (sin).sin_len = sizeof(sin); \
75 1.1 itojun (sin).sin_family = AF_INET; \
76 1.1 itojun (sin).sin_addr = (addr); \
77 1.1 itojun } while (0)
78 1.1 itojun
79 1.1 itojun #define FILLIN_SIN6(sin6, addr) \
80 1.1 itojun do { \
81 1.1 itojun (sin6).sin6_len = sizeof(sin6); \
82 1.1 itojun (sin6).sin6_family = AF_INET6; \
83 1.1 itojun (sin6).sin6_addr = (addr); \
84 1.1 itojun } while (0)
85 1.1 itojun
86 1.1 itojun #define SWAP(type, a1, a2) \
87 1.1 itojun do { \
88 1.1 itojun type tmp = a1; \
89 1.1 itojun a1 = a2; \
90 1.1 itojun a2 = tmp; \
91 1.1 itojun } while (0)
92 1.1 itojun
93 1.1 itojun #define SUNION2PF(su, af) (((af)==AF_INET) ? \
94 1.1 itojun (struct pf_addr *)&(su)->sin.sin_addr : \
95 1.1 itojun (struct pf_addr *)&(su)->sin6.sin6_addr)
96 1.1 itojun
97 1.1 itojun #define AF_BITS(af) (((af)==AF_INET)?32:128)
98 1.1 itojun #define ADDR_NETWORK(ad) ((ad)->pfra_net < AF_BITS((ad)->pfra_af))
99 1.1 itojun #define KENTRY_NETWORK(ke) ((ke)->pfrke_net < AF_BITS((ke)->pfrke_af))
100 1.1 itojun #define KENTRY_RNF_ROOT(ke) \
101 1.1 itojun ((((struct radix_node *)(ke))->rn_flags & RNF_ROOT) != 0)
102 1.1 itojun
103 1.1 itojun #define NO_ADDRESSES (-1)
104 1.1 itojun #define ENQUEUE_UNMARKED_ONLY (1)
105 1.1 itojun #define INVERT_NEG_FLAG (1)
106 1.1 itojun
107 1.1 itojun struct pfr_walktree {
108 1.1 itojun enum pfrw_op {
109 1.1 itojun PFRW_MARK,
110 1.1 itojun PFRW_SWEEP,
111 1.1 itojun PFRW_ENQUEUE,
112 1.1 itojun PFRW_GET_ADDRS,
113 1.1 itojun PFRW_GET_ASTATS,
114 1.1 itojun PFRW_POOL_GET,
115 1.1 itojun PFRW_DYNADDR_UPDATE
116 1.1 itojun } pfrw_op;
117 1.1 itojun union {
118 1.1 itojun struct pfr_addr *pfrw1_addr;
119 1.1 itojun struct pfr_astats *pfrw1_astats;
120 1.1 itojun struct pfr_kentryworkq *pfrw1_workq;
121 1.1 itojun struct pfr_kentry *pfrw1_kentry;
122 1.1 itojun struct pfi_dynaddr *pfrw1_dyn;
123 1.1 itojun } pfrw_1;
124 1.1 itojun int pfrw_free;
125 1.1 itojun int pfrw_flags;
126 1.1 itojun };
127 1.1 itojun #define pfrw_addr pfrw_1.pfrw1_addr
128 1.1 itojun #define pfrw_astats pfrw_1.pfrw1_astats
129 1.1 itojun #define pfrw_workq pfrw_1.pfrw1_workq
130 1.1 itojun #define pfrw_kentry pfrw_1.pfrw1_kentry
131 1.1 itojun #define pfrw_dyn pfrw_1.pfrw1_dyn
132 1.1 itojun #define pfrw_cnt pfrw_free
133 1.1 itojun
134 1.1 itojun #define senderr(e) do { rv = (e); goto _bad; } while (0)
135 1.1 itojun
136 1.1 itojun struct pool pfr_ktable_pl;
137 1.1 itojun struct pool pfr_kentry_pl;
138 1.6 peter struct pool pfr_kentry_pl2;
139 1.1 itojun struct sockaddr_in pfr_sin;
140 1.1 itojun struct sockaddr_in6 pfr_sin6;
141 1.1 itojun union sockaddr_union pfr_mask;
142 1.1 itojun struct pf_addr pfr_ffaddr;
143 1.1 itojun
144 1.1 itojun void pfr_copyout_addr(struct pfr_addr *,
145 1.1 itojun struct pfr_kentry *ke);
146 1.1 itojun int pfr_validate_addr(struct pfr_addr *);
147 1.1 itojun void pfr_enqueue_addrs(struct pfr_ktable *,
148 1.1 itojun struct pfr_kentryworkq *, int *, int);
149 1.1 itojun void pfr_mark_addrs(struct pfr_ktable *);
150 1.1 itojun struct pfr_kentry *pfr_lookup_addr(struct pfr_ktable *,
151 1.1 itojun struct pfr_addr *, int);
152 1.6 peter struct pfr_kentry *pfr_create_kentry(struct pfr_addr *, int);
153 1.1 itojun void pfr_destroy_kentries(struct pfr_kentryworkq *);
154 1.1 itojun void pfr_destroy_kentry(struct pfr_kentry *);
155 1.1 itojun void pfr_insert_kentries(struct pfr_ktable *,
156 1.1 itojun struct pfr_kentryworkq *, long);
157 1.1 itojun void pfr_remove_kentries(struct pfr_ktable *,
158 1.1 itojun struct pfr_kentryworkq *);
159 1.1 itojun void pfr_clstats_kentries(struct pfr_kentryworkq *, long,
160 1.1 itojun int);
161 1.1 itojun void pfr_reset_feedback(struct pfr_addr *, int, int);
162 1.1 itojun void pfr_prepare_network(union sockaddr_union *, int, int);
163 1.1 itojun int pfr_route_kentry(struct pfr_ktable *,
164 1.1 itojun struct pfr_kentry *);
165 1.1 itojun int pfr_unroute_kentry(struct pfr_ktable *,
166 1.1 itojun struct pfr_kentry *);
167 1.1 itojun int pfr_walktree(struct radix_node *, void *);
168 1.1 itojun int pfr_validate_table(struct pfr_table *, int, int);
169 1.6 peter int pfr_fix_anchor(char *);
170 1.1 itojun void pfr_commit_ktable(struct pfr_ktable *, long);
171 1.1 itojun void pfr_insert_ktables(struct pfr_ktableworkq *);
172 1.1 itojun void pfr_insert_ktable(struct pfr_ktable *);
173 1.1 itojun void pfr_setflags_ktables(struct pfr_ktableworkq *);
174 1.1 itojun void pfr_setflags_ktable(struct pfr_ktable *, int);
175 1.1 itojun void pfr_clstats_ktables(struct pfr_ktableworkq *, long,
176 1.1 itojun int);
177 1.1 itojun void pfr_clstats_ktable(struct pfr_ktable *, long, int);
178 1.1 itojun struct pfr_ktable *pfr_create_ktable(struct pfr_table *, long, int);
179 1.1 itojun void pfr_destroy_ktables(struct pfr_ktableworkq *, int);
180 1.1 itojun void pfr_destroy_ktable(struct pfr_ktable *, int);
181 1.1 itojun int pfr_ktable_compare(struct pfr_ktable *,
182 1.1 itojun struct pfr_ktable *);
183 1.1 itojun struct pfr_ktable *pfr_lookup_table(struct pfr_table *);
184 1.1 itojun void pfr_clean_node_mask(struct pfr_ktable *,
185 1.1 itojun struct pfr_kentryworkq *);
186 1.1 itojun int pfr_table_count(struct pfr_table *, int);
187 1.1 itojun int pfr_skip_table(struct pfr_table *,
188 1.1 itojun struct pfr_ktable *, int);
189 1.1 itojun struct pfr_kentry *pfr_kentry_byidx(struct pfr_ktable *, int, int);
190 1.1 itojun
191 1.1 itojun RB_PROTOTYPE(pfr_ktablehead, pfr_ktable, pfrkt_tree, pfr_ktable_compare);
192 1.1 itojun RB_GENERATE(pfr_ktablehead, pfr_ktable, pfrkt_tree, pfr_ktable_compare);
193 1.1 itojun
194 1.1 itojun struct pfr_ktablehead pfr_ktables;
195 1.1 itojun struct pfr_table pfr_nulltable;
196 1.1 itojun int pfr_ktable_cnt;
197 1.1 itojun
198 1.1 itojun void
199 1.1 itojun pfr_initialize(void)
200 1.1 itojun {
201 1.12 ad #ifdef __NetBSD__
202 1.12 ad pool_init(&pfr_ktable_pl, sizeof(struct pfr_ktable), 0, 0, 0,
203 1.12 ad "pfrktable", &pool_allocator_oldnointr, IPL_NONE);
204 1.12 ad pool_init(&pfr_kentry_pl, sizeof(struct pfr_kentry), 0, 0, 0,
205 1.12 ad "pfrkentry", &pool_allocator_oldnointr, IPL_NONE);
206 1.12 ad pool_init(&pfr_kentry_pl2, sizeof(struct pfr_kentry), 0, 0, 0,
207 1.12 ad "pfrkentry2", NULL, IPL_SOFTNET);
208 1.12 ad #else
209 1.1 itojun pool_init(&pfr_ktable_pl, sizeof(struct pfr_ktable), 0, 0, 0,
210 1.5 yamt "pfrktable", &pool_allocator_oldnointr);
211 1.1 itojun pool_init(&pfr_kentry_pl, sizeof(struct pfr_kentry), 0, 0, 0,
212 1.5 yamt "pfrkentry", &pool_allocator_oldnointr);
213 1.6 peter pool_init(&pfr_kentry_pl2, sizeof(struct pfr_kentry), 0, 0, 0,
214 1.6 peter "pfrkentry2", NULL);
215 1.12 ad #endif
216 1.1 itojun
217 1.1 itojun pfr_sin.sin_len = sizeof(pfr_sin);
218 1.1 itojun pfr_sin.sin_family = AF_INET;
219 1.1 itojun pfr_sin6.sin6_len = sizeof(pfr_sin6);
220 1.1 itojun pfr_sin6.sin6_family = AF_INET6;
221 1.1 itojun
222 1.1 itojun memset(&pfr_ffaddr, 0xff, sizeof(pfr_ffaddr));
223 1.1 itojun }
224 1.1 itojun
225 1.3 itojun #ifdef _LKM
226 1.3 itojun void
227 1.3 itojun pfr_destroy(void)
228 1.3 itojun {
229 1.3 itojun pool_destroy(&pfr_ktable_pl);
230 1.3 itojun pool_destroy(&pfr_kentry_pl);
231 1.6 peter pool_destroy(&pfr_kentry_pl2);
232 1.3 itojun }
233 1.3 itojun #endif
234 1.3 itojun
235 1.1 itojun int
236 1.1 itojun pfr_clr_addrs(struct pfr_table *tbl, int *ndel, int flags)
237 1.1 itojun {
238 1.1 itojun struct pfr_ktable *kt;
239 1.1 itojun struct pfr_kentryworkq workq;
240 1.2 itojun int s = 0;
241 1.1 itojun
242 1.1 itojun ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY);
243 1.1 itojun if (pfr_validate_table(tbl, 0, flags & PFR_FLAG_USERIOCTL))
244 1.1 itojun return (EINVAL);
245 1.1 itojun kt = pfr_lookup_table(tbl);
246 1.1 itojun if (kt == NULL || !(kt->pfrkt_flags & PFR_TFLAG_ACTIVE))
247 1.1 itojun return (ESRCH);
248 1.1 itojun if (kt->pfrkt_flags & PFR_TFLAG_CONST)
249 1.1 itojun return (EPERM);
250 1.1 itojun pfr_enqueue_addrs(kt, &workq, ndel, 0);
251 1.1 itojun
252 1.1 itojun if (!(flags & PFR_FLAG_DUMMY)) {
253 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
254 1.1 itojun s = splsoftnet();
255 1.1 itojun pfr_remove_kentries(kt, &workq);
256 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
257 1.1 itojun splx(s);
258 1.1 itojun if (kt->pfrkt_cnt) {
259 1.1 itojun printf("pfr_clr_addrs: corruption detected (%d).\n",
260 1.1 itojun kt->pfrkt_cnt);
261 1.1 itojun kt->pfrkt_cnt = 0;
262 1.1 itojun }
263 1.1 itojun }
264 1.1 itojun return (0);
265 1.1 itojun }
266 1.1 itojun
267 1.1 itojun int
268 1.1 itojun pfr_add_addrs(struct pfr_table *tbl, struct pfr_addr *addr, int size,
269 1.1 itojun int *nadd, int flags)
270 1.1 itojun {
271 1.1 itojun struct pfr_ktable *kt, *tmpkt;
272 1.1 itojun struct pfr_kentryworkq workq;
273 1.1 itojun struct pfr_kentry *p, *q;
274 1.1 itojun struct pfr_addr ad;
275 1.5 yamt int i, rv, s = 0 /* XXX gcc */, xadd = 0;
276 1.5 yamt long tzero = time_second;
277 1.1 itojun
278 1.1 itojun ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY+PFR_FLAG_FEEDBACK);
279 1.1 itojun if (pfr_validate_table(tbl, 0, flags & PFR_FLAG_USERIOCTL))
280 1.1 itojun return (EINVAL);
281 1.1 itojun kt = pfr_lookup_table(tbl);
282 1.1 itojun if (kt == NULL || !(kt->pfrkt_flags & PFR_TFLAG_ACTIVE))
283 1.1 itojun return (ESRCH);
284 1.1 itojun if (kt->pfrkt_flags & PFR_TFLAG_CONST)
285 1.1 itojun return (EPERM);
286 1.1 itojun tmpkt = pfr_create_ktable(&pfr_nulltable, 0, 0);
287 1.1 itojun if (tmpkt == NULL)
288 1.1 itojun return (ENOMEM);
289 1.1 itojun SLIST_INIT(&workq);
290 1.1 itojun for (i = 0; i < size; i++) {
291 1.1 itojun if (COPYIN(addr+i, &ad, sizeof(ad)))
292 1.1 itojun senderr(EFAULT);
293 1.1 itojun if (pfr_validate_addr(&ad))
294 1.1 itojun senderr(EINVAL);
295 1.1 itojun p = pfr_lookup_addr(kt, &ad, 1);
296 1.1 itojun q = pfr_lookup_addr(tmpkt, &ad, 1);
297 1.1 itojun if (flags & PFR_FLAG_FEEDBACK) {
298 1.1 itojun if (q != NULL)
299 1.1 itojun ad.pfra_fback = PFR_FB_DUPLICATE;
300 1.1 itojun else if (p == NULL)
301 1.1 itojun ad.pfra_fback = PFR_FB_ADDED;
302 1.1 itojun else if (p->pfrke_not != ad.pfra_not)
303 1.1 itojun ad.pfra_fback = PFR_FB_CONFLICT;
304 1.1 itojun else
305 1.1 itojun ad.pfra_fback = PFR_FB_NONE;
306 1.1 itojun }
307 1.1 itojun if (p == NULL && q == NULL) {
308 1.6 peter p = pfr_create_kentry(&ad, 0);
309 1.1 itojun if (p == NULL)
310 1.1 itojun senderr(ENOMEM);
311 1.1 itojun if (pfr_route_kentry(tmpkt, p)) {
312 1.1 itojun pfr_destroy_kentry(p);
313 1.1 itojun ad.pfra_fback = PFR_FB_NONE;
314 1.1 itojun } else {
315 1.1 itojun SLIST_INSERT_HEAD(&workq, p, pfrke_workq);
316 1.1 itojun xadd++;
317 1.1 itojun }
318 1.1 itojun }
319 1.1 itojun if (flags & PFR_FLAG_FEEDBACK)
320 1.1 itojun if (COPYOUT(&ad, addr+i, sizeof(ad)))
321 1.1 itojun senderr(EFAULT);
322 1.1 itojun }
323 1.1 itojun pfr_clean_node_mask(tmpkt, &workq);
324 1.1 itojun if (!(flags & PFR_FLAG_DUMMY)) {
325 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
326 1.1 itojun s = splsoftnet();
327 1.1 itojun pfr_insert_kentries(kt, &workq, tzero);
328 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
329 1.1 itojun splx(s);
330 1.1 itojun } else
331 1.1 itojun pfr_destroy_kentries(&workq);
332 1.1 itojun if (nadd != NULL)
333 1.1 itojun *nadd = xadd;
334 1.1 itojun pfr_destroy_ktable(tmpkt, 0);
335 1.1 itojun return (0);
336 1.1 itojun _bad:
337 1.1 itojun pfr_clean_node_mask(tmpkt, &workq);
338 1.1 itojun pfr_destroy_kentries(&workq);
339 1.1 itojun if (flags & PFR_FLAG_FEEDBACK)
340 1.1 itojun pfr_reset_feedback(addr, size, flags);
341 1.1 itojun pfr_destroy_ktable(tmpkt, 0);
342 1.1 itojun return (rv);
343 1.1 itojun }
344 1.1 itojun
345 1.1 itojun int
346 1.1 itojun pfr_del_addrs(struct pfr_table *tbl, struct pfr_addr *addr, int size,
347 1.1 itojun int *ndel, int flags)
348 1.1 itojun {
349 1.1 itojun struct pfr_ktable *kt;
350 1.1 itojun struct pfr_kentryworkq workq;
351 1.1 itojun struct pfr_kentry *p;
352 1.1 itojun struct pfr_addr ad;
353 1.5 yamt int i, rv, s = 0 /* XXX gcc */, xdel = 0, log = 1;
354 1.1 itojun
355 1.1 itojun ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY+PFR_FLAG_FEEDBACK);
356 1.1 itojun if (pfr_validate_table(tbl, 0, flags & PFR_FLAG_USERIOCTL))
357 1.1 itojun return (EINVAL);
358 1.1 itojun kt = pfr_lookup_table(tbl);
359 1.1 itojun if (kt == NULL || !(kt->pfrkt_flags & PFR_TFLAG_ACTIVE))
360 1.1 itojun return (ESRCH);
361 1.1 itojun if (kt->pfrkt_flags & PFR_TFLAG_CONST)
362 1.1 itojun return (EPERM);
363 1.5 yamt /*
364 1.5 yamt * there are two algorithms to choose from here.
365 1.5 yamt * with:
366 1.5 yamt * n: number of addresses to delete
367 1.5 yamt * N: number of addresses in the table
368 1.5 yamt *
369 1.5 yamt * one is O(N) and is better for large 'n'
370 1.5 yamt * one is O(n*LOG(N)) and is better for small 'n'
371 1.5 yamt *
372 1.5 yamt * following code try to decide which one is best.
373 1.5 yamt */
374 1.5 yamt for (i = kt->pfrkt_cnt; i > 0; i >>= 1)
375 1.5 yamt log++;
376 1.5 yamt if (size > kt->pfrkt_cnt/log) {
377 1.5 yamt /* full table scan */
378 1.5 yamt pfr_mark_addrs(kt);
379 1.5 yamt } else {
380 1.5 yamt /* iterate over addresses to delete */
381 1.5 yamt for (i = 0; i < size; i++) {
382 1.5 yamt if (COPYIN(addr+i, &ad, sizeof(ad)))
383 1.5 yamt return (EFAULT);
384 1.5 yamt if (pfr_validate_addr(&ad))
385 1.5 yamt return (EINVAL);
386 1.5 yamt p = pfr_lookup_addr(kt, &ad, 1);
387 1.5 yamt if (p != NULL)
388 1.5 yamt p->pfrke_mark = 0;
389 1.5 yamt }
390 1.5 yamt }
391 1.1 itojun SLIST_INIT(&workq);
392 1.1 itojun for (i = 0; i < size; i++) {
393 1.1 itojun if (COPYIN(addr+i, &ad, sizeof(ad)))
394 1.1 itojun senderr(EFAULT);
395 1.1 itojun if (pfr_validate_addr(&ad))
396 1.1 itojun senderr(EINVAL);
397 1.1 itojun p = pfr_lookup_addr(kt, &ad, 1);
398 1.1 itojun if (flags & PFR_FLAG_FEEDBACK) {
399 1.1 itojun if (p == NULL)
400 1.1 itojun ad.pfra_fback = PFR_FB_NONE;
401 1.1 itojun else if (p->pfrke_not != ad.pfra_not)
402 1.1 itojun ad.pfra_fback = PFR_FB_CONFLICT;
403 1.1 itojun else if (p->pfrke_mark)
404 1.1 itojun ad.pfra_fback = PFR_FB_DUPLICATE;
405 1.1 itojun else
406 1.1 itojun ad.pfra_fback = PFR_FB_DELETED;
407 1.1 itojun }
408 1.1 itojun if (p != NULL && p->pfrke_not == ad.pfra_not &&
409 1.1 itojun !p->pfrke_mark) {
410 1.1 itojun p->pfrke_mark = 1;
411 1.1 itojun SLIST_INSERT_HEAD(&workq, p, pfrke_workq);
412 1.1 itojun xdel++;
413 1.1 itojun }
414 1.1 itojun if (flags & PFR_FLAG_FEEDBACK)
415 1.1 itojun if (COPYOUT(&ad, addr+i, sizeof(ad)))
416 1.1 itojun senderr(EFAULT);
417 1.1 itojun }
418 1.1 itojun if (!(flags & PFR_FLAG_DUMMY)) {
419 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
420 1.1 itojun s = splsoftnet();
421 1.1 itojun pfr_remove_kentries(kt, &workq);
422 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
423 1.1 itojun splx(s);
424 1.1 itojun }
425 1.1 itojun if (ndel != NULL)
426 1.1 itojun *ndel = xdel;
427 1.1 itojun return (0);
428 1.1 itojun _bad:
429 1.1 itojun if (flags & PFR_FLAG_FEEDBACK)
430 1.1 itojun pfr_reset_feedback(addr, size, flags);
431 1.1 itojun return (rv);
432 1.1 itojun }
433 1.1 itojun
434 1.1 itojun int
435 1.1 itojun pfr_set_addrs(struct pfr_table *tbl, struct pfr_addr *addr, int size,
436 1.1 itojun int *size2, int *nadd, int *ndel, int *nchange, int flags)
437 1.1 itojun {
438 1.1 itojun struct pfr_ktable *kt, *tmpkt;
439 1.1 itojun struct pfr_kentryworkq addq, delq, changeq;
440 1.1 itojun struct pfr_kentry *p, *q;
441 1.1 itojun struct pfr_addr ad;
442 1.5 yamt int i, rv, s = 0 /* XXX gcc */, xadd = 0, xdel = 0,
443 1.5 yamt xchange = 0;
444 1.5 yamt long tzero = time_second;
445 1.1 itojun
446 1.1 itojun ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY+PFR_FLAG_FEEDBACK);
447 1.1 itojun if (pfr_validate_table(tbl, 0, flags & PFR_FLAG_USERIOCTL))
448 1.1 itojun return (EINVAL);
449 1.1 itojun kt = pfr_lookup_table(tbl);
450 1.1 itojun if (kt == NULL || !(kt->pfrkt_flags & PFR_TFLAG_ACTIVE))
451 1.1 itojun return (ESRCH);
452 1.1 itojun if (kt->pfrkt_flags & PFR_TFLAG_CONST)
453 1.1 itojun return (EPERM);
454 1.1 itojun tmpkt = pfr_create_ktable(&pfr_nulltable, 0, 0);
455 1.1 itojun if (tmpkt == NULL)
456 1.1 itojun return (ENOMEM);
457 1.1 itojun pfr_mark_addrs(kt);
458 1.1 itojun SLIST_INIT(&addq);
459 1.1 itojun SLIST_INIT(&delq);
460 1.1 itojun SLIST_INIT(&changeq);
461 1.1 itojun for (i = 0; i < size; i++) {
462 1.1 itojun if (COPYIN(addr+i, &ad, sizeof(ad)))
463 1.1 itojun senderr(EFAULT);
464 1.1 itojun if (pfr_validate_addr(&ad))
465 1.1 itojun senderr(EINVAL);
466 1.1 itojun ad.pfra_fback = PFR_FB_NONE;
467 1.1 itojun p = pfr_lookup_addr(kt, &ad, 1);
468 1.1 itojun if (p != NULL) {
469 1.1 itojun if (p->pfrke_mark) {
470 1.1 itojun ad.pfra_fback = PFR_FB_DUPLICATE;
471 1.1 itojun goto _skip;
472 1.1 itojun }
473 1.1 itojun p->pfrke_mark = 1;
474 1.1 itojun if (p->pfrke_not != ad.pfra_not) {
475 1.1 itojun SLIST_INSERT_HEAD(&changeq, p, pfrke_workq);
476 1.1 itojun ad.pfra_fback = PFR_FB_CHANGED;
477 1.1 itojun xchange++;
478 1.1 itojun }
479 1.1 itojun } else {
480 1.1 itojun q = pfr_lookup_addr(tmpkt, &ad, 1);
481 1.1 itojun if (q != NULL) {
482 1.1 itojun ad.pfra_fback = PFR_FB_DUPLICATE;
483 1.1 itojun goto _skip;
484 1.1 itojun }
485 1.6 peter p = pfr_create_kentry(&ad, 0);
486 1.1 itojun if (p == NULL)
487 1.1 itojun senderr(ENOMEM);
488 1.1 itojun if (pfr_route_kentry(tmpkt, p)) {
489 1.1 itojun pfr_destroy_kentry(p);
490 1.1 itojun ad.pfra_fback = PFR_FB_NONE;
491 1.1 itojun } else {
492 1.1 itojun SLIST_INSERT_HEAD(&addq, p, pfrke_workq);
493 1.1 itojun ad.pfra_fback = PFR_FB_ADDED;
494 1.1 itojun xadd++;
495 1.1 itojun }
496 1.1 itojun }
497 1.1 itojun _skip:
498 1.1 itojun if (flags & PFR_FLAG_FEEDBACK)
499 1.1 itojun if (COPYOUT(&ad, addr+i, sizeof(ad)))
500 1.1 itojun senderr(EFAULT);
501 1.1 itojun }
502 1.1 itojun pfr_enqueue_addrs(kt, &delq, &xdel, ENQUEUE_UNMARKED_ONLY);
503 1.1 itojun if ((flags & PFR_FLAG_FEEDBACK) && *size2) {
504 1.1 itojun if (*size2 < size+xdel) {
505 1.1 itojun *size2 = size+xdel;
506 1.1 itojun senderr(0);
507 1.1 itojun }
508 1.1 itojun i = 0;
509 1.1 itojun SLIST_FOREACH(p, &delq, pfrke_workq) {
510 1.1 itojun pfr_copyout_addr(&ad, p);
511 1.1 itojun ad.pfra_fback = PFR_FB_DELETED;
512 1.1 itojun if (COPYOUT(&ad, addr+size+i, sizeof(ad)))
513 1.1 itojun senderr(EFAULT);
514 1.1 itojun i++;
515 1.1 itojun }
516 1.1 itojun }
517 1.1 itojun pfr_clean_node_mask(tmpkt, &addq);
518 1.1 itojun if (!(flags & PFR_FLAG_DUMMY)) {
519 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
520 1.1 itojun s = splsoftnet();
521 1.1 itojun pfr_insert_kentries(kt, &addq, tzero);
522 1.1 itojun pfr_remove_kentries(kt, &delq);
523 1.1 itojun pfr_clstats_kentries(&changeq, tzero, INVERT_NEG_FLAG);
524 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
525 1.1 itojun splx(s);
526 1.1 itojun } else
527 1.1 itojun pfr_destroy_kentries(&addq);
528 1.1 itojun if (nadd != NULL)
529 1.1 itojun *nadd = xadd;
530 1.1 itojun if (ndel != NULL)
531 1.1 itojun *ndel = xdel;
532 1.1 itojun if (nchange != NULL)
533 1.1 itojun *nchange = xchange;
534 1.1 itojun if ((flags & PFR_FLAG_FEEDBACK) && size2)
535 1.1 itojun *size2 = size+xdel;
536 1.1 itojun pfr_destroy_ktable(tmpkt, 0);
537 1.1 itojun return (0);
538 1.1 itojun _bad:
539 1.1 itojun pfr_clean_node_mask(tmpkt, &addq);
540 1.1 itojun pfr_destroy_kentries(&addq);
541 1.1 itojun if (flags & PFR_FLAG_FEEDBACK)
542 1.1 itojun pfr_reset_feedback(addr, size, flags);
543 1.1 itojun pfr_destroy_ktable(tmpkt, 0);
544 1.1 itojun return (rv);
545 1.1 itojun }
546 1.1 itojun
547 1.1 itojun int
548 1.1 itojun pfr_tst_addrs(struct pfr_table *tbl, struct pfr_addr *addr, int size,
549 1.1 itojun int *nmatch, int flags)
550 1.1 itojun {
551 1.1 itojun struct pfr_ktable *kt;
552 1.1 itojun struct pfr_kentry *p;
553 1.1 itojun struct pfr_addr ad;
554 1.1 itojun int i, xmatch = 0;
555 1.1 itojun
556 1.1 itojun ACCEPT_FLAGS(PFR_FLAG_REPLACE);
557 1.1 itojun if (pfr_validate_table(tbl, 0, 0))
558 1.1 itojun return (EINVAL);
559 1.1 itojun kt = pfr_lookup_table(tbl);
560 1.1 itojun if (kt == NULL || !(kt->pfrkt_flags & PFR_TFLAG_ACTIVE))
561 1.1 itojun return (ESRCH);
562 1.1 itojun
563 1.1 itojun for (i = 0; i < size; i++) {
564 1.1 itojun if (COPYIN(addr+i, &ad, sizeof(ad)))
565 1.1 itojun return (EFAULT);
566 1.1 itojun if (pfr_validate_addr(&ad))
567 1.1 itojun return (EINVAL);
568 1.1 itojun if (ADDR_NETWORK(&ad))
569 1.1 itojun return (EINVAL);
570 1.1 itojun p = pfr_lookup_addr(kt, &ad, 0);
571 1.1 itojun if (flags & PFR_FLAG_REPLACE)
572 1.1 itojun pfr_copyout_addr(&ad, p);
573 1.1 itojun ad.pfra_fback = (p == NULL) ? PFR_FB_NONE :
574 1.1 itojun (p->pfrke_not ? PFR_FB_NOTMATCH : PFR_FB_MATCH);
575 1.1 itojun if (p != NULL && !p->pfrke_not)
576 1.1 itojun xmatch++;
577 1.1 itojun if (COPYOUT(&ad, addr+i, sizeof(ad)))
578 1.1 itojun return (EFAULT);
579 1.1 itojun }
580 1.1 itojun if (nmatch != NULL)
581 1.1 itojun *nmatch = xmatch;
582 1.1 itojun return (0);
583 1.1 itojun }
584 1.1 itojun
585 1.1 itojun int
586 1.1 itojun pfr_get_addrs(struct pfr_table *tbl, struct pfr_addr *addr, int *size,
587 1.1 itojun int flags)
588 1.1 itojun {
589 1.1 itojun struct pfr_ktable *kt;
590 1.1 itojun struct pfr_walktree w;
591 1.1 itojun int rv;
592 1.1 itojun
593 1.1 itojun ACCEPT_FLAGS(0);
594 1.1 itojun if (pfr_validate_table(tbl, 0, 0))
595 1.1 itojun return (EINVAL);
596 1.1 itojun kt = pfr_lookup_table(tbl);
597 1.1 itojun if (kt == NULL || !(kt->pfrkt_flags & PFR_TFLAG_ACTIVE))
598 1.1 itojun return (ESRCH);
599 1.1 itojun if (kt->pfrkt_cnt > *size) {
600 1.1 itojun *size = kt->pfrkt_cnt;
601 1.1 itojun return (0);
602 1.1 itojun }
603 1.1 itojun
604 1.1 itojun bzero(&w, sizeof(w));
605 1.1 itojun w.pfrw_op = PFRW_GET_ADDRS;
606 1.1 itojun w.pfrw_addr = addr;
607 1.1 itojun w.pfrw_free = kt->pfrkt_cnt;
608 1.1 itojun w.pfrw_flags = flags;
609 1.1 itojun rv = rn_walktree(kt->pfrkt_ip4, pfr_walktree, &w);
610 1.1 itojun if (!rv)
611 1.1 itojun rv = rn_walktree(kt->pfrkt_ip6, pfr_walktree, &w);
612 1.1 itojun if (rv)
613 1.1 itojun return (rv);
614 1.1 itojun
615 1.1 itojun if (w.pfrw_free) {
616 1.1 itojun printf("pfr_get_addrs: corruption detected (%d).\n",
617 1.1 itojun w.pfrw_free);
618 1.1 itojun return (ENOTTY);
619 1.1 itojun }
620 1.1 itojun *size = kt->pfrkt_cnt;
621 1.1 itojun return (0);
622 1.1 itojun }
623 1.1 itojun
624 1.1 itojun int
625 1.1 itojun pfr_get_astats(struct pfr_table *tbl, struct pfr_astats *addr, int *size,
626 1.1 itojun int flags)
627 1.1 itojun {
628 1.1 itojun struct pfr_ktable *kt;
629 1.1 itojun struct pfr_walktree w;
630 1.1 itojun struct pfr_kentryworkq workq;
631 1.5 yamt int rv, s = 0 /* XXX gcc */;
632 1.5 yamt long tzero = time_second;
633 1.1 itojun
634 1.1 itojun ACCEPT_FLAGS(PFR_FLAG_ATOMIC); /* XXX PFR_FLAG_CLSTATS disabled */
635 1.1 itojun if (pfr_validate_table(tbl, 0, 0))
636 1.1 itojun return (EINVAL);
637 1.1 itojun kt = pfr_lookup_table(tbl);
638 1.1 itojun if (kt == NULL || !(kt->pfrkt_flags & PFR_TFLAG_ACTIVE))
639 1.1 itojun return (ESRCH);
640 1.1 itojun if (kt->pfrkt_cnt > *size) {
641 1.1 itojun *size = kt->pfrkt_cnt;
642 1.1 itojun return (0);
643 1.1 itojun }
644 1.1 itojun
645 1.1 itojun bzero(&w, sizeof(w));
646 1.1 itojun w.pfrw_op = PFRW_GET_ASTATS;
647 1.1 itojun w.pfrw_astats = addr;
648 1.1 itojun w.pfrw_free = kt->pfrkt_cnt;
649 1.1 itojun w.pfrw_flags = flags;
650 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
651 1.1 itojun s = splsoftnet();
652 1.1 itojun rv = rn_walktree(kt->pfrkt_ip4, pfr_walktree, &w);
653 1.1 itojun if (!rv)
654 1.1 itojun rv = rn_walktree(kt->pfrkt_ip6, pfr_walktree, &w);
655 1.1 itojun if (!rv && (flags & PFR_FLAG_CLSTATS)) {
656 1.1 itojun pfr_enqueue_addrs(kt, &workq, NULL, 0);
657 1.1 itojun pfr_clstats_kentries(&workq, tzero, 0);
658 1.1 itojun }
659 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
660 1.1 itojun splx(s);
661 1.1 itojun if (rv)
662 1.1 itojun return (rv);
663 1.1 itojun
664 1.1 itojun if (w.pfrw_free) {
665 1.1 itojun printf("pfr_get_astats: corruption detected (%d).\n",
666 1.1 itojun w.pfrw_free);
667 1.1 itojun return (ENOTTY);
668 1.1 itojun }
669 1.1 itojun *size = kt->pfrkt_cnt;
670 1.1 itojun return (0);
671 1.1 itojun }
672 1.1 itojun
673 1.1 itojun int
674 1.1 itojun pfr_clr_astats(struct pfr_table *tbl, struct pfr_addr *addr, int size,
675 1.1 itojun int *nzero, int flags)
676 1.1 itojun {
677 1.1 itojun struct pfr_ktable *kt;
678 1.1 itojun struct pfr_kentryworkq workq;
679 1.1 itojun struct pfr_kentry *p;
680 1.1 itojun struct pfr_addr ad;
681 1.2 itojun int i, rv, s = 0, xzero = 0;
682 1.1 itojun
683 1.1 itojun ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY+PFR_FLAG_FEEDBACK);
684 1.1 itojun if (pfr_validate_table(tbl, 0, 0))
685 1.1 itojun return (EINVAL);
686 1.1 itojun kt = pfr_lookup_table(tbl);
687 1.1 itojun if (kt == NULL || !(kt->pfrkt_flags & PFR_TFLAG_ACTIVE))
688 1.1 itojun return (ESRCH);
689 1.1 itojun SLIST_INIT(&workq);
690 1.1 itojun for (i = 0; i < size; i++) {
691 1.1 itojun if (COPYIN(addr+i, &ad, sizeof(ad)))
692 1.1 itojun senderr(EFAULT);
693 1.1 itojun if (pfr_validate_addr(&ad))
694 1.1 itojun senderr(EINVAL);
695 1.1 itojun p = pfr_lookup_addr(kt, &ad, 1);
696 1.1 itojun if (flags & PFR_FLAG_FEEDBACK) {
697 1.1 itojun ad.pfra_fback = (p != NULL) ?
698 1.1 itojun PFR_FB_CLEARED : PFR_FB_NONE;
699 1.1 itojun if (COPYOUT(&ad, addr+i, sizeof(ad)))
700 1.1 itojun senderr(EFAULT);
701 1.1 itojun }
702 1.1 itojun if (p != NULL) {
703 1.1 itojun SLIST_INSERT_HEAD(&workq, p, pfrke_workq);
704 1.1 itojun xzero++;
705 1.1 itojun }
706 1.1 itojun }
707 1.1 itojun
708 1.1 itojun if (!(flags & PFR_FLAG_DUMMY)) {
709 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
710 1.1 itojun s = splsoftnet();
711 1.1 itojun pfr_clstats_kentries(&workq, 0, 0);
712 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
713 1.1 itojun splx(s);
714 1.1 itojun }
715 1.1 itojun if (nzero != NULL)
716 1.1 itojun *nzero = xzero;
717 1.1 itojun return (0);
718 1.1 itojun _bad:
719 1.1 itojun if (flags & PFR_FLAG_FEEDBACK)
720 1.1 itojun pfr_reset_feedback(addr, size, flags);
721 1.1 itojun return (rv);
722 1.1 itojun }
723 1.1 itojun
724 1.1 itojun int
725 1.1 itojun pfr_validate_addr(struct pfr_addr *ad)
726 1.1 itojun {
727 1.1 itojun int i;
728 1.1 itojun
729 1.1 itojun switch (ad->pfra_af) {
730 1.5 yamt #ifdef INET
731 1.1 itojun case AF_INET:
732 1.1 itojun if (ad->pfra_net > 32)
733 1.1 itojun return (-1);
734 1.1 itojun break;
735 1.5 yamt #endif /* INET */
736 1.5 yamt #ifdef INET6
737 1.1 itojun case AF_INET6:
738 1.1 itojun if (ad->pfra_net > 128)
739 1.1 itojun return (-1);
740 1.1 itojun break;
741 1.5 yamt #endif /* INET6 */
742 1.1 itojun default:
743 1.1 itojun return (-1);
744 1.1 itojun }
745 1.1 itojun if (ad->pfra_net < 128 &&
746 1.11 christos (((char *)ad)[ad->pfra_net/8] & (0xFF >> (ad->pfra_net%8))))
747 1.1 itojun return (-1);
748 1.1 itojun for (i = (ad->pfra_net+7)/8; i < sizeof(ad->pfra_u); i++)
749 1.11 christos if (((char *)ad)[i])
750 1.1 itojun return (-1);
751 1.1 itojun if (ad->pfra_not && ad->pfra_not != 1)
752 1.1 itojun return (-1);
753 1.1 itojun if (ad->pfra_fback)
754 1.1 itojun return (-1);
755 1.1 itojun return (0);
756 1.1 itojun }
757 1.1 itojun
758 1.1 itojun void
759 1.1 itojun pfr_enqueue_addrs(struct pfr_ktable *kt, struct pfr_kentryworkq *workq,
760 1.1 itojun int *naddr, int sweep)
761 1.1 itojun {
762 1.1 itojun struct pfr_walktree w;
763 1.1 itojun
764 1.1 itojun SLIST_INIT(workq);
765 1.1 itojun bzero(&w, sizeof(w));
766 1.1 itojun w.pfrw_op = sweep ? PFRW_SWEEP : PFRW_ENQUEUE;
767 1.1 itojun w.pfrw_workq = workq;
768 1.1 itojun if (kt->pfrkt_ip4 != NULL)
769 1.1 itojun if (rn_walktree(kt->pfrkt_ip4, pfr_walktree, &w))
770 1.1 itojun printf("pfr_enqueue_addrs: IPv4 walktree failed.\n");
771 1.1 itojun if (kt->pfrkt_ip6 != NULL)
772 1.1 itojun if (rn_walktree(kt->pfrkt_ip6, pfr_walktree, &w))
773 1.1 itojun printf("pfr_enqueue_addrs: IPv6 walktree failed.\n");
774 1.1 itojun if (naddr != NULL)
775 1.1 itojun *naddr = w.pfrw_cnt;
776 1.1 itojun }
777 1.1 itojun
778 1.1 itojun void
779 1.1 itojun pfr_mark_addrs(struct pfr_ktable *kt)
780 1.1 itojun {
781 1.1 itojun struct pfr_walktree w;
782 1.1 itojun
783 1.1 itojun bzero(&w, sizeof(w));
784 1.1 itojun w.pfrw_op = PFRW_MARK;
785 1.1 itojun if (rn_walktree(kt->pfrkt_ip4, pfr_walktree, &w))
786 1.1 itojun printf("pfr_mark_addrs: IPv4 walktree failed.\n");
787 1.1 itojun if (rn_walktree(kt->pfrkt_ip6, pfr_walktree, &w))
788 1.1 itojun printf("pfr_mark_addrs: IPv6 walktree failed.\n");
789 1.1 itojun }
790 1.1 itojun
791 1.1 itojun
792 1.1 itojun struct pfr_kentry *
793 1.1 itojun pfr_lookup_addr(struct pfr_ktable *kt, struct pfr_addr *ad, int exact)
794 1.1 itojun {
795 1.1 itojun union sockaddr_union sa, mask;
796 1.5 yamt struct radix_node_head *head = (void *)0xdeadb;
797 1.1 itojun struct pfr_kentry *ke;
798 1.1 itojun int s;
799 1.1 itojun
800 1.1 itojun bzero(&sa, sizeof(sa));
801 1.1 itojun if (ad->pfra_af == AF_INET) {
802 1.1 itojun FILLIN_SIN(sa.sin, ad->pfra_ip4addr);
803 1.1 itojun head = kt->pfrkt_ip4;
804 1.5 yamt } else if ( ad->pfra_af == AF_INET6 ) {
805 1.1 itojun FILLIN_SIN6(sa.sin6, ad->pfra_ip6addr);
806 1.1 itojun head = kt->pfrkt_ip6;
807 1.1 itojun }
808 1.1 itojun if (ADDR_NETWORK(ad)) {
809 1.1 itojun pfr_prepare_network(&mask, ad->pfra_af, ad->pfra_net);
810 1.1 itojun s = splsoftnet(); /* rn_lookup makes use of globals */
811 1.1 itojun ke = (struct pfr_kentry *)rn_lookup(&sa, &mask, head);
812 1.1 itojun splx(s);
813 1.1 itojun if (ke && KENTRY_RNF_ROOT(ke))
814 1.1 itojun ke = NULL;
815 1.1 itojun } else {
816 1.1 itojun ke = (struct pfr_kentry *)rn_match(&sa, head);
817 1.1 itojun if (ke && KENTRY_RNF_ROOT(ke))
818 1.1 itojun ke = NULL;
819 1.1 itojun if (exact && ke && KENTRY_NETWORK(ke))
820 1.1 itojun ke = NULL;
821 1.1 itojun }
822 1.1 itojun return (ke);
823 1.1 itojun }
824 1.1 itojun
825 1.1 itojun struct pfr_kentry *
826 1.6 peter pfr_create_kentry(struct pfr_addr *ad, int intr)
827 1.1 itojun {
828 1.1 itojun struct pfr_kentry *ke;
829 1.1 itojun
830 1.6 peter if (intr)
831 1.6 peter ke = pool_get(&pfr_kentry_pl2, PR_NOWAIT);
832 1.6 peter else
833 1.6 peter ke = pool_get(&pfr_kentry_pl, PR_NOWAIT);
834 1.1 itojun if (ke == NULL)
835 1.1 itojun return (NULL);
836 1.1 itojun bzero(ke, sizeof(*ke));
837 1.1 itojun
838 1.1 itojun if (ad->pfra_af == AF_INET)
839 1.1 itojun FILLIN_SIN(ke->pfrke_sa.sin, ad->pfra_ip4addr);
840 1.5 yamt else if (ad->pfra_af == AF_INET6)
841 1.1 itojun FILLIN_SIN6(ke->pfrke_sa.sin6, ad->pfra_ip6addr);
842 1.1 itojun ke->pfrke_af = ad->pfra_af;
843 1.1 itojun ke->pfrke_net = ad->pfra_net;
844 1.1 itojun ke->pfrke_not = ad->pfra_not;
845 1.6 peter ke->pfrke_intrpool = intr;
846 1.1 itojun return (ke);
847 1.1 itojun }
848 1.1 itojun
849 1.1 itojun void
850 1.1 itojun pfr_destroy_kentries(struct pfr_kentryworkq *workq)
851 1.1 itojun {
852 1.1 itojun struct pfr_kentry *p, *q;
853 1.1 itojun
854 1.1 itojun for (p = SLIST_FIRST(workq); p != NULL; p = q) {
855 1.1 itojun q = SLIST_NEXT(p, pfrke_workq);
856 1.1 itojun pfr_destroy_kentry(p);
857 1.1 itojun }
858 1.1 itojun }
859 1.1 itojun
860 1.1 itojun void
861 1.1 itojun pfr_destroy_kentry(struct pfr_kentry *ke)
862 1.1 itojun {
863 1.6 peter if (ke->pfrke_intrpool)
864 1.6 peter pool_put(&pfr_kentry_pl2, ke);
865 1.6 peter else
866 1.6 peter pool_put(&pfr_kentry_pl, ke);
867 1.1 itojun }
868 1.1 itojun
869 1.1 itojun void
870 1.1 itojun pfr_insert_kentries(struct pfr_ktable *kt,
871 1.1 itojun struct pfr_kentryworkq *workq, long tzero)
872 1.1 itojun {
873 1.1 itojun struct pfr_kentry *p;
874 1.1 itojun int rv, n = 0;
875 1.1 itojun
876 1.1 itojun SLIST_FOREACH(p, workq, pfrke_workq) {
877 1.1 itojun rv = pfr_route_kentry(kt, p);
878 1.1 itojun if (rv) {
879 1.1 itojun printf("pfr_insert_kentries: cannot route entry "
880 1.1 itojun "(code=%d).\n", rv);
881 1.1 itojun break;
882 1.1 itojun }
883 1.1 itojun p->pfrke_tzero = tzero;
884 1.1 itojun n++;
885 1.1 itojun }
886 1.1 itojun kt->pfrkt_cnt += n;
887 1.1 itojun }
888 1.1 itojun
889 1.6 peter int
890 1.6 peter pfr_insert_kentry(struct pfr_ktable *kt, struct pfr_addr *ad, long tzero)
891 1.6 peter {
892 1.6 peter struct pfr_kentry *p;
893 1.6 peter int rv;
894 1.6 peter
895 1.6 peter p = pfr_lookup_addr(kt, ad, 1);
896 1.6 peter if (p != NULL)
897 1.6 peter return (0);
898 1.6 peter p = pfr_create_kentry(ad, 1);
899 1.6 peter if (p == NULL)
900 1.6 peter return (EINVAL);
901 1.6 peter
902 1.6 peter rv = pfr_route_kentry(kt, p);
903 1.6 peter if (rv)
904 1.6 peter return (rv);
905 1.6 peter
906 1.6 peter p->pfrke_tzero = tzero;
907 1.6 peter kt->pfrkt_cnt++;
908 1.6 peter
909 1.6 peter return (0);
910 1.6 peter }
911 1.6 peter
912 1.1 itojun void
913 1.1 itojun pfr_remove_kentries(struct pfr_ktable *kt,
914 1.1 itojun struct pfr_kentryworkq *workq)
915 1.1 itojun {
916 1.1 itojun struct pfr_kentry *p;
917 1.1 itojun int n = 0;
918 1.1 itojun
919 1.1 itojun SLIST_FOREACH(p, workq, pfrke_workq) {
920 1.1 itojun pfr_unroute_kentry(kt, p);
921 1.1 itojun n++;
922 1.1 itojun }
923 1.1 itojun kt->pfrkt_cnt -= n;
924 1.1 itojun pfr_destroy_kentries(workq);
925 1.1 itojun }
926 1.1 itojun
927 1.1 itojun void
928 1.1 itojun pfr_clean_node_mask(struct pfr_ktable *kt,
929 1.1 itojun struct pfr_kentryworkq *workq)
930 1.1 itojun {
931 1.1 itojun struct pfr_kentry *p;
932 1.1 itojun
933 1.1 itojun SLIST_FOREACH(p, workq, pfrke_workq)
934 1.1 itojun pfr_unroute_kentry(kt, p);
935 1.1 itojun }
936 1.1 itojun
937 1.1 itojun void
938 1.1 itojun pfr_clstats_kentries(struct pfr_kentryworkq *workq, long tzero, int negchange)
939 1.1 itojun {
940 1.1 itojun struct pfr_kentry *p;
941 1.1 itojun int s;
942 1.1 itojun
943 1.1 itojun SLIST_FOREACH(p, workq, pfrke_workq) {
944 1.1 itojun s = splsoftnet();
945 1.1 itojun if (negchange)
946 1.1 itojun p->pfrke_not = !p->pfrke_not;
947 1.1 itojun bzero(p->pfrke_packets, sizeof(p->pfrke_packets));
948 1.1 itojun bzero(p->pfrke_bytes, sizeof(p->pfrke_bytes));
949 1.1 itojun splx(s);
950 1.1 itojun p->pfrke_tzero = tzero;
951 1.1 itojun }
952 1.1 itojun }
953 1.1 itojun
954 1.1 itojun void
955 1.1 itojun pfr_reset_feedback(struct pfr_addr *addr, int size, int flags)
956 1.1 itojun {
957 1.1 itojun struct pfr_addr ad;
958 1.1 itojun int i;
959 1.1 itojun
960 1.1 itojun for (i = 0; i < size; i++) {
961 1.1 itojun if (COPYIN(addr+i, &ad, sizeof(ad)))
962 1.1 itojun break;
963 1.1 itojun ad.pfra_fback = PFR_FB_NONE;
964 1.1 itojun if (COPYOUT(&ad, addr+i, sizeof(ad)))
965 1.1 itojun break;
966 1.1 itojun }
967 1.1 itojun }
968 1.1 itojun
969 1.1 itojun void
970 1.1 itojun pfr_prepare_network(union sockaddr_union *sa, int af, int net)
971 1.1 itojun {
972 1.1 itojun int i;
973 1.1 itojun
974 1.1 itojun bzero(sa, sizeof(*sa));
975 1.1 itojun if (af == AF_INET) {
976 1.1 itojun sa->sin.sin_len = sizeof(sa->sin);
977 1.1 itojun sa->sin.sin_family = AF_INET;
978 1.5 yamt sa->sin.sin_addr.s_addr = net ? htonl(-1 << (32-net)) : 0;
979 1.5 yamt } else if (af == AF_INET6) {
980 1.1 itojun sa->sin6.sin6_len = sizeof(sa->sin6);
981 1.1 itojun sa->sin6.sin6_family = AF_INET6;
982 1.1 itojun for (i = 0; i < 4; i++) {
983 1.1 itojun if (net <= 32) {
984 1.1 itojun sa->sin6.sin6_addr.s6_addr32[i] =
985 1.5 yamt net ? htonl(-1 << (32-net)) : 0;
986 1.1 itojun break;
987 1.1 itojun }
988 1.1 itojun sa->sin6.sin6_addr.s6_addr32[i] = 0xFFFFFFFF;
989 1.1 itojun net -= 32;
990 1.1 itojun }
991 1.1 itojun }
992 1.1 itojun }
993 1.1 itojun
994 1.1 itojun int
995 1.1 itojun pfr_route_kentry(struct pfr_ktable *kt, struct pfr_kentry *ke)
996 1.1 itojun {
997 1.1 itojun union sockaddr_union mask;
998 1.1 itojun struct radix_node *rn;
999 1.5 yamt struct radix_node_head *head = (void *)0xdeadb;
1000 1.1 itojun int s;
1001 1.1 itojun
1002 1.1 itojun bzero(ke->pfrke_node, sizeof(ke->pfrke_node));
1003 1.1 itojun if (ke->pfrke_af == AF_INET)
1004 1.1 itojun head = kt->pfrkt_ip4;
1005 1.5 yamt else if (ke->pfrke_af == AF_INET6)
1006 1.1 itojun head = kt->pfrkt_ip6;
1007 1.1 itojun
1008 1.1 itojun s = splsoftnet();
1009 1.1 itojun if (KENTRY_NETWORK(ke)) {
1010 1.1 itojun pfr_prepare_network(&mask, ke->pfrke_af, ke->pfrke_net);
1011 1.1 itojun rn = rn_addroute(&ke->pfrke_sa, &mask, head, ke->pfrke_node);
1012 1.1 itojun } else
1013 1.1 itojun rn = rn_addroute(&ke->pfrke_sa, NULL, head, ke->pfrke_node);
1014 1.1 itojun splx(s);
1015 1.1 itojun
1016 1.1 itojun return (rn == NULL ? -1 : 0);
1017 1.1 itojun }
1018 1.1 itojun
1019 1.1 itojun int
1020 1.1 itojun pfr_unroute_kentry(struct pfr_ktable *kt, struct pfr_kentry *ke)
1021 1.1 itojun {
1022 1.1 itojun union sockaddr_union mask;
1023 1.1 itojun struct radix_node *rn;
1024 1.5 yamt struct radix_node_head *head = (void *)0xdeadb;
1025 1.1 itojun int s;
1026 1.1 itojun
1027 1.1 itojun if (ke->pfrke_af == AF_INET)
1028 1.1 itojun head = kt->pfrkt_ip4;
1029 1.5 yamt else if (ke->pfrke_af == AF_INET6)
1030 1.1 itojun head = kt->pfrkt_ip6;
1031 1.1 itojun
1032 1.1 itojun s = splsoftnet();
1033 1.1 itojun if (KENTRY_NETWORK(ke)) {
1034 1.1 itojun pfr_prepare_network(&mask, ke->pfrke_af, ke->pfrke_net);
1035 1.1 itojun rn = rn_delete(&ke->pfrke_sa, &mask, head);
1036 1.1 itojun } else
1037 1.1 itojun rn = rn_delete(&ke->pfrke_sa, NULL, head);
1038 1.1 itojun splx(s);
1039 1.1 itojun
1040 1.1 itojun if (rn == NULL) {
1041 1.1 itojun printf("pfr_unroute_kentry: delete failed.\n");
1042 1.1 itojun return (-1);
1043 1.1 itojun }
1044 1.1 itojun return (0);
1045 1.1 itojun }
1046 1.1 itojun
1047 1.1 itojun void
1048 1.1 itojun pfr_copyout_addr(struct pfr_addr *ad, struct pfr_kentry *ke)
1049 1.1 itojun {
1050 1.1 itojun bzero(ad, sizeof(*ad));
1051 1.1 itojun if (ke == NULL)
1052 1.1 itojun return;
1053 1.1 itojun ad->pfra_af = ke->pfrke_af;
1054 1.1 itojun ad->pfra_net = ke->pfrke_net;
1055 1.1 itojun ad->pfra_not = ke->pfrke_not;
1056 1.1 itojun if (ad->pfra_af == AF_INET)
1057 1.1 itojun ad->pfra_ip4addr = ke->pfrke_sa.sin.sin_addr;
1058 1.5 yamt else if (ad->pfra_af == AF_INET6)
1059 1.1 itojun ad->pfra_ip6addr = ke->pfrke_sa.sin6.sin6_addr;
1060 1.1 itojun }
1061 1.1 itojun
1062 1.1 itojun int
1063 1.1 itojun pfr_walktree(struct radix_node *rn, void *arg)
1064 1.1 itojun {
1065 1.1 itojun struct pfr_kentry *ke = (struct pfr_kentry *)rn;
1066 1.1 itojun struct pfr_walktree *w = arg;
1067 1.1 itojun int s, flags = w->pfrw_flags;
1068 1.1 itojun
1069 1.1 itojun switch (w->pfrw_op) {
1070 1.1 itojun case PFRW_MARK:
1071 1.1 itojun ke->pfrke_mark = 0;
1072 1.1 itojun break;
1073 1.1 itojun case PFRW_SWEEP:
1074 1.1 itojun if (ke->pfrke_mark)
1075 1.1 itojun break;
1076 1.1 itojun /* FALLTHROUGH */
1077 1.1 itojun case PFRW_ENQUEUE:
1078 1.1 itojun SLIST_INSERT_HEAD(w->pfrw_workq, ke, pfrke_workq);
1079 1.1 itojun w->pfrw_cnt++;
1080 1.1 itojun break;
1081 1.1 itojun case PFRW_GET_ADDRS:
1082 1.1 itojun if (w->pfrw_free-- > 0) {
1083 1.1 itojun struct pfr_addr ad;
1084 1.1 itojun
1085 1.1 itojun pfr_copyout_addr(&ad, ke);
1086 1.1 itojun if (copyout(&ad, w->pfrw_addr, sizeof(ad)))
1087 1.1 itojun return (EFAULT);
1088 1.1 itojun w->pfrw_addr++;
1089 1.1 itojun }
1090 1.1 itojun break;
1091 1.1 itojun case PFRW_GET_ASTATS:
1092 1.1 itojun if (w->pfrw_free-- > 0) {
1093 1.1 itojun struct pfr_astats as;
1094 1.1 itojun
1095 1.1 itojun pfr_copyout_addr(&as.pfras_a, ke);
1096 1.1 itojun
1097 1.1 itojun s = splsoftnet();
1098 1.1 itojun bcopy(ke->pfrke_packets, as.pfras_packets,
1099 1.1 itojun sizeof(as.pfras_packets));
1100 1.1 itojun bcopy(ke->pfrke_bytes, as.pfras_bytes,
1101 1.1 itojun sizeof(as.pfras_bytes));
1102 1.1 itojun splx(s);
1103 1.1 itojun as.pfras_tzero = ke->pfrke_tzero;
1104 1.1 itojun
1105 1.1 itojun if (COPYOUT(&as, w->pfrw_astats, sizeof(as)))
1106 1.1 itojun return (EFAULT);
1107 1.1 itojun w->pfrw_astats++;
1108 1.1 itojun }
1109 1.1 itojun break;
1110 1.1 itojun case PFRW_POOL_GET:
1111 1.1 itojun if (ke->pfrke_not)
1112 1.1 itojun break; /* negative entries are ignored */
1113 1.1 itojun if (!w->pfrw_cnt--) {
1114 1.1 itojun w->pfrw_kentry = ke;
1115 1.1 itojun return (1); /* finish search */
1116 1.1 itojun }
1117 1.1 itojun break;
1118 1.1 itojun case PFRW_DYNADDR_UPDATE:
1119 1.1 itojun if (ke->pfrke_af == AF_INET) {
1120 1.1 itojun if (w->pfrw_dyn->pfid_acnt4++ > 0)
1121 1.1 itojun break;
1122 1.1 itojun pfr_prepare_network(&pfr_mask, AF_INET, ke->pfrke_net);
1123 1.1 itojun w->pfrw_dyn->pfid_addr4 = *SUNION2PF(
1124 1.1 itojun &ke->pfrke_sa, AF_INET);
1125 1.1 itojun w->pfrw_dyn->pfid_mask4 = *SUNION2PF(
1126 1.1 itojun &pfr_mask, AF_INET);
1127 1.5 yamt } else if (ke->pfrke_af == AF_INET6){
1128 1.1 itojun if (w->pfrw_dyn->pfid_acnt6++ > 0)
1129 1.1 itojun break;
1130 1.1 itojun pfr_prepare_network(&pfr_mask, AF_INET6, ke->pfrke_net);
1131 1.1 itojun w->pfrw_dyn->pfid_addr6 = *SUNION2PF(
1132 1.1 itojun &ke->pfrke_sa, AF_INET6);
1133 1.1 itojun w->pfrw_dyn->pfid_mask6 = *SUNION2PF(
1134 1.1 itojun &pfr_mask, AF_INET6);
1135 1.1 itojun }
1136 1.1 itojun break;
1137 1.1 itojun }
1138 1.1 itojun return (0);
1139 1.1 itojun }
1140 1.1 itojun
1141 1.1 itojun int
1142 1.1 itojun pfr_clr_tables(struct pfr_table *filter, int *ndel, int flags)
1143 1.1 itojun {
1144 1.1 itojun struct pfr_ktableworkq workq;
1145 1.1 itojun struct pfr_ktable *p;
1146 1.2 itojun int s = 0, xdel = 0;
1147 1.1 itojun
1148 1.1 itojun ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY+PFR_FLAG_ALLRSETS);
1149 1.6 peter if (pfr_fix_anchor(filter->pfrt_anchor))
1150 1.6 peter return (EINVAL);
1151 1.1 itojun if (pfr_table_count(filter, flags) < 0)
1152 1.1 itojun return (ENOENT);
1153 1.1 itojun
1154 1.1 itojun SLIST_INIT(&workq);
1155 1.1 itojun RB_FOREACH(p, pfr_ktablehead, &pfr_ktables) {
1156 1.1 itojun if (pfr_skip_table(filter, p, flags))
1157 1.1 itojun continue;
1158 1.1 itojun if (!strcmp(p->pfrkt_anchor, PF_RESERVED_ANCHOR))
1159 1.1 itojun continue;
1160 1.1 itojun if (!(p->pfrkt_flags & PFR_TFLAG_ACTIVE))
1161 1.1 itojun continue;
1162 1.1 itojun p->pfrkt_nflags = p->pfrkt_flags & ~PFR_TFLAG_ACTIVE;
1163 1.1 itojun SLIST_INSERT_HEAD(&workq, p, pfrkt_workq);
1164 1.1 itojun xdel++;
1165 1.1 itojun }
1166 1.1 itojun if (!(flags & PFR_FLAG_DUMMY)) {
1167 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
1168 1.1 itojun s = splsoftnet();
1169 1.1 itojun pfr_setflags_ktables(&workq);
1170 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
1171 1.1 itojun splx(s);
1172 1.1 itojun }
1173 1.1 itojun if (ndel != NULL)
1174 1.1 itojun *ndel = xdel;
1175 1.1 itojun return (0);
1176 1.1 itojun }
1177 1.1 itojun
1178 1.1 itojun int
1179 1.1 itojun pfr_add_tables(struct pfr_table *tbl, int size, int *nadd, int flags)
1180 1.1 itojun {
1181 1.1 itojun struct pfr_ktableworkq addq, changeq;
1182 1.1 itojun struct pfr_ktable *p, *q, *r, key;
1183 1.5 yamt int i, rv, s = 0 /* XXX gcc */, xadd = 0;
1184 1.5 yamt long tzero = time_second;
1185 1.1 itojun
1186 1.1 itojun ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY);
1187 1.1 itojun SLIST_INIT(&addq);
1188 1.1 itojun SLIST_INIT(&changeq);
1189 1.1 itojun for (i = 0; i < size; i++) {
1190 1.1 itojun if (COPYIN(tbl+i, &key.pfrkt_t, sizeof(key.pfrkt_t)))
1191 1.1 itojun senderr(EFAULT);
1192 1.1 itojun if (pfr_validate_table(&key.pfrkt_t, PFR_TFLAG_USRMASK,
1193 1.1 itojun flags & PFR_FLAG_USERIOCTL))
1194 1.1 itojun senderr(EINVAL);
1195 1.1 itojun key.pfrkt_flags |= PFR_TFLAG_ACTIVE;
1196 1.1 itojun p = RB_FIND(pfr_ktablehead, &pfr_ktables, &key);
1197 1.1 itojun if (p == NULL) {
1198 1.1 itojun p = pfr_create_ktable(&key.pfrkt_t, tzero, 1);
1199 1.1 itojun if (p == NULL)
1200 1.1 itojun senderr(ENOMEM);
1201 1.1 itojun SLIST_FOREACH(q, &addq, pfrkt_workq) {
1202 1.1 itojun if (!pfr_ktable_compare(p, q))
1203 1.1 itojun goto _skip;
1204 1.1 itojun }
1205 1.1 itojun SLIST_INSERT_HEAD(&addq, p, pfrkt_workq);
1206 1.1 itojun xadd++;
1207 1.1 itojun if (!key.pfrkt_anchor[0])
1208 1.1 itojun goto _skip;
1209 1.1 itojun
1210 1.1 itojun /* find or create root table */
1211 1.1 itojun bzero(key.pfrkt_anchor, sizeof(key.pfrkt_anchor));
1212 1.1 itojun r = RB_FIND(pfr_ktablehead, &pfr_ktables, &key);
1213 1.1 itojun if (r != NULL) {
1214 1.1 itojun p->pfrkt_root = r;
1215 1.1 itojun goto _skip;
1216 1.1 itojun }
1217 1.1 itojun SLIST_FOREACH(q, &addq, pfrkt_workq) {
1218 1.1 itojun if (!pfr_ktable_compare(&key, q)) {
1219 1.1 itojun p->pfrkt_root = q;
1220 1.1 itojun goto _skip;
1221 1.1 itojun }
1222 1.1 itojun }
1223 1.1 itojun key.pfrkt_flags = 0;
1224 1.1 itojun r = pfr_create_ktable(&key.pfrkt_t, 0, 1);
1225 1.1 itojun if (r == NULL)
1226 1.1 itojun senderr(ENOMEM);
1227 1.1 itojun SLIST_INSERT_HEAD(&addq, r, pfrkt_workq);
1228 1.1 itojun p->pfrkt_root = r;
1229 1.1 itojun } else if (!(p->pfrkt_flags & PFR_TFLAG_ACTIVE)) {
1230 1.1 itojun SLIST_FOREACH(q, &changeq, pfrkt_workq)
1231 1.1 itojun if (!pfr_ktable_compare(&key, q))
1232 1.1 itojun goto _skip;
1233 1.1 itojun p->pfrkt_nflags = (p->pfrkt_flags &
1234 1.1 itojun ~PFR_TFLAG_USRMASK) | key.pfrkt_flags;
1235 1.1 itojun SLIST_INSERT_HEAD(&changeq, p, pfrkt_workq);
1236 1.1 itojun xadd++;
1237 1.1 itojun }
1238 1.1 itojun _skip:
1239 1.1 itojun ;
1240 1.1 itojun }
1241 1.1 itojun if (!(flags & PFR_FLAG_DUMMY)) {
1242 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
1243 1.1 itojun s = splsoftnet();
1244 1.1 itojun pfr_insert_ktables(&addq);
1245 1.1 itojun pfr_setflags_ktables(&changeq);
1246 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
1247 1.1 itojun splx(s);
1248 1.1 itojun } else
1249 1.1 itojun pfr_destroy_ktables(&addq, 0);
1250 1.1 itojun if (nadd != NULL)
1251 1.1 itojun *nadd = xadd;
1252 1.1 itojun return (0);
1253 1.1 itojun _bad:
1254 1.1 itojun pfr_destroy_ktables(&addq, 0);
1255 1.1 itojun return (rv);
1256 1.1 itojun }
1257 1.1 itojun
1258 1.1 itojun int
1259 1.1 itojun pfr_del_tables(struct pfr_table *tbl, int size, int *ndel, int flags)
1260 1.1 itojun {
1261 1.1 itojun struct pfr_ktableworkq workq;
1262 1.1 itojun struct pfr_ktable *p, *q, key;
1263 1.2 itojun int i, s = 0, xdel = 0;
1264 1.1 itojun
1265 1.1 itojun ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY);
1266 1.1 itojun SLIST_INIT(&workq);
1267 1.1 itojun for (i = 0; i < size; i++) {
1268 1.1 itojun if (COPYIN(tbl+i, &key.pfrkt_t, sizeof(key.pfrkt_t)))
1269 1.1 itojun return (EFAULT);
1270 1.1 itojun if (pfr_validate_table(&key.pfrkt_t, 0,
1271 1.1 itojun flags & PFR_FLAG_USERIOCTL))
1272 1.1 itojun return (EINVAL);
1273 1.1 itojun p = RB_FIND(pfr_ktablehead, &pfr_ktables, &key);
1274 1.1 itojun if (p != NULL && (p->pfrkt_flags & PFR_TFLAG_ACTIVE)) {
1275 1.1 itojun SLIST_FOREACH(q, &workq, pfrkt_workq)
1276 1.1 itojun if (!pfr_ktable_compare(p, q))
1277 1.1 itojun goto _skip;
1278 1.1 itojun p->pfrkt_nflags = p->pfrkt_flags & ~PFR_TFLAG_ACTIVE;
1279 1.1 itojun SLIST_INSERT_HEAD(&workq, p, pfrkt_workq);
1280 1.1 itojun xdel++;
1281 1.1 itojun }
1282 1.1 itojun _skip:
1283 1.1 itojun ;
1284 1.1 itojun }
1285 1.1 itojun
1286 1.1 itojun if (!(flags & PFR_FLAG_DUMMY)) {
1287 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
1288 1.1 itojun s = splsoftnet();
1289 1.1 itojun pfr_setflags_ktables(&workq);
1290 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
1291 1.1 itojun splx(s);
1292 1.1 itojun }
1293 1.1 itojun if (ndel != NULL)
1294 1.1 itojun *ndel = xdel;
1295 1.1 itojun return (0);
1296 1.1 itojun }
1297 1.1 itojun
1298 1.1 itojun int
1299 1.1 itojun pfr_get_tables(struct pfr_table *filter, struct pfr_table *tbl, int *size,
1300 1.1 itojun int flags)
1301 1.1 itojun {
1302 1.1 itojun struct pfr_ktable *p;
1303 1.1 itojun int n, nn;
1304 1.1 itojun
1305 1.1 itojun ACCEPT_FLAGS(PFR_FLAG_ALLRSETS);
1306 1.6 peter if (pfr_fix_anchor(filter->pfrt_anchor))
1307 1.6 peter return (EINVAL);
1308 1.1 itojun n = nn = pfr_table_count(filter, flags);
1309 1.1 itojun if (n < 0)
1310 1.1 itojun return (ENOENT);
1311 1.1 itojun if (n > *size) {
1312 1.1 itojun *size = n;
1313 1.1 itojun return (0);
1314 1.1 itojun }
1315 1.1 itojun RB_FOREACH(p, pfr_ktablehead, &pfr_ktables) {
1316 1.1 itojun if (pfr_skip_table(filter, p, flags))
1317 1.1 itojun continue;
1318 1.1 itojun if (n-- <= 0)
1319 1.1 itojun continue;
1320 1.1 itojun if (COPYOUT(&p->pfrkt_t, tbl++, sizeof(*tbl)))
1321 1.1 itojun return (EFAULT);
1322 1.1 itojun }
1323 1.1 itojun if (n) {
1324 1.1 itojun printf("pfr_get_tables: corruption detected (%d).\n", n);
1325 1.1 itojun return (ENOTTY);
1326 1.1 itojun }
1327 1.1 itojun *size = nn;
1328 1.1 itojun return (0);
1329 1.1 itojun }
1330 1.1 itojun
1331 1.1 itojun int
1332 1.1 itojun pfr_get_tstats(struct pfr_table *filter, struct pfr_tstats *tbl, int *size,
1333 1.1 itojun int flags)
1334 1.1 itojun {
1335 1.1 itojun struct pfr_ktable *p;
1336 1.1 itojun struct pfr_ktableworkq workq;
1337 1.5 yamt int s = 0 /* XXX gcc */, n, nn;
1338 1.5 yamt long tzero = time_second;
1339 1.1 itojun
1340 1.1 itojun ACCEPT_FLAGS(PFR_FLAG_ATOMIC|PFR_FLAG_ALLRSETS);
1341 1.1 itojun /* XXX PFR_FLAG_CLSTATS disabled */
1342 1.6 peter if (pfr_fix_anchor(filter->pfrt_anchor))
1343 1.6 peter return (EINVAL);
1344 1.1 itojun n = nn = pfr_table_count(filter, flags);
1345 1.1 itojun if (n < 0)
1346 1.1 itojun return (ENOENT);
1347 1.1 itojun if (n > *size) {
1348 1.1 itojun *size = n;
1349 1.1 itojun return (0);
1350 1.1 itojun }
1351 1.1 itojun SLIST_INIT(&workq);
1352 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
1353 1.1 itojun s = splsoftnet();
1354 1.1 itojun RB_FOREACH(p, pfr_ktablehead, &pfr_ktables) {
1355 1.1 itojun if (pfr_skip_table(filter, p, flags))
1356 1.1 itojun continue;
1357 1.1 itojun if (n-- <= 0)
1358 1.1 itojun continue;
1359 1.1 itojun if (!(flags & PFR_FLAG_ATOMIC))
1360 1.1 itojun s = splsoftnet();
1361 1.1 itojun if (COPYOUT(&p->pfrkt_ts, tbl++, sizeof(*tbl))) {
1362 1.1 itojun splx(s);
1363 1.1 itojun return (EFAULT);
1364 1.1 itojun }
1365 1.1 itojun if (!(flags & PFR_FLAG_ATOMIC))
1366 1.1 itojun splx(s);
1367 1.1 itojun SLIST_INSERT_HEAD(&workq, p, pfrkt_workq);
1368 1.1 itojun }
1369 1.1 itojun if (flags & PFR_FLAG_CLSTATS)
1370 1.1 itojun pfr_clstats_ktables(&workq, tzero,
1371 1.1 itojun flags & PFR_FLAG_ADDRSTOO);
1372 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
1373 1.1 itojun splx(s);
1374 1.1 itojun if (n) {
1375 1.1 itojun printf("pfr_get_tstats: corruption detected (%d).\n", n);
1376 1.1 itojun return (ENOTTY);
1377 1.1 itojun }
1378 1.1 itojun *size = nn;
1379 1.1 itojun return (0);
1380 1.1 itojun }
1381 1.1 itojun
1382 1.1 itojun int
1383 1.1 itojun pfr_clr_tstats(struct pfr_table *tbl, int size, int *nzero, int flags)
1384 1.1 itojun {
1385 1.1 itojun struct pfr_ktableworkq workq;
1386 1.1 itojun struct pfr_ktable *p, key;
1387 1.5 yamt int i, s = 0 /* XXX gcc */, xzero = 0;
1388 1.5 yamt long tzero = time_second;
1389 1.1 itojun
1390 1.1 itojun ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY+PFR_FLAG_ADDRSTOO);
1391 1.1 itojun SLIST_INIT(&workq);
1392 1.1 itojun for (i = 0; i < size; i++) {
1393 1.1 itojun if (COPYIN(tbl+i, &key.pfrkt_t, sizeof(key.pfrkt_t)))
1394 1.1 itojun return (EFAULT);
1395 1.1 itojun if (pfr_validate_table(&key.pfrkt_t, 0, 0))
1396 1.1 itojun return (EINVAL);
1397 1.1 itojun p = RB_FIND(pfr_ktablehead, &pfr_ktables, &key);
1398 1.1 itojun if (p != NULL) {
1399 1.1 itojun SLIST_INSERT_HEAD(&workq, p, pfrkt_workq);
1400 1.1 itojun xzero++;
1401 1.1 itojun }
1402 1.1 itojun }
1403 1.1 itojun if (!(flags & PFR_FLAG_DUMMY)) {
1404 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
1405 1.1 itojun s = splsoftnet();
1406 1.1 itojun pfr_clstats_ktables(&workq, tzero, flags & PFR_FLAG_ADDRSTOO);
1407 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
1408 1.1 itojun splx(s);
1409 1.1 itojun }
1410 1.1 itojun if (nzero != NULL)
1411 1.1 itojun *nzero = xzero;
1412 1.1 itojun return (0);
1413 1.1 itojun }
1414 1.1 itojun
1415 1.1 itojun int
1416 1.1 itojun pfr_set_tflags(struct pfr_table *tbl, int size, int setflag, int clrflag,
1417 1.1 itojun int *nchange, int *ndel, int flags)
1418 1.1 itojun {
1419 1.1 itojun struct pfr_ktableworkq workq;
1420 1.1 itojun struct pfr_ktable *p, *q, key;
1421 1.2 itojun int i, s = 0, xchange = 0, xdel = 0;
1422 1.1 itojun
1423 1.1 itojun ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY);
1424 1.1 itojun if ((setflag & ~PFR_TFLAG_USRMASK) ||
1425 1.1 itojun (clrflag & ~PFR_TFLAG_USRMASK) ||
1426 1.1 itojun (setflag & clrflag))
1427 1.1 itojun return (EINVAL);
1428 1.1 itojun SLIST_INIT(&workq);
1429 1.1 itojun for (i = 0; i < size; i++) {
1430 1.1 itojun if (COPYIN(tbl+i, &key.pfrkt_t, sizeof(key.pfrkt_t)))
1431 1.1 itojun return (EFAULT);
1432 1.1 itojun if (pfr_validate_table(&key.pfrkt_t, 0,
1433 1.1 itojun flags & PFR_FLAG_USERIOCTL))
1434 1.1 itojun return (EINVAL);
1435 1.1 itojun p = RB_FIND(pfr_ktablehead, &pfr_ktables, &key);
1436 1.1 itojun if (p != NULL && (p->pfrkt_flags & PFR_TFLAG_ACTIVE)) {
1437 1.1 itojun p->pfrkt_nflags = (p->pfrkt_flags | setflag) &
1438 1.1 itojun ~clrflag;
1439 1.1 itojun if (p->pfrkt_nflags == p->pfrkt_flags)
1440 1.1 itojun goto _skip;
1441 1.1 itojun SLIST_FOREACH(q, &workq, pfrkt_workq)
1442 1.1 itojun if (!pfr_ktable_compare(p, q))
1443 1.1 itojun goto _skip;
1444 1.1 itojun SLIST_INSERT_HEAD(&workq, p, pfrkt_workq);
1445 1.1 itojun if ((p->pfrkt_flags & PFR_TFLAG_PERSIST) &&
1446 1.1 itojun (clrflag & PFR_TFLAG_PERSIST) &&
1447 1.1 itojun !(p->pfrkt_flags & PFR_TFLAG_REFERENCED))
1448 1.1 itojun xdel++;
1449 1.1 itojun else
1450 1.1 itojun xchange++;
1451 1.1 itojun }
1452 1.1 itojun _skip:
1453 1.1 itojun ;
1454 1.1 itojun }
1455 1.1 itojun if (!(flags & PFR_FLAG_DUMMY)) {
1456 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
1457 1.1 itojun s = splsoftnet();
1458 1.1 itojun pfr_setflags_ktables(&workq);
1459 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
1460 1.1 itojun splx(s);
1461 1.1 itojun }
1462 1.1 itojun if (nchange != NULL)
1463 1.1 itojun *nchange = xchange;
1464 1.1 itojun if (ndel != NULL)
1465 1.1 itojun *ndel = xdel;
1466 1.1 itojun return (0);
1467 1.1 itojun }
1468 1.1 itojun
1469 1.1 itojun int
1470 1.1 itojun pfr_ina_begin(struct pfr_table *trs, u_int32_t *ticket, int *ndel, int flags)
1471 1.1 itojun {
1472 1.1 itojun struct pfr_ktableworkq workq;
1473 1.1 itojun struct pfr_ktable *p;
1474 1.1 itojun struct pf_ruleset *rs;
1475 1.1 itojun int xdel = 0;
1476 1.1 itojun
1477 1.1 itojun ACCEPT_FLAGS(PFR_FLAG_DUMMY);
1478 1.5 yamt rs = pf_find_or_create_ruleset(trs->pfrt_anchor);
1479 1.1 itojun if (rs == NULL)
1480 1.1 itojun return (ENOMEM);
1481 1.1 itojun SLIST_INIT(&workq);
1482 1.1 itojun RB_FOREACH(p, pfr_ktablehead, &pfr_ktables) {
1483 1.1 itojun if (!(p->pfrkt_flags & PFR_TFLAG_INACTIVE) ||
1484 1.1 itojun pfr_skip_table(trs, p, 0))
1485 1.1 itojun continue;
1486 1.1 itojun p->pfrkt_nflags = p->pfrkt_flags & ~PFR_TFLAG_INACTIVE;
1487 1.1 itojun SLIST_INSERT_HEAD(&workq, p, pfrkt_workq);
1488 1.1 itojun xdel++;
1489 1.1 itojun }
1490 1.1 itojun if (!(flags & PFR_FLAG_DUMMY)) {
1491 1.1 itojun pfr_setflags_ktables(&workq);
1492 1.1 itojun if (ticket != NULL)
1493 1.1 itojun *ticket = ++rs->tticket;
1494 1.1 itojun rs->topen = 1;
1495 1.1 itojun } else
1496 1.1 itojun pf_remove_if_empty_ruleset(rs);
1497 1.1 itojun if (ndel != NULL)
1498 1.1 itojun *ndel = xdel;
1499 1.1 itojun return (0);
1500 1.1 itojun }
1501 1.1 itojun
1502 1.1 itojun int
1503 1.1 itojun pfr_ina_define(struct pfr_table *tbl, struct pfr_addr *addr, int size,
1504 1.1 itojun int *nadd, int *naddr, u_int32_t ticket, int flags)
1505 1.1 itojun {
1506 1.1 itojun struct pfr_ktableworkq tableq;
1507 1.1 itojun struct pfr_kentryworkq addrq;
1508 1.1 itojun struct pfr_ktable *kt, *rt, *shadow, key;
1509 1.1 itojun struct pfr_kentry *p;
1510 1.1 itojun struct pfr_addr ad;
1511 1.1 itojun struct pf_ruleset *rs;
1512 1.1 itojun int i, rv, xadd = 0, xaddr = 0;
1513 1.1 itojun
1514 1.1 itojun ACCEPT_FLAGS(PFR_FLAG_DUMMY|PFR_FLAG_ADDRSTOO);
1515 1.1 itojun if (size && !(flags & PFR_FLAG_ADDRSTOO))
1516 1.1 itojun return (EINVAL);
1517 1.1 itojun if (pfr_validate_table(tbl, PFR_TFLAG_USRMASK,
1518 1.1 itojun flags & PFR_FLAG_USERIOCTL))
1519 1.1 itojun return (EINVAL);
1520 1.5 yamt rs = pf_find_ruleset(tbl->pfrt_anchor);
1521 1.1 itojun if (rs == NULL || !rs->topen || ticket != rs->tticket)
1522 1.1 itojun return (EBUSY);
1523 1.1 itojun tbl->pfrt_flags |= PFR_TFLAG_INACTIVE;
1524 1.1 itojun SLIST_INIT(&tableq);
1525 1.1 itojun kt = RB_FIND(pfr_ktablehead, &pfr_ktables, (struct pfr_ktable *)tbl);
1526 1.1 itojun if (kt == NULL) {
1527 1.1 itojun kt = pfr_create_ktable(tbl, 0, 1);
1528 1.1 itojun if (kt == NULL)
1529 1.1 itojun return (ENOMEM);
1530 1.1 itojun SLIST_INSERT_HEAD(&tableq, kt, pfrkt_workq);
1531 1.1 itojun xadd++;
1532 1.1 itojun if (!tbl->pfrt_anchor[0])
1533 1.1 itojun goto _skip;
1534 1.1 itojun
1535 1.1 itojun /* find or create root table */
1536 1.1 itojun bzero(&key, sizeof(key));
1537 1.1 itojun strlcpy(key.pfrkt_name, tbl->pfrt_name, sizeof(key.pfrkt_name));
1538 1.1 itojun rt = RB_FIND(pfr_ktablehead, &pfr_ktables, &key);
1539 1.1 itojun if (rt != NULL) {
1540 1.1 itojun kt->pfrkt_root = rt;
1541 1.1 itojun goto _skip;
1542 1.1 itojun }
1543 1.1 itojun rt = pfr_create_ktable(&key.pfrkt_t, 0, 1);
1544 1.1 itojun if (rt == NULL) {
1545 1.1 itojun pfr_destroy_ktables(&tableq, 0);
1546 1.1 itojun return (ENOMEM);
1547 1.1 itojun }
1548 1.1 itojun SLIST_INSERT_HEAD(&tableq, rt, pfrkt_workq);
1549 1.1 itojun kt->pfrkt_root = rt;
1550 1.1 itojun } else if (!(kt->pfrkt_flags & PFR_TFLAG_INACTIVE))
1551 1.1 itojun xadd++;
1552 1.1 itojun _skip:
1553 1.1 itojun shadow = pfr_create_ktable(tbl, 0, 0);
1554 1.1 itojun if (shadow == NULL) {
1555 1.1 itojun pfr_destroy_ktables(&tableq, 0);
1556 1.1 itojun return (ENOMEM);
1557 1.1 itojun }
1558 1.1 itojun SLIST_INIT(&addrq);
1559 1.1 itojun for (i = 0; i < size; i++) {
1560 1.1 itojun if (COPYIN(addr+i, &ad, sizeof(ad)))
1561 1.1 itojun senderr(EFAULT);
1562 1.1 itojun if (pfr_validate_addr(&ad))
1563 1.1 itojun senderr(EINVAL);
1564 1.1 itojun if (pfr_lookup_addr(shadow, &ad, 1) != NULL)
1565 1.1 itojun continue;
1566 1.6 peter p = pfr_create_kentry(&ad, 0);
1567 1.1 itojun if (p == NULL)
1568 1.1 itojun senderr(ENOMEM);
1569 1.1 itojun if (pfr_route_kentry(shadow, p)) {
1570 1.1 itojun pfr_destroy_kentry(p);
1571 1.1 itojun continue;
1572 1.1 itojun }
1573 1.1 itojun SLIST_INSERT_HEAD(&addrq, p, pfrke_workq);
1574 1.1 itojun xaddr++;
1575 1.1 itojun }
1576 1.1 itojun if (!(flags & PFR_FLAG_DUMMY)) {
1577 1.1 itojun if (kt->pfrkt_shadow != NULL)
1578 1.1 itojun pfr_destroy_ktable(kt->pfrkt_shadow, 1);
1579 1.1 itojun kt->pfrkt_flags |= PFR_TFLAG_INACTIVE;
1580 1.1 itojun pfr_insert_ktables(&tableq);
1581 1.1 itojun shadow->pfrkt_cnt = (flags & PFR_FLAG_ADDRSTOO) ?
1582 1.1 itojun xaddr : NO_ADDRESSES;
1583 1.1 itojun kt->pfrkt_shadow = shadow;
1584 1.1 itojun } else {
1585 1.1 itojun pfr_clean_node_mask(shadow, &addrq);
1586 1.1 itojun pfr_destroy_ktable(shadow, 0);
1587 1.1 itojun pfr_destroy_ktables(&tableq, 0);
1588 1.1 itojun pfr_destroy_kentries(&addrq);
1589 1.1 itojun }
1590 1.1 itojun if (nadd != NULL)
1591 1.1 itojun *nadd = xadd;
1592 1.1 itojun if (naddr != NULL)
1593 1.1 itojun *naddr = xaddr;
1594 1.1 itojun return (0);
1595 1.1 itojun _bad:
1596 1.1 itojun pfr_destroy_ktable(shadow, 0);
1597 1.1 itojun pfr_destroy_ktables(&tableq, 0);
1598 1.1 itojun pfr_destroy_kentries(&addrq);
1599 1.1 itojun return (rv);
1600 1.1 itojun }
1601 1.1 itojun
1602 1.1 itojun int
1603 1.1 itojun pfr_ina_rollback(struct pfr_table *trs, u_int32_t ticket, int *ndel, int flags)
1604 1.1 itojun {
1605 1.1 itojun struct pfr_ktableworkq workq;
1606 1.1 itojun struct pfr_ktable *p;
1607 1.1 itojun struct pf_ruleset *rs;
1608 1.1 itojun int xdel = 0;
1609 1.1 itojun
1610 1.1 itojun ACCEPT_FLAGS(PFR_FLAG_DUMMY);
1611 1.5 yamt rs = pf_find_ruleset(trs->pfrt_anchor);
1612 1.1 itojun if (rs == NULL || !rs->topen || ticket != rs->tticket)
1613 1.1 itojun return (0);
1614 1.1 itojun SLIST_INIT(&workq);
1615 1.1 itojun RB_FOREACH(p, pfr_ktablehead, &pfr_ktables) {
1616 1.1 itojun if (!(p->pfrkt_flags & PFR_TFLAG_INACTIVE) ||
1617 1.1 itojun pfr_skip_table(trs, p, 0))
1618 1.1 itojun continue;
1619 1.1 itojun p->pfrkt_nflags = p->pfrkt_flags & ~PFR_TFLAG_INACTIVE;
1620 1.1 itojun SLIST_INSERT_HEAD(&workq, p, pfrkt_workq);
1621 1.1 itojun xdel++;
1622 1.1 itojun }
1623 1.1 itojun if (!(flags & PFR_FLAG_DUMMY)) {
1624 1.1 itojun pfr_setflags_ktables(&workq);
1625 1.1 itojun rs->topen = 0;
1626 1.1 itojun pf_remove_if_empty_ruleset(rs);
1627 1.1 itojun }
1628 1.1 itojun if (ndel != NULL)
1629 1.1 itojun *ndel = xdel;
1630 1.1 itojun return (0);
1631 1.1 itojun }
1632 1.1 itojun
1633 1.1 itojun int
1634 1.1 itojun pfr_ina_commit(struct pfr_table *trs, u_int32_t ticket, int *nadd,
1635 1.1 itojun int *nchange, int flags)
1636 1.1 itojun {
1637 1.4 yamt struct pfr_ktable *p, *q;
1638 1.1 itojun struct pfr_ktableworkq workq;
1639 1.1 itojun struct pf_ruleset *rs;
1640 1.5 yamt int s = 0 /* XXX gcc */, xadd = 0, xchange = 0;
1641 1.5 yamt long tzero = time_second;
1642 1.1 itojun
1643 1.1 itojun ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY);
1644 1.5 yamt rs = pf_find_ruleset(trs->pfrt_anchor);
1645 1.1 itojun if (rs == NULL || !rs->topen || ticket != rs->tticket)
1646 1.1 itojun return (EBUSY);
1647 1.1 itojun
1648 1.1 itojun SLIST_INIT(&workq);
1649 1.1 itojun RB_FOREACH(p, pfr_ktablehead, &pfr_ktables) {
1650 1.1 itojun if (!(p->pfrkt_flags & PFR_TFLAG_INACTIVE) ||
1651 1.1 itojun pfr_skip_table(trs, p, 0))
1652 1.1 itojun continue;
1653 1.1 itojun SLIST_INSERT_HEAD(&workq, p, pfrkt_workq);
1654 1.1 itojun if (p->pfrkt_flags & PFR_TFLAG_ACTIVE)
1655 1.1 itojun xchange++;
1656 1.1 itojun else
1657 1.1 itojun xadd++;
1658 1.1 itojun }
1659 1.1 itojun
1660 1.1 itojun if (!(flags & PFR_FLAG_DUMMY)) {
1661 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
1662 1.1 itojun s = splsoftnet();
1663 1.4 yamt for (p = SLIST_FIRST(&workq); p != NULL; p = q) {
1664 1.4 yamt q = SLIST_NEXT(p, pfrkt_workq);
1665 1.1 itojun pfr_commit_ktable(p, tzero);
1666 1.4 yamt }
1667 1.1 itojun if (flags & PFR_FLAG_ATOMIC)
1668 1.1 itojun splx(s);
1669 1.1 itojun rs->topen = 0;
1670 1.1 itojun pf_remove_if_empty_ruleset(rs);
1671 1.1 itojun }
1672 1.1 itojun if (nadd != NULL)
1673 1.1 itojun *nadd = xadd;
1674 1.1 itojun if (nchange != NULL)
1675 1.1 itojun *nchange = xchange;
1676 1.1 itojun
1677 1.1 itojun return (0);
1678 1.1 itojun }
1679 1.1 itojun
1680 1.1 itojun void
1681 1.1 itojun pfr_commit_ktable(struct pfr_ktable *kt, long tzero)
1682 1.1 itojun {
1683 1.1 itojun struct pfr_ktable *shadow = kt->pfrkt_shadow;
1684 1.1 itojun int nflags;
1685 1.1 itojun
1686 1.1 itojun if (shadow->pfrkt_cnt == NO_ADDRESSES) {
1687 1.1 itojun if (!(kt->pfrkt_flags & PFR_TFLAG_ACTIVE))
1688 1.1 itojun pfr_clstats_ktable(kt, tzero, 1);
1689 1.1 itojun } else if (kt->pfrkt_flags & PFR_TFLAG_ACTIVE) {
1690 1.1 itojun /* kt might contain addresses */
1691 1.1 itojun struct pfr_kentryworkq addrq, addq, changeq, delq, garbageq;
1692 1.1 itojun struct pfr_kentry *p, *q, *next;
1693 1.1 itojun struct pfr_addr ad;
1694 1.1 itojun
1695 1.1 itojun pfr_enqueue_addrs(shadow, &addrq, NULL, 0);
1696 1.1 itojun pfr_mark_addrs(kt);
1697 1.1 itojun SLIST_INIT(&addq);
1698 1.1 itojun SLIST_INIT(&changeq);
1699 1.1 itojun SLIST_INIT(&delq);
1700 1.1 itojun SLIST_INIT(&garbageq);
1701 1.1 itojun pfr_clean_node_mask(shadow, &addrq);
1702 1.1 itojun for (p = SLIST_FIRST(&addrq); p != NULL; p = next) {
1703 1.1 itojun next = SLIST_NEXT(p, pfrke_workq); /* XXX */
1704 1.1 itojun pfr_copyout_addr(&ad, p);
1705 1.1 itojun q = pfr_lookup_addr(kt, &ad, 1);
1706 1.1 itojun if (q != NULL) {
1707 1.1 itojun if (q->pfrke_not != p->pfrke_not)
1708 1.1 itojun SLIST_INSERT_HEAD(&changeq, q,
1709 1.1 itojun pfrke_workq);
1710 1.1 itojun q->pfrke_mark = 1;
1711 1.1 itojun SLIST_INSERT_HEAD(&garbageq, p, pfrke_workq);
1712 1.1 itojun } else {
1713 1.1 itojun p->pfrke_tzero = tzero;
1714 1.1 itojun SLIST_INSERT_HEAD(&addq, p, pfrke_workq);
1715 1.1 itojun }
1716 1.1 itojun }
1717 1.1 itojun pfr_enqueue_addrs(kt, &delq, NULL, ENQUEUE_UNMARKED_ONLY);
1718 1.1 itojun pfr_insert_kentries(kt, &addq, tzero);
1719 1.1 itojun pfr_remove_kentries(kt, &delq);
1720 1.1 itojun pfr_clstats_kentries(&changeq, tzero, INVERT_NEG_FLAG);
1721 1.1 itojun pfr_destroy_kentries(&garbageq);
1722 1.1 itojun } else {
1723 1.1 itojun /* kt cannot contain addresses */
1724 1.1 itojun SWAP(struct radix_node_head *, kt->pfrkt_ip4,
1725 1.1 itojun shadow->pfrkt_ip4);
1726 1.1 itojun SWAP(struct radix_node_head *, kt->pfrkt_ip6,
1727 1.1 itojun shadow->pfrkt_ip6);
1728 1.1 itojun SWAP(int, kt->pfrkt_cnt, shadow->pfrkt_cnt);
1729 1.1 itojun pfr_clstats_ktable(kt, tzero, 1);
1730 1.1 itojun }
1731 1.1 itojun nflags = ((shadow->pfrkt_flags & PFR_TFLAG_USRMASK) |
1732 1.1 itojun (kt->pfrkt_flags & PFR_TFLAG_SETMASK) | PFR_TFLAG_ACTIVE)
1733 1.1 itojun & ~PFR_TFLAG_INACTIVE;
1734 1.1 itojun pfr_destroy_ktable(shadow, 0);
1735 1.1 itojun kt->pfrkt_shadow = NULL;
1736 1.1 itojun pfr_setflags_ktable(kt, nflags);
1737 1.1 itojun }
1738 1.1 itojun
1739 1.1 itojun int
1740 1.1 itojun pfr_validate_table(struct pfr_table *tbl, int allowedflags, int no_reserved)
1741 1.1 itojun {
1742 1.1 itojun int i;
1743 1.1 itojun
1744 1.1 itojun if (!tbl->pfrt_name[0])
1745 1.1 itojun return (-1);
1746 1.1 itojun if (no_reserved && !strcmp(tbl->pfrt_anchor, PF_RESERVED_ANCHOR))
1747 1.1 itojun return (-1);
1748 1.1 itojun if (tbl->pfrt_name[PF_TABLE_NAME_SIZE-1])
1749 1.1 itojun return (-1);
1750 1.1 itojun for (i = strlen(tbl->pfrt_name); i < PF_TABLE_NAME_SIZE; i++)
1751 1.1 itojun if (tbl->pfrt_name[i])
1752 1.1 itojun return (-1);
1753 1.6 peter if (pfr_fix_anchor(tbl->pfrt_anchor))
1754 1.6 peter return (-1);
1755 1.1 itojun if (tbl->pfrt_flags & ~allowedflags)
1756 1.1 itojun return (-1);
1757 1.1 itojun return (0);
1758 1.1 itojun }
1759 1.1 itojun
1760 1.6 peter /*
1761 1.6 peter * Rewrite anchors referenced by tables to remove slashes
1762 1.6 peter * and check for validity.
1763 1.6 peter */
1764 1.6 peter int
1765 1.6 peter pfr_fix_anchor(char *anchor)
1766 1.6 peter {
1767 1.6 peter size_t siz = MAXPATHLEN;
1768 1.6 peter int i;
1769 1.6 peter
1770 1.6 peter if (anchor[0] == '/') {
1771 1.6 peter char *path;
1772 1.6 peter int off;
1773 1.6 peter
1774 1.6 peter path = anchor;
1775 1.6 peter off = 1;
1776 1.6 peter while (*++path == '/')
1777 1.6 peter off++;
1778 1.6 peter bcopy(path, anchor, siz - off);
1779 1.6 peter memset(anchor + siz - off, 0, off);
1780 1.6 peter }
1781 1.6 peter if (anchor[siz - 1])
1782 1.6 peter return (-1);
1783 1.6 peter for (i = strlen(anchor); i < siz; i++)
1784 1.6 peter if (anchor[i])
1785 1.6 peter return (-1);
1786 1.6 peter return (0);
1787 1.6 peter }
1788 1.6 peter
1789 1.1 itojun int
1790 1.1 itojun pfr_table_count(struct pfr_table *filter, int flags)
1791 1.1 itojun {
1792 1.1 itojun struct pf_ruleset *rs;
1793 1.1 itojun
1794 1.1 itojun if (flags & PFR_FLAG_ALLRSETS)
1795 1.1 itojun return (pfr_ktable_cnt);
1796 1.5 yamt if (filter->pfrt_anchor[0]) {
1797 1.5 yamt rs = pf_find_ruleset(filter->pfrt_anchor);
1798 1.1 itojun return ((rs != NULL) ? rs->tables : -1);
1799 1.1 itojun }
1800 1.1 itojun return (pf_main_ruleset.tables);
1801 1.1 itojun }
1802 1.1 itojun
1803 1.1 itojun int
1804 1.1 itojun pfr_skip_table(struct pfr_table *filter, struct pfr_ktable *kt, int flags)
1805 1.1 itojun {
1806 1.1 itojun if (flags & PFR_FLAG_ALLRSETS)
1807 1.1 itojun return (0);
1808 1.5 yamt if (strcmp(filter->pfrt_anchor, kt->pfrkt_anchor))
1809 1.1 itojun return (1);
1810 1.1 itojun return (0);
1811 1.1 itojun }
1812 1.1 itojun
1813 1.1 itojun void
1814 1.1 itojun pfr_insert_ktables(struct pfr_ktableworkq *workq)
1815 1.1 itojun {
1816 1.1 itojun struct pfr_ktable *p;
1817 1.1 itojun
1818 1.1 itojun SLIST_FOREACH(p, workq, pfrkt_workq)
1819 1.1 itojun pfr_insert_ktable(p);
1820 1.1 itojun }
1821 1.1 itojun
1822 1.1 itojun void
1823 1.1 itojun pfr_insert_ktable(struct pfr_ktable *kt)
1824 1.1 itojun {
1825 1.1 itojun RB_INSERT(pfr_ktablehead, &pfr_ktables, kt);
1826 1.1 itojun pfr_ktable_cnt++;
1827 1.1 itojun if (kt->pfrkt_root != NULL)
1828 1.1 itojun if (!kt->pfrkt_root->pfrkt_refcnt[PFR_REFCNT_ANCHOR]++)
1829 1.1 itojun pfr_setflags_ktable(kt->pfrkt_root,
1830 1.1 itojun kt->pfrkt_root->pfrkt_flags|PFR_TFLAG_REFDANCHOR);
1831 1.1 itojun }
1832 1.1 itojun
1833 1.1 itojun void
1834 1.1 itojun pfr_setflags_ktables(struct pfr_ktableworkq *workq)
1835 1.1 itojun {
1836 1.4 yamt struct pfr_ktable *p, *q;
1837 1.1 itojun
1838 1.4 yamt for (p = SLIST_FIRST(workq); p; p = q) {
1839 1.4 yamt q = SLIST_NEXT(p, pfrkt_workq);
1840 1.1 itojun pfr_setflags_ktable(p, p->pfrkt_nflags);
1841 1.4 yamt }
1842 1.1 itojun }
1843 1.1 itojun
1844 1.1 itojun void
1845 1.1 itojun pfr_setflags_ktable(struct pfr_ktable *kt, int newf)
1846 1.1 itojun {
1847 1.1 itojun struct pfr_kentryworkq addrq;
1848 1.1 itojun
1849 1.1 itojun if (!(newf & PFR_TFLAG_REFERENCED) &&
1850 1.1 itojun !(newf & PFR_TFLAG_PERSIST))
1851 1.1 itojun newf &= ~PFR_TFLAG_ACTIVE;
1852 1.1 itojun if (!(newf & PFR_TFLAG_ACTIVE))
1853 1.1 itojun newf &= ~PFR_TFLAG_USRMASK;
1854 1.1 itojun if (!(newf & PFR_TFLAG_SETMASK)) {
1855 1.1 itojun RB_REMOVE(pfr_ktablehead, &pfr_ktables, kt);
1856 1.1 itojun if (kt->pfrkt_root != NULL)
1857 1.1 itojun if (!--kt->pfrkt_root->pfrkt_refcnt[PFR_REFCNT_ANCHOR])
1858 1.1 itojun pfr_setflags_ktable(kt->pfrkt_root,
1859 1.1 itojun kt->pfrkt_root->pfrkt_flags &
1860 1.1 itojun ~PFR_TFLAG_REFDANCHOR);
1861 1.1 itojun pfr_destroy_ktable(kt, 1);
1862 1.1 itojun pfr_ktable_cnt--;
1863 1.1 itojun return;
1864 1.1 itojun }
1865 1.1 itojun if (!(newf & PFR_TFLAG_ACTIVE) && kt->pfrkt_cnt) {
1866 1.1 itojun pfr_enqueue_addrs(kt, &addrq, NULL, 0);
1867 1.1 itojun pfr_remove_kentries(kt, &addrq);
1868 1.1 itojun }
1869 1.1 itojun if (!(newf & PFR_TFLAG_INACTIVE) && kt->pfrkt_shadow != NULL) {
1870 1.1 itojun pfr_destroy_ktable(kt->pfrkt_shadow, 1);
1871 1.1 itojun kt->pfrkt_shadow = NULL;
1872 1.1 itojun }
1873 1.1 itojun kt->pfrkt_flags = newf;
1874 1.1 itojun }
1875 1.1 itojun
1876 1.1 itojun void
1877 1.1 itojun pfr_clstats_ktables(struct pfr_ktableworkq *workq, long tzero, int recurse)
1878 1.1 itojun {
1879 1.1 itojun struct pfr_ktable *p;
1880 1.1 itojun
1881 1.1 itojun SLIST_FOREACH(p, workq, pfrkt_workq)
1882 1.1 itojun pfr_clstats_ktable(p, tzero, recurse);
1883 1.1 itojun }
1884 1.1 itojun
1885 1.1 itojun void
1886 1.1 itojun pfr_clstats_ktable(struct pfr_ktable *kt, long tzero, int recurse)
1887 1.1 itojun {
1888 1.1 itojun struct pfr_kentryworkq addrq;
1889 1.1 itojun int s;
1890 1.1 itojun
1891 1.1 itojun if (recurse) {
1892 1.1 itojun pfr_enqueue_addrs(kt, &addrq, NULL, 0);
1893 1.1 itojun pfr_clstats_kentries(&addrq, tzero, 0);
1894 1.1 itojun }
1895 1.1 itojun s = splsoftnet();
1896 1.1 itojun bzero(kt->pfrkt_packets, sizeof(kt->pfrkt_packets));
1897 1.1 itojun bzero(kt->pfrkt_bytes, sizeof(kt->pfrkt_bytes));
1898 1.1 itojun kt->pfrkt_match = kt->pfrkt_nomatch = 0;
1899 1.1 itojun splx(s);
1900 1.1 itojun kt->pfrkt_tzero = tzero;
1901 1.1 itojun }
1902 1.1 itojun
1903 1.1 itojun struct pfr_ktable *
1904 1.1 itojun pfr_create_ktable(struct pfr_table *tbl, long tzero, int attachruleset)
1905 1.1 itojun {
1906 1.1 itojun struct pfr_ktable *kt;
1907 1.1 itojun struct pf_ruleset *rs;
1908 1.9 peter void *h4 = NULL, *h6 = NULL;
1909 1.1 itojun
1910 1.1 itojun kt = pool_get(&pfr_ktable_pl, PR_NOWAIT);
1911 1.1 itojun if (kt == NULL)
1912 1.1 itojun return (NULL);
1913 1.1 itojun bzero(kt, sizeof(*kt));
1914 1.1 itojun kt->pfrkt_t = *tbl;
1915 1.1 itojun
1916 1.1 itojun if (attachruleset) {
1917 1.5 yamt rs = pf_find_or_create_ruleset(tbl->pfrt_anchor);
1918 1.1 itojun if (!rs) {
1919 1.1 itojun pfr_destroy_ktable(kt, 0);
1920 1.1 itojun return (NULL);
1921 1.1 itojun }
1922 1.1 itojun kt->pfrkt_rs = rs;
1923 1.1 itojun rs->tables++;
1924 1.1 itojun }
1925 1.1 itojun
1926 1.8 christos if (!rn_inithead(&h4, offsetof(struct sockaddr_in, sin_addr) * 8))
1927 1.8 christos goto out;
1928 1.8 christos
1929 1.8 christos if (!rn_inithead(&h6, offsetof(struct sockaddr_in6, sin6_addr) * 8)) {
1930 1.8 christos Free(h4);
1931 1.8 christos goto out;
1932 1.1 itojun }
1933 1.8 christos kt->pfrkt_ip4 = h4;
1934 1.8 christos kt->pfrkt_ip6 = h6;
1935 1.1 itojun kt->pfrkt_tzero = tzero;
1936 1.1 itojun
1937 1.1 itojun return (kt);
1938 1.8 christos out:
1939 1.8 christos pfr_destroy_ktable(kt, 0);
1940 1.8 christos return (NULL);
1941 1.1 itojun }
1942 1.1 itojun
1943 1.1 itojun void
1944 1.1 itojun pfr_destroy_ktables(struct pfr_ktableworkq *workq, int flushaddr)
1945 1.1 itojun {
1946 1.1 itojun struct pfr_ktable *p, *q;
1947 1.1 itojun
1948 1.1 itojun for (p = SLIST_FIRST(workq); p; p = q) {
1949 1.1 itojun q = SLIST_NEXT(p, pfrkt_workq);
1950 1.1 itojun pfr_destroy_ktable(p, flushaddr);
1951 1.1 itojun }
1952 1.1 itojun }
1953 1.1 itojun
1954 1.1 itojun void
1955 1.1 itojun pfr_destroy_ktable(struct pfr_ktable *kt, int flushaddr)
1956 1.1 itojun {
1957 1.1 itojun struct pfr_kentryworkq addrq;
1958 1.1 itojun
1959 1.1 itojun if (flushaddr) {
1960 1.1 itojun pfr_enqueue_addrs(kt, &addrq, NULL, 0);
1961 1.1 itojun pfr_clean_node_mask(kt, &addrq);
1962 1.1 itojun pfr_destroy_kentries(&addrq);
1963 1.1 itojun }
1964 1.1 itojun if (kt->pfrkt_ip4 != NULL)
1965 1.11 christos free((void *)kt->pfrkt_ip4, M_RTABLE);
1966 1.1 itojun if (kt->pfrkt_ip6 != NULL)
1967 1.11 christos free((void *)kt->pfrkt_ip6, M_RTABLE);
1968 1.1 itojun if (kt->pfrkt_shadow != NULL)
1969 1.1 itojun pfr_destroy_ktable(kt->pfrkt_shadow, flushaddr);
1970 1.1 itojun if (kt->pfrkt_rs != NULL) {
1971 1.1 itojun kt->pfrkt_rs->tables--;
1972 1.1 itojun pf_remove_if_empty_ruleset(kt->pfrkt_rs);
1973 1.1 itojun }
1974 1.1 itojun pool_put(&pfr_ktable_pl, kt);
1975 1.1 itojun }
1976 1.1 itojun
1977 1.1 itojun int
1978 1.1 itojun pfr_ktable_compare(struct pfr_ktable *p, struct pfr_ktable *q)
1979 1.1 itojun {
1980 1.1 itojun int d;
1981 1.1 itojun
1982 1.1 itojun if ((d = strncmp(p->pfrkt_name, q->pfrkt_name, PF_TABLE_NAME_SIZE)))
1983 1.1 itojun return (d);
1984 1.5 yamt return (strcmp(p->pfrkt_anchor, q->pfrkt_anchor));
1985 1.1 itojun }
1986 1.1 itojun
1987 1.1 itojun struct pfr_ktable *
1988 1.1 itojun pfr_lookup_table(struct pfr_table *tbl)
1989 1.1 itojun {
1990 1.1 itojun /* struct pfr_ktable start like a struct pfr_table */
1991 1.1 itojun return (RB_FIND(pfr_ktablehead, &pfr_ktables,
1992 1.1 itojun (struct pfr_ktable *)tbl));
1993 1.1 itojun }
1994 1.1 itojun
1995 1.1 itojun int
1996 1.1 itojun pfr_match_addr(struct pfr_ktable *kt, struct pf_addr *a, sa_family_t af)
1997 1.1 itojun {
1998 1.1 itojun struct pfr_kentry *ke = NULL;
1999 1.1 itojun int match;
2000 1.1 itojun
2001 1.1 itojun if (!(kt->pfrkt_flags & PFR_TFLAG_ACTIVE) && kt->pfrkt_root != NULL)
2002 1.1 itojun kt = kt->pfrkt_root;
2003 1.1 itojun if (!(kt->pfrkt_flags & PFR_TFLAG_ACTIVE))
2004 1.1 itojun return (0);
2005 1.1 itojun
2006 1.1 itojun switch (af) {
2007 1.5 yamt #ifdef INET
2008 1.1 itojun case AF_INET:
2009 1.1 itojun pfr_sin.sin_addr.s_addr = a->addr32[0];
2010 1.1 itojun ke = (struct pfr_kentry *)rn_match(&pfr_sin, kt->pfrkt_ip4);
2011 1.1 itojun if (ke && KENTRY_RNF_ROOT(ke))
2012 1.1 itojun ke = NULL;
2013 1.1 itojun break;
2014 1.5 yamt #endif /* INET */
2015 1.5 yamt #ifdef INET6
2016 1.1 itojun case AF_INET6:
2017 1.1 itojun bcopy(a, &pfr_sin6.sin6_addr, sizeof(pfr_sin6.sin6_addr));
2018 1.1 itojun ke = (struct pfr_kentry *)rn_match(&pfr_sin6, kt->pfrkt_ip6);
2019 1.1 itojun if (ke && KENTRY_RNF_ROOT(ke))
2020 1.1 itojun ke = NULL;
2021 1.1 itojun break;
2022 1.5 yamt #endif /* INET6 */
2023 1.1 itojun }
2024 1.1 itojun match = (ke && !ke->pfrke_not);
2025 1.1 itojun if (match)
2026 1.1 itojun kt->pfrkt_match++;
2027 1.1 itojun else
2028 1.1 itojun kt->pfrkt_nomatch++;
2029 1.1 itojun return (match);
2030 1.1 itojun }
2031 1.1 itojun
2032 1.1 itojun void
2033 1.1 itojun pfr_update_stats(struct pfr_ktable *kt, struct pf_addr *a, sa_family_t af,
2034 1.1 itojun u_int64_t len, int dir_out, int op_pass, int notrule)
2035 1.1 itojun {
2036 1.1 itojun struct pfr_kentry *ke = NULL;
2037 1.1 itojun
2038 1.1 itojun if (!(kt->pfrkt_flags & PFR_TFLAG_ACTIVE) && kt->pfrkt_root != NULL)
2039 1.1 itojun kt = kt->pfrkt_root;
2040 1.1 itojun if (!(kt->pfrkt_flags & PFR_TFLAG_ACTIVE))
2041 1.1 itojun return;
2042 1.1 itojun
2043 1.1 itojun switch (af) {
2044 1.5 yamt #ifdef INET
2045 1.1 itojun case AF_INET:
2046 1.1 itojun pfr_sin.sin_addr.s_addr = a->addr32[0];
2047 1.1 itojun ke = (struct pfr_kentry *)rn_match(&pfr_sin, kt->pfrkt_ip4);
2048 1.1 itojun if (ke && KENTRY_RNF_ROOT(ke))
2049 1.1 itojun ke = NULL;
2050 1.1 itojun break;
2051 1.5 yamt #endif /* INET */
2052 1.5 yamt #ifdef INET6
2053 1.1 itojun case AF_INET6:
2054 1.1 itojun bcopy(a, &pfr_sin6.sin6_addr, sizeof(pfr_sin6.sin6_addr));
2055 1.1 itojun ke = (struct pfr_kentry *)rn_match(&pfr_sin6, kt->pfrkt_ip6);
2056 1.1 itojun if (ke && KENTRY_RNF_ROOT(ke))
2057 1.1 itojun ke = NULL;
2058 1.1 itojun break;
2059 1.5 yamt #endif /* INET6 */
2060 1.5 yamt default:
2061 1.5 yamt ;
2062 1.1 itojun }
2063 1.1 itojun if ((ke == NULL || ke->pfrke_not) != notrule) {
2064 1.1 itojun if (op_pass != PFR_OP_PASS)
2065 1.1 itojun printf("pfr_update_stats: assertion failed.\n");
2066 1.1 itojun op_pass = PFR_OP_XPASS;
2067 1.1 itojun }
2068 1.1 itojun kt->pfrkt_packets[dir_out][op_pass]++;
2069 1.1 itojun kt->pfrkt_bytes[dir_out][op_pass] += len;
2070 1.1 itojun if (ke != NULL && op_pass != PFR_OP_XPASS) {
2071 1.1 itojun ke->pfrke_packets[dir_out][op_pass]++;
2072 1.1 itojun ke->pfrke_bytes[dir_out][op_pass] += len;
2073 1.1 itojun }
2074 1.1 itojun }
2075 1.1 itojun
2076 1.1 itojun struct pfr_ktable *
2077 1.1 itojun pfr_attach_table(struct pf_ruleset *rs, char *name)
2078 1.1 itojun {
2079 1.1 itojun struct pfr_ktable *kt, *rt;
2080 1.1 itojun struct pfr_table tbl;
2081 1.1 itojun struct pf_anchor *ac = rs->anchor;
2082 1.1 itojun
2083 1.1 itojun bzero(&tbl, sizeof(tbl));
2084 1.1 itojun strlcpy(tbl.pfrt_name, name, sizeof(tbl.pfrt_name));
2085 1.5 yamt if (ac != NULL)
2086 1.1 itojun strlcpy(tbl.pfrt_anchor, ac->name, sizeof(tbl.pfrt_anchor));
2087 1.1 itojun kt = pfr_lookup_table(&tbl);
2088 1.1 itojun if (kt == NULL) {
2089 1.5 yamt kt = pfr_create_ktable(&tbl, time_second, 1);
2090 1.1 itojun if (kt == NULL)
2091 1.1 itojun return (NULL);
2092 1.1 itojun if (ac != NULL) {
2093 1.1 itojun bzero(tbl.pfrt_anchor, sizeof(tbl.pfrt_anchor));
2094 1.1 itojun rt = pfr_lookup_table(&tbl);
2095 1.1 itojun if (rt == NULL) {
2096 1.1 itojun rt = pfr_create_ktable(&tbl, 0, 1);
2097 1.1 itojun if (rt == NULL) {
2098 1.1 itojun pfr_destroy_ktable(kt, 0);
2099 1.1 itojun return (NULL);
2100 1.1 itojun }
2101 1.1 itojun pfr_insert_ktable(rt);
2102 1.1 itojun }
2103 1.1 itojun kt->pfrkt_root = rt;
2104 1.1 itojun }
2105 1.1 itojun pfr_insert_ktable(kt);
2106 1.1 itojun }
2107 1.1 itojun if (!kt->pfrkt_refcnt[PFR_REFCNT_RULE]++)
2108 1.1 itojun pfr_setflags_ktable(kt, kt->pfrkt_flags|PFR_TFLAG_REFERENCED);
2109 1.1 itojun return (kt);
2110 1.1 itojun }
2111 1.1 itojun
2112 1.1 itojun void
2113 1.1 itojun pfr_detach_table(struct pfr_ktable *kt)
2114 1.1 itojun {
2115 1.1 itojun if (kt->pfrkt_refcnt[PFR_REFCNT_RULE] <= 0)
2116 1.1 itojun printf("pfr_detach_table: refcount = %d.\n",
2117 1.1 itojun kt->pfrkt_refcnt[PFR_REFCNT_RULE]);
2118 1.1 itojun else if (!--kt->pfrkt_refcnt[PFR_REFCNT_RULE])
2119 1.1 itojun pfr_setflags_ktable(kt, kt->pfrkt_flags&~PFR_TFLAG_REFERENCED);
2120 1.1 itojun }
2121 1.1 itojun
2122 1.1 itojun int
2123 1.1 itojun pfr_pool_get(struct pfr_ktable *kt, int *pidx, struct pf_addr *counter,
2124 1.1 itojun struct pf_addr **raddr, struct pf_addr **rmask, sa_family_t af)
2125 1.1 itojun {
2126 1.5 yamt struct pfr_kentry *ke, *ke2 = (void *)0xdeadb;
2127 1.5 yamt struct pf_addr *addr = (void *)0xdeadb;
2128 1.1 itojun union sockaddr_union mask;
2129 1.1 itojun int idx = -1, use_counter = 0;
2130 1.1 itojun
2131 1.5 yamt if (af == AF_INET)
2132 1.5 yamt addr = (struct pf_addr *)&pfr_sin.sin_addr;
2133 1.5 yamt else if (af == AF_INET6)
2134 1.5 yamt addr = (struct pf_addr *)&pfr_sin6.sin6_addr;
2135 1.1 itojun if (!(kt->pfrkt_flags & PFR_TFLAG_ACTIVE) && kt->pfrkt_root != NULL)
2136 1.1 itojun kt = kt->pfrkt_root;
2137 1.1 itojun if (!(kt->pfrkt_flags & PFR_TFLAG_ACTIVE))
2138 1.1 itojun return (-1);
2139 1.1 itojun
2140 1.1 itojun if (pidx != NULL)
2141 1.1 itojun idx = *pidx;
2142 1.1 itojun if (counter != NULL && idx >= 0)
2143 1.1 itojun use_counter = 1;
2144 1.1 itojun if (idx < 0)
2145 1.1 itojun idx = 0;
2146 1.1 itojun
2147 1.1 itojun _next_block:
2148 1.1 itojun ke = pfr_kentry_byidx(kt, idx, af);
2149 1.1 itojun if (ke == NULL)
2150 1.1 itojun return (1);
2151 1.1 itojun pfr_prepare_network(&pfr_mask, af, ke->pfrke_net);
2152 1.1 itojun *raddr = SUNION2PF(&ke->pfrke_sa, af);
2153 1.1 itojun *rmask = SUNION2PF(&pfr_mask, af);
2154 1.1 itojun
2155 1.1 itojun if (use_counter) {
2156 1.1 itojun /* is supplied address within block? */
2157 1.1 itojun if (!PF_MATCHA(0, *raddr, *rmask, counter, af)) {
2158 1.1 itojun /* no, go to next block in table */
2159 1.1 itojun idx++;
2160 1.1 itojun use_counter = 0;
2161 1.1 itojun goto _next_block;
2162 1.1 itojun }
2163 1.1 itojun PF_ACPY(addr, counter, af);
2164 1.1 itojun } else {
2165 1.1 itojun /* use first address of block */
2166 1.1 itojun PF_ACPY(addr, *raddr, af);
2167 1.1 itojun }
2168 1.1 itojun
2169 1.1 itojun if (!KENTRY_NETWORK(ke)) {
2170 1.1 itojun /* this is a single IP address - no possible nested block */
2171 1.1 itojun PF_ACPY(counter, addr, af);
2172 1.1 itojun *pidx = idx;
2173 1.1 itojun return (0);
2174 1.1 itojun }
2175 1.1 itojun for (;;) {
2176 1.1 itojun /* we don't want to use a nested block */
2177 1.5 yamt if (af == AF_INET)
2178 1.5 yamt ke2 = (struct pfr_kentry *)rn_match(&pfr_sin,
2179 1.5 yamt kt->pfrkt_ip4);
2180 1.5 yamt else if (af == AF_INET6)
2181 1.5 yamt ke2 = (struct pfr_kentry *)rn_match(&pfr_sin6,
2182 1.5 yamt kt->pfrkt_ip6);
2183 1.1 itojun /* no need to check KENTRY_RNF_ROOT() here */
2184 1.1 itojun if (ke2 == ke) {
2185 1.1 itojun /* lookup return the same block - perfect */
2186 1.1 itojun PF_ACPY(counter, addr, af);
2187 1.1 itojun *pidx = idx;
2188 1.1 itojun return (0);
2189 1.1 itojun }
2190 1.1 itojun
2191 1.1 itojun /* we need to increase the counter past the nested block */
2192 1.1 itojun pfr_prepare_network(&mask, AF_INET, ke2->pfrke_net);
2193 1.1 itojun PF_POOLMASK(addr, addr, SUNION2PF(&mask, af), &pfr_ffaddr, af);
2194 1.1 itojun PF_AINC(addr, af);
2195 1.1 itojun if (!PF_MATCHA(0, *raddr, *rmask, addr, af)) {
2196 1.1 itojun /* ok, we reached the end of our main block */
2197 1.1 itojun /* go to next block in table */
2198 1.1 itojun idx++;
2199 1.1 itojun use_counter = 0;
2200 1.1 itojun goto _next_block;
2201 1.1 itojun }
2202 1.1 itojun }
2203 1.1 itojun }
2204 1.1 itojun
2205 1.1 itojun struct pfr_kentry *
2206 1.1 itojun pfr_kentry_byidx(struct pfr_ktable *kt, int idx, int af)
2207 1.1 itojun {
2208 1.1 itojun struct pfr_walktree w;
2209 1.1 itojun
2210 1.1 itojun bzero(&w, sizeof(w));
2211 1.1 itojun w.pfrw_op = PFRW_POOL_GET;
2212 1.1 itojun w.pfrw_cnt = idx;
2213 1.1 itojun
2214 1.1 itojun switch (af) {
2215 1.5 yamt #ifdef INET
2216 1.1 itojun case AF_INET:
2217 1.1 itojun rn_walktree(kt->pfrkt_ip4, pfr_walktree, &w);
2218 1.1 itojun return (w.pfrw_kentry);
2219 1.5 yamt #endif /* INET */
2220 1.5 yamt #ifdef INET6
2221 1.1 itojun case AF_INET6:
2222 1.1 itojun rn_walktree(kt->pfrkt_ip6, pfr_walktree, &w);
2223 1.1 itojun return (w.pfrw_kentry);
2224 1.5 yamt #endif /* INET6 */
2225 1.1 itojun default:
2226 1.1 itojun return (NULL);
2227 1.1 itojun }
2228 1.1 itojun }
2229 1.1 itojun
2230 1.1 itojun void
2231 1.1 itojun pfr_dynaddr_update(struct pfr_ktable *kt, struct pfi_dynaddr *dyn)
2232 1.1 itojun {
2233 1.1 itojun struct pfr_walktree w;
2234 1.1 itojun int s;
2235 1.1 itojun
2236 1.1 itojun bzero(&w, sizeof(w));
2237 1.1 itojun w.pfrw_op = PFRW_DYNADDR_UPDATE;
2238 1.1 itojun w.pfrw_dyn = dyn;
2239 1.1 itojun
2240 1.1 itojun s = splsoftnet();
2241 1.1 itojun dyn->pfid_acnt4 = 0;
2242 1.1 itojun dyn->pfid_acnt6 = 0;
2243 1.1 itojun if (!dyn->pfid_af || dyn->pfid_af == AF_INET)
2244 1.1 itojun rn_walktree(kt->pfrkt_ip4, pfr_walktree, &w);
2245 1.1 itojun if (!dyn->pfid_af || dyn->pfid_af == AF_INET6)
2246 1.1 itojun rn_walktree(kt->pfrkt_ip6, pfr_walktree, &w);
2247 1.1 itojun splx(s);
2248 1.1 itojun }
2249