Deleted Added
sdiff udiff text old ( 126261 ) new ( 127145 )
full compact
pf_table.c (126261) pf_table.c (127145)
1/* $FreeBSD: head/sys/contrib/pf/net/pf_table.c 126261 2004-02-26 02:34:12Z mlaier $ */
1/* $FreeBSD: head/sys/contrib/pf/net/pf_table.c 127145 2004-03-17 21:11:02Z mlaier $ */
2/* $OpenBSD: pf_table.c,v 1.41 2003/08/22 15:19:23 henning Exp $ */
3
4/*
5 * Copyright (c) 2002 Cedric Berger
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions

--- 16 unchanged lines hidden (view full) ---

26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
27 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
29 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 *
32 */
33
2/* $OpenBSD: pf_table.c,v 1.41 2003/08/22 15:19:23 henning Exp $ */
3
4/*
5 * Copyright (c) 2002 Cedric Berger
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions

--- 16 unchanged lines hidden (view full) ---

26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
27 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
29 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 *
32 */
33
34#if defined(__FreeBSD__)
34#ifdef __FreeBSD__
35#include "opt_inet.h"
36#include "opt_inet6.h"
37#endif
38
39#include <sys/param.h>
40#include <sys/systm.h>
41#include <sys/socket.h>
42#include <sys/mbuf.h>
43#include <sys/kernel.h>
35#include "opt_inet.h"
36#include "opt_inet6.h"
37#endif
38
39#include <sys/param.h>
40#include <sys/systm.h>
41#include <sys/socket.h>
42#include <sys/mbuf.h>
43#include <sys/kernel.h>
44#if defined(__FreeBSD__)
44#ifdef __FreeBSD__
45#include <sys/malloc.h>
46#endif
47
48#include <net/if.h>
49#include <net/route.h>
50#include <netinet/in.h>
45#include <sys/malloc.h>
46#endif
47
48#include <net/if.h>
49#include <net/route.h>
50#include <netinet/in.h>
51#if !defined(__FreeBSD__)
51#ifndef __FreeBSD__
52#include <netinet/ip_ipsp.h>
53#endif
54
55#include <net/pfvar.h>
56
52#include <netinet/ip_ipsp.h>
53#endif
54
55#include <net/pfvar.h>
56
57#if defined(FreeBSD__)
58MALLOC_DECLARE(M_RTABLE);
59#endif
60
61#define ACCEPT_FLAGS(oklist) \
62 do { \
63 if ((flags & ~(oklist)) & \
64 PFR_FLAG_ALLMASK) \
65 return (EINVAL); \
66 } while (0)
67
68#define FILLIN_SIN(sin, addr) \

--- 51 unchanged lines hidden (view full) ---

120#define pfrw_addr pfrw_1.pfrw1_addr
121#define pfrw_astats pfrw_1.pfrw1_astats
122#define pfrw_workq pfrw_1.pfrw1_workq
123#define pfrw_kentry pfrw_1.pfrw1_kentry
124#define pfrw_cnt pfrw_free
125
126#define senderr(e) do { rv = (e); goto _bad; } while (0)
127
57#define ACCEPT_FLAGS(oklist) \
58 do { \
59 if ((flags & ~(oklist)) & \
60 PFR_FLAG_ALLMASK) \
61 return (EINVAL); \
62 } while (0)
63
64#define FILLIN_SIN(sin, addr) \

--- 51 unchanged lines hidden (view full) ---

116#define pfrw_addr pfrw_1.pfrw1_addr
117#define pfrw_astats pfrw_1.pfrw1_astats
118#define pfrw_workq pfrw_1.pfrw1_workq
119#define pfrw_kentry pfrw_1.pfrw1_kentry
120#define pfrw_cnt pfrw_free
121
122#define senderr(e) do { rv = (e); goto _bad; } while (0)
123
128#if defined(__FreeBSD__)
124#ifdef __FreeBSD__
129uma_zone_t pfr_ktable_pl;
130uma_zone_t pfr_kentry_pl;
131#else
132struct pool pfr_ktable_pl;
133struct pool pfr_kentry_pl;
134#endif
135struct sockaddr_in pfr_sin;
136struct sockaddr_in6 pfr_sin6;

--- 51 unchanged lines hidden (view full) ---

