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