188
189struct pfr_ktablehead pfr_ktables;
190struct pfr_table pfr_nulltable;
191int pfr_ktable_cnt;
192
193void
194pfr_initialize(void)
195{
125uma_zone_t pfr_ktable_pl;
126uma_zone_t pfr_kentry_pl;
127#else
128struct pool pfr_ktable_pl;
129struct pool pfr_kentry_pl;
130#endif
131struct sockaddr_in pfr_sin;
132struct sockaddr_in6 pfr_sin6;

--- 51 unchanged lines hidden (view full) ---

184
185struct pfr_ktablehead pfr_ktables;
186struct pfr_table pfr_nulltable;
187int pfr_ktable_cnt;
188
189void
190pfr_initialize(void)
191{
196#if !defined(__FreeBSD__)
192#ifndef __FreeBSD__
197 pool_init(&pfr_ktable_pl, sizeof(struct pfr_ktable), 0, 0, 0,
198 "pfrktable", NULL);
199 pool_init(&pfr_kentry_pl, sizeof(struct pfr_kentry), 0, 0, 0,
200 "pfrkentry", NULL);
201#endif
202
203 pfr_sin.sin_len = sizeof(pfr_sin);
204 pfr_sin.sin_family = AF_INET;

--- 39 unchanged lines hidden (view full) ---

244pfr_add_addrs(struct pfr_table *tbl, struct pfr_addr *addr, int size,
245 int *nadd, int flags)
246{
247 struct pfr_ktable *kt, *tmpkt;
248 struct pfr_kentryworkq workq;
249 struct pfr_kentry *p, *q;
250 struct pfr_addr ad;
251 int i, rv, s, xadd = 0;
193 pool_init(&pfr_ktable_pl, sizeof(struct pfr_ktable), 0, 0, 0,
194 "pfrktable", NULL);
195 pool_init(&pfr_kentry_pl, sizeof(struct pfr_kentry), 0, 0, 0,
196 "pfrkentry", NULL);
197#endif
198
199 pfr_sin.sin_len = sizeof(pfr_sin);
200 pfr_sin.sin_family = AF_INET;

--- 39 unchanged lines hidden (view full) ---

240pfr_add_addrs(struct pfr_table *tbl, struct pfr_addr *addr, int size,
241 int *nadd, int flags)
242{
243 struct pfr_ktable *kt, *tmpkt;
244 struct pfr_kentryworkq workq;
245 struct pfr_kentry *p, *q;
246 struct pfr_addr ad;
247 int i, rv, s, xadd = 0;
252#if defined(__FreeBSD__)
248#ifdef __FreeBSD__
253 int ec;
254 /*
255 * XXX Is it OK under LP64 environments?
256 */
257 long tzero = (long)time_second;
258#else
259 long tzero = time.tv_sec;
260#endif

--- 6 unchanged lines hidden (view full) ---

267 return (ESRCH);
268 if (kt->pfrkt_flags & PFR_TFLAG_CONST)
269 return (EPERM);
270 tmpkt = pfr_create_ktable(&pfr_nulltable, 0, 0);
271 if (tmpkt == NULL)
272 return (ENOMEM);
273 SLIST_INIT(&workq);
274 for (i = 0; i < size; i++) {
249 int ec;
250 /*
251 * XXX Is it OK under LP64 environments?
252 */
253 long tzero = (long)time_second;
254#else
255 long tzero = time.tv_sec;
256#endif

--- 6 unchanged lines hidden (view full) ---

263 return (ESRCH);
264 if (kt->pfrkt_flags & PFR_TFLAG_CONST)
265 return (EPERM);
266 tmpkt = pfr_create_ktable(&pfr_nulltable, 0, 0);
267 if (tmpkt == NULL)
268 return (ENOMEM);
269 SLIST_INIT(&workq);
270 for (i = 0; i < size; i++) {
275#if defined(__FreeBSD__)
271#ifdef __FreeBSD__
276 PF_COPYIN(addr+i, &ad, sizeof(ad), ec);
277 if (ec)
278 senderr(EFAULT);
279#else
280 if (copyin(addr+i, &ad, sizeof(ad)))
281 senderr(EFAULT);
282#endif
283 if (pfr_validate_addr(&ad))

--- 17 unchanged lines hidden (view full) ---

301 if (pfr_route_kentry(tmpkt, p)) {
302 pfr_destroy_kentry(p);
303 ad.pfra_fback = PFR_FB_NONE;
304 } else {
305 SLIST_INSERT_HEAD(&workq, p, pfrke_workq);
306 xadd++;
307 }
308 }
272 PF_COPYIN(addr+i, &ad, sizeof(ad), ec);
273 if (ec)
274 senderr(EFAULT);
275#else
276 if (copyin(addr+i, &ad, sizeof(ad)))
277 senderr(EFAULT);
278#endif
279 if (pfr_validate_addr(&ad))

--- 17 unchanged lines hidden (view full) ---

297 if (pfr_route_kentry(tmpkt, p)) {
298 pfr_destroy_kentry(p);
299 ad.pfra_fback = PFR_FB_NONE;
300 } else {
301 SLIST_INSERT_HEAD(&workq, p, pfrke_workq);
302 xadd++;
303 }
304 }
309#if defined(__FreeBSD__)
305#ifdef __FreeBSD__
310 if (flags & PFR_FLAG_FEEDBACK) {
311 PF_COPYOUT(&ad, addr+i, sizeof(ad), ec);
312 if (ec)
313 senderr(EFAULT);
314 }
315#else
316 if (flags & PFR_FLAG_FEEDBACK)
317 if (copyout(&ad, addr+i, sizeof(ad)))

--- 26 unchanged lines hidden (view full) ---

344pfr_del_addrs(struct pfr_table *tbl, struct pfr_addr *addr, int size,
345 int *ndel, int flags)
346{
347 struct pfr_ktable *kt;
348 struct pfr_kentryworkq workq;
349 struct pfr_kentry *p;
350 struct pfr_addr ad;
351 int i, rv, s, xdel = 0;
306 if (flags & PFR_FLAG_FEEDBACK) {
307 PF_COPYOUT(&ad, addr+i, sizeof(ad), ec);
308 if (ec)
309 senderr(EFAULT);
310 }
311#else
312 if (flags & PFR_FLAG_FEEDBACK)
313 if (copyout(&ad, addr+i, sizeof(ad)))

--- 26 unchanged lines hidden (view full) ---

340pfr_del_addrs(struct pfr_table *tbl, struct pfr_addr *addr, int size,
341 int *ndel, int flags)
342{
343 struct pfr_ktable *kt;
344 struct pfr_kentryworkq workq;
345 struct pfr_kentry *p;
346 struct pfr_addr ad;
347 int i, rv, s, xdel = 0;
352#if defined(__FreeBSD__)
348#ifdef __FreeBSD__
353 int ec;
354#endif
355
356 ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY+PFR_FLAG_FEEDBACK);
357 if (pfr_validate_table(tbl, 0))
358 return (EINVAL);
359 kt = pfr_lookup_table(tbl);
360 if (kt == NULL || !(kt->pfrkt_flags & PFR_TFLAG_ACTIVE))
361 return (ESRCH);
362 if (kt->pfrkt_flags & PFR_TFLAG_CONST)
363 return (EPERM);
364 pfr_mark_addrs(kt);
365 SLIST_INIT(&workq);
366 for (i = 0; i < size; i++) {
349 int ec;
350#endif
351
352 ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY+PFR_FLAG_FEEDBACK);
353 if (pfr_validate_table(tbl, 0))
354 return (EINVAL);
355 kt = pfr_lookup_table(tbl);
356 if (kt == NULL || !(kt->pfrkt_flags & PFR_TFLAG_ACTIVE))
357 return (ESRCH);
358 if (kt->pfrkt_flags & PFR_TFLAG_CONST)
359 return (EPERM);
360 pfr_mark_addrs(kt);
361 SLIST_INIT(&workq);
362 for (i = 0; i < size; i++) {
367#if defined(__FreeBSD__)
363#ifdef __FreeBSD__
368 PF_COPYIN(addr+i, &ad, sizeof(ad), ec);
369 if (ec)
370 senderr(EFAULT);
371#else
372 if (copyin(addr+i, &ad, sizeof(ad)))
373 senderr(EFAULT);
374#endif
375 if (pfr_validate_addr(&ad))

--- 10 unchanged lines hidden (view full) ---

386 ad.pfra_fback = PFR_FB_DELETED;
387 }
388 if (p != NULL && p->pfrke_not == ad.pfra_not &&
389 !p->pfrke_mark) {
390 p->pfrke_mark = 1;
391 SLIST_INSERT_HEAD(&workq, p, pfrke_workq);
392 xdel++;
393 }
364 PF_COPYIN(addr+i, &ad, sizeof(ad), ec);
365 if (ec)
366 senderr(EFAULT);
367#else
368 if (copyin(addr+i, &ad, sizeof(ad)))
369 senderr(EFAULT);
370#endif
371 if (pfr_validate_addr(&ad))

--- 10 unchanged lines hidden (view full) ---

382 ad.pfra_fback = PFR_FB_DELETED;
383 }
384 if (p != NULL && p->pfrke_not == ad.pfra_not &&
385 !p->pfrke_mark) {
386 p->pfrke_mark = 1;
387 SLIST_INSERT_HEAD(&workq, p, pfrke_workq);
388 xdel++;
389 }
394#if defined(__FreeBSD__)
390#ifdef __FreeBSD__
395 if (flags & PFR_FLAG_FEEDBACK) {
396 PF_COPYOUT(&ad, addr+i, sizeof(ad), ec);
397 if (ec)
398 senderr(EFAULT);
399 }
400#else
401 if (flags & PFR_FLAG_FEEDBACK)
402 if (copyout(&ad, addr+i, sizeof(ad)))

--- 20 unchanged lines hidden (view full) ---

423pfr_set_addrs(struct pfr_table *tbl, struct pfr_addr *addr, int size,
424 int *size2, int *nadd, int *ndel, int *nchange, int flags)
425{
426 struct pfr_ktable *kt, *tmpkt;
427 struct pfr_kentryworkq addq, delq, changeq;
428 struct pfr_kentry *p, *q;
429 struct pfr_addr ad;
430 int i, rv, s, xadd = 0, xdel = 0, xchange = 0;
391 if (flags & PFR_FLAG_FEEDBACK) {
392 PF_COPYOUT(&ad, addr+i, sizeof(ad), ec);
393 if (ec)
394 senderr(EFAULT);
395 }
396#else
397 if (flags & PFR_FLAG_FEEDBACK)
398 if (copyout(&ad, addr+i, sizeof(ad)))

--- 20 unchanged lines hidden (view full) ---

419pfr_set_addrs(struct pfr_table *tbl, struct pfr_addr *addr, int size,
420 int *size2, int *nadd, int *ndel, int *nchange, int flags)
421{
422 struct pfr_ktable *kt, *tmpkt;
423 struct pfr_kentryworkq addq, delq, changeq;
424 struct pfr_kentry *p, *q;
425 struct pfr_addr ad;
426 int i, rv, s, xadd = 0, xdel = 0, xchange = 0;
431#if defined(__FreeBSD__)
427#ifdef __FreeBSD__
432 int ec;
433 /*
434 * XXX Is it OK under LP64 environments?
435 */
436 long tzero = (long)time_second;
437#else
438 long tzero = time.tv_sec;
439#endif

--- 9 unchanged lines hidden (view full) ---

449 tmpkt = pfr_create_ktable(&pfr_nulltable, 0, 0);
450 if (tmpkt == NULL)
451 return (ENOMEM);
452 pfr_mark_addrs(kt);
453 SLIST_INIT(&addq);
454 SLIST_INIT(&delq);
455 SLIST_INIT(&changeq);
456 for (i = 0; i < size; i++) {
428 int ec;
429 /*
430 * XXX Is it OK under LP64 environments?
431 */
432 long tzero = (long)time_second;
433#else
434 long tzero = time.tv_sec;
435#endif

--- 9 unchanged lines hidden (view full) ---

445 tmpkt = pfr_create_ktable(&pfr_nulltable, 0, 0);
446 if (tmpkt == NULL)
447 return (ENOMEM);
448 pfr_mark_addrs(kt);
449 SLIST_INIT(&addq);
450 SLIST_INIT(&delq);
451 SLIST_INIT(&changeq);
452 for (i = 0; i < size; i++) {
457#if defined(__FreeBSD__)
453#ifdef __FreeBSD__
458 PF_COPYIN(addr+i, &ad, sizeof(ad), ec);
459 if (ec)
460 senderr(EFAULT);
461#else
462 if (copyin(addr+i, &ad, sizeof(ad)))
463 senderr(EFAULT);
464#endif
465 if (pfr_validate_addr(&ad))

--- 25 unchanged lines hidden (view full) ---

491 ad.pfra_fback = PFR_FB_NONE;
492 } else {
493 SLIST_INSERT_HEAD(&addq, p, pfrke_workq);
494 ad.pfra_fback = PFR_FB_ADDED;
495 xadd++;
496 }
497 }
498_skip:
454 PF_COPYIN(addr+i, &ad, sizeof(ad), ec);
455 if (ec)
456 senderr(EFAULT);
457#else
458 if (copyin(addr+i, &ad, sizeof(ad)))
459 senderr(EFAULT);
460#endif
461 if (pfr_validate_addr(&ad))

--- 25 unchanged lines hidden (view full) ---

487 ad.pfra_fback = PFR_FB_NONE;
488 } else {
489 SLIST_INSERT_HEAD(&addq, p, pfrke_workq);
490 ad.pfra_fback = PFR_FB_ADDED;
491 xadd++;
492 }
493 }
494_skip:
499#if defined(__FreeBSD__)
495#ifdef __FreeBSD__
500 if (flags & PFR_FLAG_FEEDBACK) {
501 PF_COPYOUT(&ad, addr+i, sizeof(ad), ec);
502 if (ec)
503 senderr(EFAULT);
504 }
505#else
506 if (flags & PFR_FLAG_FEEDBACK)
507 if (copyout(&ad, addr+i, sizeof(ad)))

--- 5 unchanged lines hidden (view full) ---

513 if (*size2 < size+xdel) {
514 *size2 = size+xdel;
515 senderr(0);
516 }
517 i = 0;
518 SLIST_FOREACH(p, &delq, pfrke_workq) {
519 pfr_copyout_addr(&ad, p);
520 ad.pfra_fback = PFR_FB_DELETED;
496 if (flags & PFR_FLAG_FEEDBACK) {
497 PF_COPYOUT(&ad, addr+i, sizeof(ad), ec);
498 if (ec)
499 senderr(EFAULT);
500 }
501#else
502 if (flags & PFR_FLAG_FEEDBACK)
503 if (copyout(&ad, addr+i, sizeof(ad)))

--- 5 unchanged lines hidden (view full) ---

509 if (*size2 < size+xdel) {
510 *size2 = size+xdel;
511 senderr(0);
512 }
513 i = 0;
514 SLIST_FOREACH(p, &delq, pfrke_workq) {
515 pfr_copyout_addr(&ad, p);
516 ad.pfra_fback = PFR_FB_DELETED;
521#if defined(__FreeBSD__)
517#ifdef __FreeBSD__
522 PF_COPYOUT(&ad, addr+size+i, sizeof(ad), ec);
523 if (ec)
524 senderr(EFAULT);
525#else
526 if (copyout(&ad, addr+size+i, sizeof(ad)))
527 senderr(EFAULT);
528#endif
529 i++;

--- 32 unchanged lines hidden (view full) ---

562int
563pfr_tst_addrs(struct pfr_table *tbl, struct pfr_addr *addr, int size,
564 int *nmatch, int flags)
565{
566 struct pfr_ktable *kt;
567 struct pfr_kentry *p;
568 struct pfr_addr ad;
569 int i, xmatch = 0;
518 PF_COPYOUT(&ad, addr+size+i, sizeof(ad), ec);
519 if (ec)
520 senderr(EFAULT);
521#else
522 if (copyout(&ad, addr+size+i, sizeof(ad)))
523 senderr(EFAULT);
524#endif
525 i++;

--- 32 unchanged lines hidden (view full) ---

558int
559pfr_tst_addrs(struct pfr_table *tbl, struct pfr_addr *addr, int size,
560 int *nmatch, int flags)
561{
562 struct pfr_ktable *kt;
563 struct pfr_kentry *p;
564 struct pfr_addr ad;
565 int i, xmatch = 0;
570#if defined(__FreeBSD__)
566#ifdef __FreeBSD__
571 int ec;
572#endif
573
574 ACCEPT_FLAGS(PFR_FLAG_REPLACE);
575 if (pfr_validate_table(tbl, 0))
576 return (EINVAL);
577 kt = pfr_lookup_table(tbl);
578 if (kt == NULL || !(kt->pfrkt_flags & PFR_TFLAG_ACTIVE))
579 return (ESRCH);
580
581 for (i = 0; i < size; i++) {
567 int ec;
568#endif
569
570 ACCEPT_FLAGS(PFR_FLAG_REPLACE);
571 if (pfr_validate_table(tbl, 0))
572 return (EINVAL);
573 kt = pfr_lookup_table(tbl);
574 if (kt == NULL || !(kt->pfrkt_flags & PFR_TFLAG_ACTIVE))
575 return (ESRCH);
576
577 for (i = 0; i < size; i++) {
582#if defined(__FreeBSD__)
578#ifdef __FreeBSD__
583 PF_COPYIN(addr+i, &ad, sizeof(ad), ec);
584 if (ec)
585 return (EFAULT);
586#else
587 if (copyin(addr+i, &ad, sizeof(ad)))
588 return (EFAULT);
589#endif
590 if (pfr_validate_addr(&ad))
591 return (EINVAL);
592 if (ADDR_NETWORK(&ad))
593 return (EINVAL);
594 p = pfr_lookup_addr(kt, &ad, 0);
595 if (flags & PFR_FLAG_REPLACE)
596 pfr_copyout_addr(&ad, p);
597 ad.pfra_fback = (p == NULL) ? PFR_FB_NONE :
598 (p->pfrke_not ? PFR_FB_NOTMATCH : PFR_FB_MATCH);
599 if (p != NULL && !p->pfrke_not)
600 xmatch++;
579 PF_COPYIN(addr+i, &ad, sizeof(ad), ec);
580 if (ec)
581 return (EFAULT);
582#else
583 if (copyin(addr+i, &ad, sizeof(ad)))
584 return (EFAULT);
585#endif
586 if (pfr_validate_addr(&ad))
587 return (EINVAL);
588 if (ADDR_NETWORK(&ad))
589 return (EINVAL);
590 p = pfr_lookup_addr(kt, &ad, 0);
591 if (flags & PFR_FLAG_REPLACE)
592 pfr_copyout_addr(&ad, p);
593 ad.pfra_fback = (p == NULL) ? PFR_FB_NONE :
594 (p->pfrke_not ? PFR_FB_NOTMATCH : PFR_FB_MATCH);
595 if (p != NULL && !p->pfrke_not)
596 xmatch++;
601#if defined(__FreeBSD__)
597#ifdef __FreeBSD__
602 PF_COPYOUT(&ad, addr+i, sizeof(ad), ec);
603 if (ec)
604 return (EFAULT);
605#else
606 if (copyout(&ad, addr+i, sizeof(ad)))
607 return (EFAULT);
608#endif
609 }

--- 20 unchanged lines hidden (view full) ---

630 *size = kt->pfrkt_cnt;
631 return (0);
632 }
633
634 bzero(&w, sizeof(w));
635 w.pfrw_op = PFRW_GET_ADDRS;
636 w.pfrw_addr = addr;
637 w.pfrw_free = kt->pfrkt_cnt;
598 PF_COPYOUT(&ad, addr+i, sizeof(ad), ec);
599 if (ec)
600 return (EFAULT);
601#else
602 if (copyout(&ad, addr+i, sizeof(ad)))
603 return (EFAULT);
604#endif
605 }

--- 20 unchanged lines hidden (view full) ---

626 *size = kt->pfrkt_cnt;
627 return (0);
628 }
629
630 bzero(&w, sizeof(w));
631 w.pfrw_op = PFRW_GET_ADDRS;
632 w.pfrw_addr = addr;
633 w.pfrw_free = kt->pfrkt_cnt;
638#if defined(__FreeBSD__)
634#ifdef __FreeBSD__
639 rv = kt->pfrkt_ip4->rnh_walktree(kt->pfrkt_ip4, pfr_walktree, &w);
640#else
641 rv = rn_walktree(kt->pfrkt_ip4, pfr_walktree, &w);
642#endif
643 if (!rv)
635 rv = kt->pfrkt_ip4->rnh_walktree(kt->pfrkt_ip4, pfr_walktree, &w);
636#else
637 rv = rn_walktree(kt->pfrkt_ip4, pfr_walktree, &w);
638#endif
639 if (!rv)
644#if defined(__FreeBSD__)
640#ifdef __FreeBSD__
645 rv = kt->pfrkt_ip6->rnh_walktree(kt->pfrkt_ip6, pfr_walktree,
646 &w);
647#else
648 rv = rn_walktree(kt->pfrkt_ip6, pfr_walktree, &w);
649#endif
650 if (rv)
651 return (rv);
652

--- 9 unchanged lines hidden (view full) ---

662int
663pfr_get_astats(struct pfr_table *tbl, struct pfr_astats *addr, int *size,
664 int flags)
665{
666 struct pfr_ktable *kt;
667 struct pfr_walktree w;
668 struct pfr_kentryworkq workq;
669 int rv, s;
641 rv = kt->pfrkt_ip6->rnh_walktree(kt->pfrkt_ip6, pfr_walktree,
642 &w);
643#else
644 rv = rn_walktree(kt->pfrkt_ip6, pfr_walktree, &w);
645#endif
646 if (rv)
647 return (rv);
648

--- 9 unchanged lines hidden (view full) ---

658int
659pfr_get_astats(struct pfr_table *tbl, struct pfr_astats *addr, int *size,
660 int flags)
661{
662 struct pfr_ktable *kt;
663 struct pfr_walktree w;
664 struct pfr_kentryworkq workq;
665 int rv, s;
670#if defined(__FreeBSD__)
666#ifdef __FreeBSD__
671 /*
672 * XXX Is it OK under LP64 environments?
673 */
674 long tzero = (long)time_second;
675#else
676 long tzero = time.tv_sec;
677#endif
678

--- 9 unchanged lines hidden (view full) ---

688 }
689
690 bzero(&w, sizeof(w));
691 w.pfrw_op = PFRW_GET_ASTATS;
692 w.pfrw_astats = addr;
693 w.pfrw_free = kt->pfrkt_cnt;
694 if (flags & PFR_FLAG_ATOMIC)
695 s = splsoftnet();
667 /*
668 * XXX Is it OK under LP64 environments?
669 */
670 long tzero = (long)time_second;
671#else
672 long tzero = time.tv_sec;
673#endif
674

--- 9 unchanged lines hidden (view full) ---

684 }
685
686 bzero(&w, sizeof(w));
687 w.pfrw_op = PFRW_GET_ASTATS;
688 w.pfrw_astats = addr;
689 w.pfrw_free = kt->pfrkt_cnt;
690 if (flags & PFR_FLAG_ATOMIC)
691 s = splsoftnet();
696#if defined(__FreeBSD__)
692#ifdef __FreeBSD__
697 rv = kt->pfrkt_ip4->rnh_walktree(kt->pfrkt_ip4, pfr_walktree, &w);
698#else
699 rv = rn_walktree(kt->pfrkt_ip4, pfr_walktree, &w);
700#endif
701 if (!rv)
693 rv = kt->pfrkt_ip4->rnh_walktree(kt->pfrkt_ip4, pfr_walktree, &w);
694#else
695 rv = rn_walktree(kt->pfrkt_ip4, pfr_walktree, &w);
696#endif
697 if (!rv)
702#if defined(__FreeBSD__)
698#ifdef __FreeBSD__
703 rv = kt->pfrkt_ip6->rnh_walktree(kt->pfrkt_ip6, pfr_walktree,
704 &w);
705#else
706 rv = rn_walktree(kt->pfrkt_ip6, pfr_walktree, &w);
707#endif
708 if (!rv && (flags & PFR_FLAG_CLSTATS)) {
709 pfr_enqueue_addrs(kt, &workq, NULL, 0);
710 pfr_clstats_kentries(&workq, tzero, 0);

--- 16 unchanged lines hidden (view full) ---

727pfr_clr_astats(struct pfr_table *tbl, struct pfr_addr *addr, int size,
728 int *nzero, int flags)
729{
730 struct pfr_ktable *kt;
731 struct pfr_kentryworkq workq;
732 struct pfr_kentry *p;
733 struct pfr_addr ad;
734 int i, rv, s, xzero = 0;
699 rv = kt->pfrkt_ip6->rnh_walktree(kt->pfrkt_ip6, pfr_walktree,
700 &w);
701#else
702 rv = rn_walktree(kt->pfrkt_ip6, pfr_walktree, &w);
703#endif
704 if (!rv && (flags & PFR_FLAG_CLSTATS)) {
705 pfr_enqueue_addrs(kt, &workq, NULL, 0);
706 pfr_clstats_kentries(&workq, tzero, 0);

--- 16 unchanged lines hidden (view full) ---

723pfr_clr_astats(struct pfr_table *tbl, struct pfr_addr *addr, int size,
724 int *nzero, int flags)
725{
726 struct pfr_ktable *kt;
727 struct pfr_kentryworkq workq;
728 struct pfr_kentry *p;
729 struct pfr_addr ad;
730 int i, rv, s, xzero = 0;
735#if defined(__FreeBSD__)
731#ifdef __FreeBSD__
736 int ec;
737#endif
738
739 ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY+PFR_FLAG_FEEDBACK);
740 if (pfr_validate_table(tbl, 0))
741 return (EINVAL);
742 kt = pfr_lookup_table(tbl);
743 if (kt == NULL || !(kt->pfrkt_flags & PFR_TFLAG_ACTIVE))
744 return (ESRCH);
745 SLIST_INIT(&workq);
746 for (i = 0; i < size; i++) {
732 int ec;
733#endif
734
735 ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY+PFR_FLAG_FEEDBACK);
736 if (pfr_validate_table(tbl, 0))
737 return (EINVAL);
738 kt = pfr_lookup_table(tbl);
739 if (kt == NULL || !(kt->pfrkt_flags & PFR_TFLAG_ACTIVE))
740 return (ESRCH);
741 SLIST_INIT(&workq);
742 for (i = 0; i < size; i++) {
747#if defined(__FreeBSD__)
743#ifdef __FreeBSD__
748 PF_COPYIN(addr+i, &ad, sizeof(ad), ec);
749 if (ec)
750 senderr(EFAULT);
751#else
752 if (copyin(addr+i, &ad, sizeof(ad)))
753 senderr(EFAULT);
754#endif
755 if (pfr_validate_addr(&ad))
756 senderr(EINVAL);
757 p = pfr_lookup_addr(kt, &ad, 1);
758 if (flags & PFR_FLAG_FEEDBACK) {
759 ad.pfra_fback = (p != NULL) ?
760 PFR_FB_CLEARED : PFR_FB_NONE;
744 PF_COPYIN(addr+i, &ad, sizeof(ad), ec);
745 if (ec)
746 senderr(EFAULT);
747#else
748 if (copyin(addr+i, &ad, sizeof(ad)))
749 senderr(EFAULT);
750#endif
751 if (pfr_validate_addr(&ad))
752 senderr(EINVAL);
753 p = pfr_lookup_addr(kt, &ad, 1);
754 if (flags & PFR_FLAG_FEEDBACK) {
755 ad.pfra_fback = (p != NULL) ?
756 PFR_FB_CLEARED : PFR_FB_NONE;
761#if defined(__FreeBSD__)
757#ifdef __FreeBSD__
762 PF_COPYOUT(&ad, addr+i, sizeof(ad), ec);
763 if (ec)
764 senderr(EFAULT);
765#else
766 if (copyout(&ad, addr+i, sizeof(ad)))
767 senderr(EFAULT);
768#endif
769 }

--- 55 unchanged lines hidden (view full) ---

825{
826 struct pfr_walktree w;
827
828 SLIST_INIT(workq);
829 bzero(&w, sizeof(w));
830 w.pfrw_op = sweep ? PFRW_SWEEP : PFRW_ENQUEUE;
831 w.pfrw_workq = workq;
832 if (kt->pfrkt_ip4 != NULL)
758 PF_COPYOUT(&ad, addr+i, sizeof(ad), ec);
759 if (ec)
760 senderr(EFAULT);
761#else
762 if (copyout(&ad, addr+i, sizeof(ad)))
763 senderr(EFAULT);
764#endif
765 }

--- 55 unchanged lines hidden (view full) ---

821{
822 struct pfr_walktree w;
823
824 SLIST_INIT(workq);
825 bzero(&w, sizeof(w));
826 w.pfrw_op = sweep ? PFRW_SWEEP : PFRW_ENQUEUE;
827 w.pfrw_workq = workq;
828 if (kt->pfrkt_ip4 != NULL)
833#if defined(__FreeBSD__)
829#ifdef __FreeBSD__
834 if (kt->pfrkt_ip4->rnh_walktree(kt->pfrkt_ip4, pfr_walktree,
835 &w))
836#else
837 if (rn_walktree(kt->pfrkt_ip4, pfr_walktree, &w))
838#endif
839 printf("pfr_enqueue_addrs: IPv4 walktree failed.\n");
840 if (kt->pfrkt_ip6 != NULL)
830 if (kt->pfrkt_ip4->rnh_walktree(kt->pfrkt_ip4, pfr_walktree,
831 &w))
832#else
833 if (rn_walktree(kt->pfrkt_ip4, pfr_walktree, &w))
834#endif
835 printf("pfr_enqueue_addrs: IPv4 walktree failed.\n");
836 if (kt->pfrkt_ip6 != NULL)
841#if defined(__FreeBSD__)
837#ifdef __FreeBSD__
842 if (kt->pfrkt_ip6->rnh_walktree(kt->pfrkt_ip6, pfr_walktree,
843 &w))
844#else
845 if (rn_walktree(kt->pfrkt_ip6, pfr_walktree, &w))
846#endif
847 printf("pfr_enqueue_addrs: IPv6 walktree failed.\n");
848 if (naddr != NULL)
849 *naddr = w.pfrw_cnt;
850}
851
852void
853pfr_mark_addrs(struct pfr_ktable *kt)
854{
855 struct pfr_walktree w;
856
857 bzero(&w, sizeof(w));
858 w.pfrw_op = PFRW_MARK;
838 if (kt->pfrkt_ip6->rnh_walktree(kt->pfrkt_ip6, pfr_walktree,
839 &w))
840#else
841 if (rn_walktree(kt->pfrkt_ip6, pfr_walktree, &w))
842#endif
843 printf("pfr_enqueue_addrs: IPv6 walktree failed.\n");
844 if (naddr != NULL)
845 *naddr = w.pfrw_cnt;
846}
847
848void
849pfr_mark_addrs(struct pfr_ktable *kt)
850{
851 struct pfr_walktree w;
852
853 bzero(&w, sizeof(w));
854 w.pfrw_op = PFRW_MARK;
859#if defined(__FreeBSD__)
855#ifdef __FreeBSD__
860 if (kt->pfrkt_ip4->rnh_walktree(kt->pfrkt_ip4, pfr_walktree, &w))
861#else
862 if (rn_walktree(kt->pfrkt_ip4, pfr_walktree, &w))
863#endif
864 printf("pfr_mark_addrs: IPv4 walktree failed.\n");
856 if (kt->pfrkt_ip4->rnh_walktree(kt->pfrkt_ip4, pfr_walktree, &w))
857#else
858 if (rn_walktree(kt->pfrkt_ip4, pfr_walktree, &w))
859#endif
860 printf("pfr_mark_addrs: IPv4 walktree failed.\n");
865#if defined(__FreeBSD__)
861#ifdef __FreeBSD__
866 if (kt->pfrkt_ip6->rnh_walktree(kt->pfrkt_ip6, pfr_walktree, &w))
867#else
868 if (rn_walktree(kt->pfrkt_ip6, pfr_walktree, &w))
869#endif
870 printf("pfr_mark_addrs: IPv6 walktree failed.\n");
871}
872
873

--- 135 unchanged lines hidden (view full) ---

1009 }
1010}
1011
1012void
1013pfr_reset_feedback(struct pfr_addr *addr, int size)
1014{
1015 struct pfr_addr ad;
1016 int i;
862 if (kt->pfrkt_ip6->rnh_walktree(kt->pfrkt_ip6, pfr_walktree, &w))
863#else
864 if (rn_walktree(kt->pfrkt_ip6, pfr_walktree, &w))
865#endif
866 printf("pfr_mark_addrs: IPv6 walktree failed.\n");
867}
868
869

--- 135 unchanged lines hidden (view full) ---

1005 }
1006}
1007
1008void
1009pfr_reset_feedback(struct pfr_addr *addr, int size)
1010{
1011 struct pfr_addr ad;
1012 int i;
1017#if defined(__FreeBSD__)
1013#ifdef __FreeBSD__
1018 int ec;
1019#endif
1020
1021 for (i = 0; i < size; i++) {
1014 int ec;
1015#endif
1016
1017 for (i = 0; i < size; i++) {
1022#if defined(__FreeBSD__)
1018#ifdef __FreeBSD__
1023 PF_COPYIN(addr+i, &ad, sizeof(ad), ec);
1024 if (ec)
1025 break;
1026#else
1027 if (copyin(addr+i, &ad, sizeof(ad)))
1028 break;
1029#endif
1030 ad.pfra_fback = PFR_FB_NONE;
1019 PF_COPYIN(addr+i, &ad, sizeof(ad), ec);
1020 if (ec)
1021 break;
1022#else
1023 if (copyin(addr+i, &ad, sizeof(ad)))
1024 break;
1025#endif
1026 ad.pfra_fback = PFR_FB_NONE;
1031#if defined(__FreeBSD__)
1027#ifdef __FreeBSD__
1032 PF_COPYOUT(&ad, addr+i, sizeof(ad), ec);
1033 if (ec)
1034 break;
1035#else
1036 if (copyout(&ad, addr+i, sizeof(ad)))
1037 break;
1038#endif
1039 }

--- 105 unchanged lines hidden (view full) ---

1145}
1146
1147int
1148pfr_walktree(struct radix_node *rn, void *arg)
1149{
1150 struct pfr_kentry *ke = (struct pfr_kentry *)rn;
1151 struct pfr_walktree *w = arg;
1152 int s;
1028 PF_COPYOUT(&ad, addr+i, sizeof(ad), ec);
1029 if (ec)
1030 break;
1031#else
1032 if (copyout(&ad, addr+i, sizeof(ad)))
1033 break;
1034#endif
1035 }

--- 105 unchanged lines hidden (view full) ---

1141}
1142
1143int
1144pfr_walktree(struct radix_node *rn, void *arg)
1145{
1146 struct pfr_kentry *ke = (struct pfr_kentry *)rn;
1147 struct pfr_walktree *w = arg;
1148 int s;
1153#if defined(__FreeBSD__)
1149#ifdef __FreeBSD__
1154 int ec;
1155#endif
1156
1157 switch (w->pfrw_op) {
1158 case PFRW_MARK:
1159 ke->pfrke_mark = 0;
1160 break;
1161 case PFRW_SWEEP:

--- 4 unchanged lines hidden (view full) ---

1166 SLIST_INSERT_HEAD(w->pfrw_workq, ke, pfrke_workq);
1167 w->pfrw_cnt++;
1168 break;
1169 case PFRW_GET_ADDRS:
1170 if (w->pfrw_free-- > 0) {
1171 struct pfr_addr ad;
1172
1173 pfr_copyout_addr(&ad, ke);
1150 int ec;
1151#endif
1152
1153 switch (w->pfrw_op) {
1154 case PFRW_MARK:
1155 ke->pfrke_mark = 0;
1156 break;
1157 case PFRW_SWEEP:

--- 4 unchanged lines hidden (view full) ---

1162 SLIST_INSERT_HEAD(w->pfrw_workq, ke, pfrke_workq);
1163 w->pfrw_cnt++;
1164 break;
1165 case PFRW_GET_ADDRS:
1166 if (w->pfrw_free-- > 0) {
1167 struct pfr_addr ad;
1168
1169 pfr_copyout_addr(&ad, ke);
1174#if defined(__FreeBSD__)
1170#ifdef __FreeBSD__
1175 PF_COPYOUT(&ad, w->pfrw_addr, sizeof(ad), ec);
1176 if (ec)
1177 return (EFAULT);
1178#else
1179 if (copyout(&ad, w->pfrw_addr, sizeof(ad)))
1180 return (EFAULT);
1181#endif
1182 w->pfrw_addr++;

--- 8 unchanged lines hidden (view full) ---

1191 s = splsoftnet();
1192 bcopy(ke->pfrke_packets, as.pfras_packets,
1193 sizeof(as.pfras_packets));
1194 bcopy(ke->pfrke_bytes, as.pfras_bytes,
1195 sizeof(as.pfras_bytes));
1196 splx(s);
1197 as.pfras_tzero = ke->pfrke_tzero;
1198
1171 PF_COPYOUT(&ad, w->pfrw_addr, sizeof(ad), ec);
1172 if (ec)
1173 return (EFAULT);
1174#else
1175 if (copyout(&ad, w->pfrw_addr, sizeof(ad)))
1176 return (EFAULT);
1177#endif
1178 w->pfrw_addr++;

--- 8 unchanged lines hidden (view full) ---

1187 s = splsoftnet();
1188 bcopy(ke->pfrke_packets, as.pfras_packets,
1189 sizeof(as.pfras_packets));
1190 bcopy(ke->pfrke_bytes, as.pfras_bytes,
1191 sizeof(as.pfras_bytes));
1192 splx(s);
1193 as.pfras_tzero = ke->pfrke_tzero;
1194
1199#if defined(__FreeBSD__)
1195#ifdef __FreeBSD__
1200 PF_COPYOUT(&as, w->pfrw_astats, sizeof(as), ec);
1201 if (ec)
1202 return (EFAULT);
1203#else
1204 if (copyout(&as, w->pfrw_astats, sizeof(as)))
1205 return (EFAULT);
1206#endif
1207 w->pfrw_astats++;

--- 45 unchanged lines hidden (view full) ---

1253}
1254
1255int
1256pfr_add_tables(struct pfr_table *tbl, int size, int *nadd, int flags)
1257{
1258 struct pfr_ktableworkq addq, changeq;
1259 struct pfr_ktable *p, *q, *r, key;
1260 int i, rv, s, xadd = 0;
1196 PF_COPYOUT(&as, w->pfrw_astats, sizeof(as), ec);
1197 if (ec)
1198 return (EFAULT);
1199#else
1200 if (copyout(&as, w->pfrw_astats, sizeof(as)))
1201 return (EFAULT);
1202#endif
1203 w->pfrw_astats++;

--- 45 unchanged lines hidden (view full) ---

1249}
1250
1251int
1252pfr_add_tables(struct pfr_table *tbl, int size, int *nadd, int flags)
1253{
1254 struct pfr_ktableworkq addq, changeq;
1255 struct pfr_ktable *p, *q, *r, key;
1256 int i, rv, s, xadd = 0;
1261#if defined(__FreeBSD__)
1257#ifdef __FreeBSD__
1262 int ec;
1263 /*
1264 * XXX Is it OK under LP64 environments?
1265 */
1266 long tzero = (long)time_second;
1267#else
1268 long tzero = time.tv_sec;
1269#endif
1270
1271 ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY);
1272 SLIST_INIT(&addq);
1273 SLIST_INIT(&changeq);
1274 for (i = 0; i < size; i++) {
1258 int ec;
1259 /*
1260 * XXX Is it OK under LP64 environments?
1261 */
1262 long tzero = (long)time_second;
1263#else
1264 long tzero = time.tv_sec;
1265#endif
1266
1267 ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY);
1268 SLIST_INIT(&addq);
1269 SLIST_INIT(&changeq);
1270 for (i = 0; i < size; i++) {
1275#if defined(__FreeBSD__)
1271#ifdef __FreeBSD__
1276 PF_COPYIN(tbl+i, &key.pfrkt_t, sizeof(key.pfrkt_t), ec);
1277 if (ec)
1278 senderr(EFAULT);
1279#else
1280 if (copyin(tbl+i, &key.pfrkt_t, sizeof(key.pfrkt_t)))
1281 senderr(EFAULT);
1282#endif
1283 if (pfr_validate_table(&key.pfrkt_t, PFR_TFLAG_USRMASK))

--- 63 unchanged lines hidden (view full) ---

1347}
1348
1349int
1350pfr_del_tables(struct pfr_table *tbl, int size, int *ndel, int flags)
1351{
1352 struct pfr_ktableworkq workq;
1353 struct pfr_ktable *p, *q, key;
1354 int i, s, xdel = 0;
1272 PF_COPYIN(tbl+i, &key.pfrkt_t, sizeof(key.pfrkt_t), ec);
1273 if (ec)
1274 senderr(EFAULT);
1275#else
1276 if (copyin(tbl+i, &key.pfrkt_t, sizeof(key.pfrkt_t)))
1277 senderr(EFAULT);
1278#endif
1279 if (pfr_validate_table(&key.pfrkt_t, PFR_TFLAG_USRMASK))

--- 63 unchanged lines hidden (view full) ---

1343}
1344
1345int
1346pfr_del_tables(struct pfr_table *tbl, int size, int *ndel, int flags)
1347{
1348 struct pfr_ktableworkq workq;
1349 struct pfr_ktable *p, *q, key;
1350 int i, s, xdel = 0;
1355#if defined(__FreeBSD__)
1351#ifdef __FreeBSD__
1356 int ec;
1357#endif
1358
1359 ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY);
1360 SLIST_INIT(&workq);
1361 for (i = 0; i < size; i++) {
1352 int ec;
1353#endif
1354
1355 ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY);
1356 SLIST_INIT(&workq);
1357 for (i = 0; i < size; i++) {
1362#if defined(__FreeBSD__)
1358#ifdef __FreeBSD__
1363 PF_COPYIN(tbl+i, &key.pfrkt_t, sizeof(key.pfrkt_t), ec);
1364 if (ec)
1365 return (EFAULT);
1366#else
1367 if (copyin(tbl+i, &key.pfrkt_t, sizeof(key.pfrkt_t)))
1368 return (EFAULT);
1369#endif
1370 if (pfr_validate_table(&key.pfrkt_t, 0))

--- 24 unchanged lines hidden (view full) ---

1395}
1396
1397int
1398pfr_get_tables(struct pfr_table *filter, struct pfr_table *tbl, int *size,
1399 int flags)
1400{
1401 struct pfr_ktable *p;
1402 int n, nn;
1359 PF_COPYIN(tbl+i, &key.pfrkt_t, sizeof(key.pfrkt_t), ec);
1360 if (ec)
1361 return (EFAULT);
1362#else
1363 if (copyin(tbl+i, &key.pfrkt_t, sizeof(key.pfrkt_t)))
1364 return (EFAULT);
1365#endif
1366 if (pfr_validate_table(&key.pfrkt_t, 0))

--- 24 unchanged lines hidden (view full) ---

1391}
1392
1393int
1394pfr_get_tables(struct pfr_table *filter, struct pfr_table *tbl, int *size,
1395 int flags)
1396{
1397 struct pfr_ktable *p;
1398 int n, nn;
1403#if defined(__FreeBSD__)
1399#ifdef __FreeBSD__
1404 int ec;
1405#endif
1406
1407 ACCEPT_FLAGS(PFR_FLAG_ALLRSETS);
1408 n = nn = pfr_table_count(filter, flags);
1409 if (n < 0)
1410 return (ENOENT);
1411 if (n > *size) {
1412 *size = n;
1413 return (0);
1414 }
1415 RB_FOREACH(p, pfr_ktablehead, &pfr_ktables) {
1416 if (pfr_skip_table(filter, p, flags))
1417 continue;
1418 if (n-- <= 0)
1419 continue;
1400 int ec;
1401#endif
1402
1403 ACCEPT_FLAGS(PFR_FLAG_ALLRSETS);
1404 n = nn = pfr_table_count(filter, flags);
1405 if (n < 0)
1406 return (ENOENT);
1407 if (n > *size) {
1408 *size = n;
1409 return (0);
1410 }
1411 RB_FOREACH(p, pfr_ktablehead, &pfr_ktables) {
1412 if (pfr_skip_table(filter, p, flags))
1413 continue;
1414 if (n-- <= 0)
1415 continue;
1420#if defined(__FreeBSD__)
1416#ifdef __FreeBSD__
1421 PF_COPYOUT(&p->pfrkt_t, tbl++, sizeof(*tbl), ec);
1422 if (ec)
1423 return (EFAULT);
1424#else
1425 if (copyout(&p->pfrkt_t, tbl++, sizeof(*tbl)))
1426 return (EFAULT);
1427#endif
1428 }

--- 7 unchanged lines hidden (view full) ---

1436
1437int
1438pfr_get_tstats(struct pfr_table *filter, struct pfr_tstats *tbl, int *size,
1439 int flags)
1440{
1441 struct pfr_ktable *p;
1442 struct pfr_ktableworkq workq;
1443 int s, n, nn;
1417 PF_COPYOUT(&p->pfrkt_t, tbl++, sizeof(*tbl), ec);
1418 if (ec)
1419 return (EFAULT);
1420#else
1421 if (copyout(&p->pfrkt_t, tbl++, sizeof(*tbl)))
1422 return (EFAULT);
1423#endif
1424 }

--- 7 unchanged lines hidden (view full) ---

1432
1433int
1434pfr_get_tstats(struct pfr_table *filter, struct pfr_tstats *tbl, int *size,
1435 int flags)
1436{
1437 struct pfr_ktable *p;
1438 struct pfr_ktableworkq workq;
1439 int s, n, nn;
1444#if defined(__FreeBSD__)
1440#ifdef __FreeBSD__
1445 int ec;
1446 /*
1447 * XXX Is it OK under LP64 environments?
1448 */
1449 long tzero = (long)time_second;
1450#else
1451 long tzero = time.tv_sec;
1452#endif

--- 12 unchanged lines hidden (view full) ---

1465 s = splsoftnet();
1466 RB_FOREACH(p, pfr_ktablehead, &pfr_ktables) {
1467 if (pfr_skip_table(filter, p, flags))
1468 continue;
1469 if (n-- <= 0)
1470 continue;
1471 if (!(flags & PFR_FLAG_ATOMIC))
1472 s = splsoftnet();
1441 int ec;
1442 /*
1443 * XXX Is it OK under LP64 environments?
1444 */
1445 long tzero = (long)time_second;
1446#else
1447 long tzero = time.tv_sec;
1448#endif

--- 12 unchanged lines hidden (view full) ---

1461 s = splsoftnet();
1462 RB_FOREACH(p, pfr_ktablehead, &pfr_ktables) {
1463 if (pfr_skip_table(filter, p, flags))
1464 continue;
1465 if (n-- <= 0)
1466 continue;
1467 if (!(flags & PFR_FLAG_ATOMIC))
1468 s = splsoftnet();
1473#if defined(__FreeBSD__)
1469#ifdef __FreeBSD__
1474 PF_COPYOUT(&p->pfrkt_ts, tbl++, sizeof(*tbl), ec);
1475 if (ec) {
1476 splx(s);
1477 return (EFAULT);
1478 }
1479#else
1480 if (copyout(&p->pfrkt_ts, tbl++, sizeof(*tbl))) {
1481 splx(s);

--- 18 unchanged lines hidden (view full) ---

1500}
1501
1502int
1503pfr_clr_tstats(struct pfr_table *tbl, int size, int *nzero, int flags)
1504{
1505 struct pfr_ktableworkq workq;
1506 struct pfr_ktable *p, key;
1507 int i, s, xzero = 0;
1470 PF_COPYOUT(&p->pfrkt_ts, tbl++, sizeof(*tbl), ec);
1471 if (ec) {
1472 splx(s);
1473 return (EFAULT);
1474 }
1475#else
1476 if (copyout(&p->pfrkt_ts, tbl++, sizeof(*tbl))) {
1477 splx(s);

--- 18 unchanged lines hidden (view full) ---

1496}
1497
1498int
1499pfr_clr_tstats(struct pfr_table *tbl, int size, int *nzero, int flags)
1500{
1501 struct pfr_ktableworkq workq;
1502 struct pfr_ktable *p, key;
1503 int i, s, xzero = 0;
1508#if defined(__FreeBSD__)
1504#ifdef __FreeBSD__
1509 int ec;
1510 /*
1511 * XXX Is it OK under LP64 environments?
1512 */
1513 long tzero = (long)time_second;
1514#else
1515 long tzero = time.tv_sec;
1516#endif
1517
1518 ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY+PFR_FLAG_ADDRSTOO);
1519 SLIST_INIT(&workq);
1520 for (i = 0; i < size; i++) {
1505 int ec;
1506 /*
1507 * XXX Is it OK under LP64 environments?
1508 */
1509 long tzero = (long)time_second;
1510#else
1511 long tzero = time.tv_sec;
1512#endif
1513
1514 ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY+PFR_FLAG_ADDRSTOO);
1515 SLIST_INIT(&workq);
1516 for (i = 0; i < size; i++) {
1521#if defined(__FreeBSD__)
1517#ifdef __FreeBSD__
1522 PF_COPYIN(tbl+i, &key.pfrkt_t, sizeof(key.pfrkt_t), ec);
1523 if (ec)
1524 return (EFAULT);
1525#else
1526 if (copyin(tbl+i, &key.pfrkt_t, sizeof(key.pfrkt_t)))
1527 return (EFAULT);
1528#endif
1529 if (pfr_validate_table(&key.pfrkt_t, 0))

--- 18 unchanged lines hidden (view full) ---

1548
1549int
1550pfr_set_tflags(struct pfr_table *tbl, int size, int setflag, int clrflag,
1551 int *nchange, int *ndel, int flags)
1552{
1553 struct pfr_ktableworkq workq;
1554 struct pfr_ktable *p, *q, key;
1555 int i, s, xchange = 0, xdel = 0;
1518 PF_COPYIN(tbl+i, &key.pfrkt_t, sizeof(key.pfrkt_t), ec);
1519 if (ec)
1520 return (EFAULT);
1521#else
1522 if (copyin(tbl+i, &key.pfrkt_t, sizeof(key.pfrkt_t)))
1523 return (EFAULT);
1524#endif
1525 if (pfr_validate_table(&key.pfrkt_t, 0))

--- 18 unchanged lines hidden (view full) ---

1544
1545int
1546pfr_set_tflags(struct pfr_table *tbl, int size, int setflag, int clrflag,
1547 int *nchange, int *ndel, int flags)
1548{
1549 struct pfr_ktableworkq workq;
1550 struct pfr_ktable *p, *q, key;
1551 int i, s, xchange = 0, xdel = 0;
1556#if defined(__FreeBSD__)
1552#ifdef __FreeBSD__
1557 int ec;
1558#endif
1559
1560 ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY);
1561 if ((setflag & ~PFR_TFLAG_USRMASK) ||
1562 (clrflag & ~PFR_TFLAG_USRMASK) ||
1563 (setflag & clrflag))
1564 return (EINVAL);
1565 SLIST_INIT(&workq);
1566 for (i = 0; i < size; i++) {
1553 int ec;
1554#endif
1555
1556 ACCEPT_FLAGS(PFR_FLAG_ATOMIC+PFR_FLAG_DUMMY);
1557 if ((setflag & ~PFR_TFLAG_USRMASK) ||
1558 (clrflag & ~PFR_TFLAG_USRMASK) ||
1559 (setflag & clrflag))
1560 return (EINVAL);
1561 SLIST_INIT(&workq);
1562 for (i = 0; i < size; i++) {
1567#if defined(__FreeBSD__)
1563#ifdef __FreeBSD__
1568 PF_COPYIN(tbl+i, &key.pfrkt_t, sizeof(key.pfrkt_t), ec);
1569 if (ec)
1570 return (EFAULT);
1571#else
1572 if (copyin(tbl+i, &key.pfrkt_t, sizeof(key.pfrkt_t)))
1573 return (EFAULT);
1574#endif
1575 if (pfr_validate_table(&key.pfrkt_t, 0))

--- 71 unchanged lines hidden (view full) ---

1647{
1648 struct pfr_ktableworkq tableq;
1649 struct pfr_kentryworkq addrq;
1650 struct pfr_ktable *kt, *rt, *shadow, key;
1651 struct pfr_kentry *p;
1652 struct pfr_addr ad;
1653 struct pf_ruleset *rs;
1654 int i, rv, xadd = 0, xaddr = 0;
1564 PF_COPYIN(tbl+i, &key.pfrkt_t, sizeof(key.pfrkt_t), ec);
1565 if (ec)
1566 return (EFAULT);
1567#else
1568 if (copyin(tbl+i, &key.pfrkt_t, sizeof(key.pfrkt_t)))
1569 return (EFAULT);
1570#endif
1571 if (pfr_validate_table(&key.pfrkt_t, 0))

--- 71 unchanged lines hidden (view full) ---

1643{
1644 struct pfr_ktableworkq tableq;
1645 struct pfr_kentryworkq addrq;
1646 struct pfr_ktable *kt, *rt, *shadow, key;
1647 struct pfr_kentry *p;
1648 struct pfr_addr ad;
1649 struct pf_ruleset *rs;
1650 int i, rv, xadd = 0, xaddr = 0;
1655#if defined(__FreeBSD__)
1651#ifdef __FreeBSD__
1656 int ec;
1657#endif
1658
1659 ACCEPT_FLAGS(PFR_FLAG_DUMMY|PFR_FLAG_ADDRSTOO);
1660 if (size && !(flags & PFR_FLAG_ADDRSTOO))
1661 return (EINVAL);
1662 if (pfr_validate_table(tbl, PFR_TFLAG_USRMASK))
1663 return (EINVAL);

--- 32 unchanged lines hidden (view full) ---

1696_skip:
1697 shadow = pfr_create_ktable(tbl, 0, 0);
1698 if (shadow == NULL) {
1699 pfr_destroy_ktables(&tableq, 0);
1700 return (ENOMEM);
1701 }
1702 SLIST_INIT(&addrq);
1703 for (i = 0; i < size; i++) {
1652 int ec;
1653#endif
1654
1655 ACCEPT_FLAGS(PFR_FLAG_DUMMY|PFR_FLAG_ADDRSTOO);
1656 if (size && !(flags & PFR_FLAG_ADDRSTOO))
1657 return (EINVAL);
1658 if (pfr_validate_table(tbl, PFR_TFLAG_USRMASK))
1659 return (EINVAL);

--- 32 unchanged lines hidden (view full) ---

1692_skip:
1693 shadow = pfr_create_ktable(tbl, 0, 0);
1694 if (shadow == NULL) {
1695 pfr_destroy_ktables(&tableq, 0);
1696 return (ENOMEM);
1697 }
1698 SLIST_INIT(&addrq);
1699 for (i = 0; i < size; i++) {
1704#if defined(__FreeBSD__)
1700#ifdef __FreeBSD__
1705 PF_COPYIN(addr+i, &ad, sizeof(ad), ec);
1706 if (ec)
1707 senderr(EFAULT);
1708#else
1709 if (copyin(addr+i, &ad, sizeof(ad)))
1710 senderr(EFAULT);
1711#endif
1712 if (pfr_validate_addr(&ad))

--- 39 unchanged lines hidden (view full) ---

1752int
1753pfr_ina_commit(struct pfr_table *trs, u_int32_t ticket, int *nadd,
1754 int *nchange, int flags)
1755{
1756 struct pfr_ktable *p;
1757 struct pfr_ktableworkq workq;
1758 struct pf_ruleset *rs;
1759 int s, xadd = 0, xchange = 0;
1701 PF_COPYIN(addr+i, &ad, sizeof(ad), ec);
1702 if (ec)
1703 senderr(EFAULT);
1704#else
1705 if (copyin(addr+i, &ad, sizeof(ad)))
1706 senderr(EFAULT);
1707#endif
1708 if (pfr_validate_addr(&ad))

--- 39 unchanged lines hidden (view full) ---

1748int
1749pfr_ina_commit(struct pfr_table *trs, u_int32_t ticket, int *nadd,
1750 int *nchange, int flags)
1751{
1752 struct pfr_ktable *p;
1753 struct pfr_ktableworkq workq;
1754 struct pf_ruleset *rs;
1755 int s, xadd = 0, xchange = 0;
1760#if defined(__FreeBSD__)
1756#ifdef __FreeBSD__
1761 /*
1762 * XXX Is it OK under LP64 environments?
1763 */
1764 long tzero = (long)time_second;
1765#else
1766 long tzero = time.tv_sec;
1767#endif
1768

--- 418 unchanged lines hidden (view full) ---

2187 bzero(&tbl, sizeof(tbl));
2188 strlcpy(tbl.pfrt_name, name, sizeof(tbl.pfrt_name));
2189 if (ac != NULL) {
2190 strlcpy(tbl.pfrt_anchor, ac->name, sizeof(tbl.pfrt_anchor));
2191 strlcpy(tbl.pfrt_ruleset, rs->name, sizeof(tbl.pfrt_ruleset));
2192 }
2193 kt = pfr_lookup_table(&tbl);
2194 if (kt == NULL) {
1757 /*
1758 * XXX Is it OK under LP64 environments?
1759 */
1760 long tzero = (long)time_second;
1761#else
1762 long tzero = time.tv_sec;
1763#endif
1764

--- 418 unchanged lines hidden (view full) ---

2183 bzero(&tbl, sizeof(tbl));
2184 strlcpy(tbl.pfrt_name, name, sizeof(tbl.pfrt_name));
2185 if (ac != NULL) {
2186 strlcpy(tbl.pfrt_anchor, ac->name, sizeof(tbl.pfrt_anchor));
2187 strlcpy(tbl.pfrt_ruleset, rs->name, sizeof(tbl.pfrt_ruleset));
2188 }
2189 kt = pfr_lookup_table(&tbl);
2190 if (kt == NULL) {
2195#if defined(__FreeBSD__)
2191#ifdef __FreeBSD__
2196 /*
2197 * XXX Is it OK under LP64 environments?
2198 */
2199 kt = pfr_create_ktable(&tbl, (long)time_second, 1);
2200#else
2201 kt = pfr_create_ktable(&tbl, time.tv_sec, 1);
2202#endif
2203 if (kt == NULL)

--- 114 unchanged lines hidden (view full) ---

2318 struct pfr_walktree w;
2319
2320 bzero(&w, sizeof(w));
2321 w.pfrw_op = PFRW_POOL_GET;
2322 w.pfrw_cnt = idx;
2323
2324 switch(af) {
2325 case AF_INET:
2192 /*
2193 * XXX Is it OK under LP64 environments?
2194 */
2195 kt = pfr_create_ktable(&tbl, (long)time_second, 1);
2196#else
2197 kt = pfr_create_ktable(&tbl, time.tv_sec, 1);
2198#endif
2199 if (kt == NULL)

--- 114 unchanged lines hidden (view full) ---

2314 struct pfr_walktree w;
2315
2316 bzero(&w, sizeof(w));
2317 w.pfrw_op = PFRW_POOL_GET;
2318 w.pfrw_cnt = idx;
2319
2320 switch(af) {
2321 case AF_INET:
2326#if defined(__FreeBSD__)
2322#ifdef __FreeBSD__
2327 kt->pfrkt_ip4->rnh_walktree(kt->pfrkt_ip4, pfr_walktree, &w);
2328#else
2329 rn_walktree(kt->pfrkt_ip4, pfr_walktree, &w);
2330#endif
2331 return w.pfrw_kentry;
2332 case AF_INET6:
2323 kt->pfrkt_ip4->rnh_walktree(kt->pfrkt_ip4, pfr_walktree, &w);
2324#else
2325 rn_walktree(kt->pfrkt_ip4, pfr_walktree, &w);
2326#endif
2327 return w.pfrw_kentry;
2328 case AF_INET6:
2333#if defined(__FreeBSD__)
2329#ifdef __FreeBSD__
2334 kt->pfrkt_ip6->rnh_walktree(kt->pfrkt_ip6, pfr_walktree, &w);
2335#else
2336 rn_walktree(kt->pfrkt_ip6, pfr_walktree, &w);
2337#endif
2338 return w.pfrw_kentry;
2339 default:
2340 return NULL;
2341 }
2342}
2330 kt->pfrkt_ip6->rnh_walktree(kt->pfrkt_ip6, pfr_walktree, &w);
2331#else
2332 rn_walktree(kt->pfrkt_ip6, pfr_walktree, &w);
2333#endif
2334 return w.pfrw_kentry;
2335 default:
2336 return NULL;
2337 }
2338}