1 /* $FreeBSD$ */ 2 3 /* 4 * Copyright (C) 2012 by Darren Reed. 5 * 6 * See the IPFILTER.LICENCE file for details on licencing. 7 */ 8 #if defined(KERNEL) || defined(_KERNEL) 9 # undef KERNEL 10 # undef _KERNEL 11 # define KERNEL 1 12 # define _KERNEL 1 13 #endif 14 #include <sys/param.h> 15 #include <sys/types.h> 16 #include <sys/errno.h> 17 #include <sys/time.h> 18 #include <sys/file.h> 19 #if !defined(_KERNEL) 20 # include <stdlib.h> 21 # include <string.h> 22 # define _KERNEL 23 # include <sys/uio.h> 24 # undef _KERNEL 25 #endif 26 #include <sys/socket.h> 27 #if defined(__FreeBSD__) 28 # include <sys/malloc.h> 29 #endif 30 #if defined(__FreeBSD__) 31 # include <sys/cdefs.h> 32 # include <sys/proc.h> 33 #endif 34 #if !defined(__SVR4) 35 # include <sys/mbuf.h> 36 #endif 37 #if defined(_KERNEL) 38 # include <sys/systm.h> 39 #else 40 # include "ipf.h" 41 #endif 42 #include <netinet/in.h> 43 #include <net/if.h> 44 45 #include "netinet/ip_compat.h" 46 #include "netinet/ip_fil.h" 47 #include "netinet/ip_lookup.h" 48 #include "netinet/ip_htable.h" 49 /* END OF INCLUDES */ 50 51 #if !defined(lint) 52 static const char rcsid[] = "@(#)$Id$"; 53 #endif 54 55 # ifdef USE_INET6 56 static iphtent_t *ipf_iphmfind6(iphtable_t *, i6addr_t *); 57 # endif 58 static iphtent_t *ipf_iphmfind(iphtable_t *, struct in_addr *); 59 static int ipf_iphmfindip(ipf_main_softc_t *, void *, int, void *, u_int); 60 static int ipf_htable_clear(ipf_main_softc_t *, void *, iphtable_t *); 61 static int ipf_htable_create(ipf_main_softc_t *, void *, iplookupop_t *); 62 static int ipf_htable_deref(ipf_main_softc_t *, void *, void *); 63 static int ipf_htable_destroy(ipf_main_softc_t *, void *, int, char *); 64 static void *ipf_htable_exists(void *, int, char *); 65 static size_t ipf_htable_flush(ipf_main_softc_t *, void *, 66 iplookupflush_t *); 67 static void ipf_htable_free(void *, iphtable_t *); 68 static int ipf_htable_iter_deref(ipf_main_softc_t *, void *, int, 69 int, void *); 70 static int ipf_htable_iter_next(ipf_main_softc_t *, void *, ipftoken_t *, 71 ipflookupiter_t *); 72 static int ipf_htable_node_add(ipf_main_softc_t *, void *, 73 iplookupop_t *, int); 74 static int ipf_htable_node_del(ipf_main_softc_t *, void *, 75 iplookupop_t *, int); 76 static int ipf_htable_remove(ipf_main_softc_t *, void *, iphtable_t *); 77 static void *ipf_htable_soft_create(ipf_main_softc_t *); 78 static void ipf_htable_soft_destroy(ipf_main_softc_t *, void *); 79 static int ipf_htable_soft_init(ipf_main_softc_t *, void *); 80 static void ipf_htable_soft_fini(ipf_main_softc_t *, void *); 81 static int ipf_htable_stats_get(ipf_main_softc_t *, void *, 82 iplookupop_t *); 83 static int ipf_htable_table_add(ipf_main_softc_t *, void *, 84 iplookupop_t *); 85 static int ipf_htable_table_del(ipf_main_softc_t *, void *, 86 iplookupop_t *); 87 static int ipf_htent_deref(void *, iphtent_t *); 88 static iphtent_t *ipf_htent_find(iphtable_t *, iphtent_t *); 89 static int ipf_htent_insert(ipf_main_softc_t *, void *, iphtable_t *, 90 iphtent_t *); 91 static int ipf_htent_remove(ipf_main_softc_t *, void *, iphtable_t *, 92 iphtent_t *); 93 static void *ipf_htable_select_add_ref(void *, int, char *); 94 static void ipf_htable_expire(ipf_main_softc_t *, void *); 95 96 97 typedef struct ipf_htable_softc_s { 98 u_long ipht_nomem[LOOKUP_POOL_SZ]; 99 u_long ipf_nhtables[LOOKUP_POOL_SZ]; 100 u_long ipf_nhtnodes[LOOKUP_POOL_SZ]; 101 iphtable_t *ipf_htables[LOOKUP_POOL_SZ]; 102 iphtent_t *ipf_node_explist; 103 } ipf_htable_softc_t; 104 105 ipf_lookup_t ipf_htable_backend = { 106 IPLT_HASH, 107 ipf_htable_soft_create, 108 ipf_htable_soft_destroy, 109 ipf_htable_soft_init, 110 ipf_htable_soft_fini, 111 ipf_iphmfindip, 112 ipf_htable_flush, 113 ipf_htable_iter_deref, 114 ipf_htable_iter_next, 115 ipf_htable_node_add, 116 ipf_htable_node_del, 117 ipf_htable_stats_get, 118 ipf_htable_table_add, 119 ipf_htable_table_del, 120 ipf_htable_deref, 121 ipf_htable_exists, 122 ipf_htable_select_add_ref, 123 NULL, 124 ipf_htable_expire, 125 NULL 126 }; 127 128 129 /* ------------------------------------------------------------------------ */ 130 /* Function: ipf_htable_soft_create */ 131 /* Returns: void * - NULL = failure, else pointer to local context */ 132 /* Parameters: softc(I) - pointer to soft context main structure */ 133 /* */ 134 /* Initialise the routing table data structures where required. */ 135 /* ------------------------------------------------------------------------ */ 136 static void * 137 ipf_htable_soft_create(ipf_main_softc_t *softc) 138 { 139 ipf_htable_softc_t *softh; 140 141 KMALLOC(softh, ipf_htable_softc_t *); 142 if (softh == NULL) { 143 IPFERROR(30026); 144 return(NULL); 145 } 146 147 bzero((char *)softh, sizeof(*softh)); 148 149 return(softh); 150 } 151 152 153 /* ------------------------------------------------------------------------ */ 154 /* Function: ipf_htable_soft_destroy */ 155 /* Returns: Nil */ 156 /* Parameters: softc(I) - pointer to soft context main structure */ 157 /* arg(I) - pointer to local context to use */ 158 /* */ 159 /* Clean up the pool by free'ing the radix tree associated with it and free */ 160 /* up the pool context too. */ 161 /* ------------------------------------------------------------------------ */ 162 static void 163 ipf_htable_soft_destroy(ipf_main_softc_t *softc, void *arg) 164 { 165 ipf_htable_softc_t *softh = arg; 166 167 KFREE(softh); 168 } 169 170 171 /* ------------------------------------------------------------------------ */ 172 /* Function: ipf_htable_soft_init */ 173 /* Returns: int - 0 = success, else error */ 174 /* Parameters: softc(I) - pointer to soft context main structure */ 175 /* arg(I) - pointer to local context to use */ 176 /* */ 177 /* Initialise the hash table ready for use. */ 178 /* ------------------------------------------------------------------------ */ 179 static int 180 ipf_htable_soft_init(softc, arg) 181 ipf_main_softc_t *softc; 182 void *arg; 183 { 184 ipf_htable_softc_t *softh = arg; 185 186 bzero((char *)softh, sizeof(*softh)); 187 188 return(0); 189 } 190 191 192 /* ------------------------------------------------------------------------ */ 193 /* Function: ipf_htable_soft_fini */ 194 /* Returns: Nil */ 195 /* Parameters: softc(I) - pointer to soft context main structure */ 196 /* arg(I) - pointer to local context to use */ 197 /* Locks: WRITE(ipf_global) */ 198 /* */ 199 /* Clean up all the pool data structures allocated and call the cleanup */ 200 /* function for the radix tree that supports the pools. ipf_pool_destroy is */ 201 /* used to delete the pools one by one to ensure they're properly freed up. */ 202 /* ------------------------------------------------------------------------ */ 203 static void 204 ipf_htable_soft_fini(ipf_main_softc_t *softc, void *arg) 205 { 206 iplookupflush_t fop; 207 208 fop.iplf_type = IPLT_HASH; 209 fop.iplf_unit = IPL_LOGALL; 210 fop.iplf_arg = 0; 211 fop.iplf_count = 0; 212 *fop.iplf_name = '\0'; 213 ipf_htable_flush(softc, arg, &fop); 214 } 215 216 217 /* ------------------------------------------------------------------------ */ 218 /* Function: ipf_htable_stats_get */ 219 /* Returns: int - 0 = success, else error */ 220 /* Parameters: softc(I) - pointer to soft context main structure */ 221 /* arg(I) - pointer to local context to use */ 222 /* op(I) - pointer to lookup operation data */ 223 /* */ 224 /* Copy the relevant statistics out of internal structures and into the */ 225 /* structure used to export statistics. */ 226 /* ------------------------------------------------------------------------ */ 227 static int 228 ipf_htable_stats_get(ipf_main_softc_t *softc, void *arg, iplookupop_t *op) 229 { 230 ipf_htable_softc_t *softh = arg; 231 iphtstat_t stats; 232 int err; 233 234 if (op->iplo_size != sizeof(stats)) { 235 IPFERROR(30001); 236 return(EINVAL); 237 } 238 239 stats.iphs_tables = softh->ipf_htables[op->iplo_unit + 1]; 240 stats.iphs_numtables = softh->ipf_nhtables[op->iplo_unit + 1]; 241 stats.iphs_numnodes = softh->ipf_nhtnodes[op->iplo_unit + 1]; 242 stats.iphs_nomem = softh->ipht_nomem[op->iplo_unit + 1]; 243 244 err = COPYOUT(&stats, op->iplo_struct, sizeof(stats)); 245 if (err != 0) { 246 IPFERROR(30013); 247 return(EFAULT); 248 } 249 return(0); 250 251 } 252 253 254 /* ------------------------------------------------------------------------ */ 255 /* Function: ipf_htable_create */ 256 /* Returns: int - 0 = success, else error */ 257 /* Parameters: softc(I) - pointer to soft context main structure */ 258 /* arg(I) - pointer to local context to use */ 259 /* op(I) - pointer to lookup operation data */ 260 /* */ 261 /* Create a new hash table using the template passed. */ 262 /* ------------------------------------------------------------------------ */ 263 static int 264 ipf_htable_create(ipf_main_softc_t *softc, void *arg, iplookupop_t *op) 265 { 266 ipf_htable_softc_t *softh = arg; 267 iphtable_t htab, *iph, *oiph; 268 char name[FR_GROUPLEN]; 269 int err, i, unit; 270 271 if (op->iplo_size != sizeof(htab)) { 272 IPFERROR(30024); 273 return(EINVAL); 274 } 275 err = COPYIN(op->iplo_struct, &htab, sizeof(htab)); 276 if (err != 0) { 277 IPFERROR(30003); 278 return(EFAULT); 279 } 280 281 unit = op->iplo_unit; 282 if (htab.iph_unit != unit) { 283 IPFERROR(30005); 284 return(EINVAL); 285 } 286 if (htab.iph_size < 1) { 287 IPFERROR(30025); 288 return(EINVAL); 289 } 290 291 292 if ((op->iplo_arg & IPHASH_ANON) == 0) { 293 iph = ipf_htable_exists(softh, unit, op->iplo_name); 294 if (iph != NULL) { 295 if ((iph->iph_flags & IPHASH_DELETE) == 0) { 296 IPFERROR(30004); 297 return(EEXIST); 298 } 299 iph->iph_flags &= ~IPHASH_DELETE; 300 iph->iph_ref++; 301 return(0); 302 } 303 } 304 305 KMALLOC(iph, iphtable_t *); 306 if (iph == NULL) { 307 softh->ipht_nomem[op->iplo_unit + 1]++; 308 IPFERROR(30002); 309 return(ENOMEM); 310 } 311 *iph = htab; 312 313 if ((op->iplo_arg & IPHASH_ANON) != 0) { 314 i = IPHASH_ANON; 315 do { 316 i++; 317 (void)snprintf(name, sizeof(name), "%u", i); 318 for (oiph = softh->ipf_htables[unit + 1]; oiph != NULL; 319 oiph = oiph->iph_next) 320 if (strncmp(oiph->iph_name, name, 321 sizeof(oiph->iph_name)) == 0) 322 break; 323 } while (oiph != NULL); 324 325 (void)strncpy(iph->iph_name, name, sizeof(iph->iph_name)); 326 (void)strncpy(op->iplo_name, name, sizeof(op->iplo_name)); 327 iph->iph_type |= IPHASH_ANON; 328 } else { 329 (void)strncpy(iph->iph_name, op->iplo_name, 330 sizeof(iph->iph_name)); 331 iph->iph_name[sizeof(iph->iph_name) - 1] = '\0'; 332 } 333 334 KMALLOCS(iph->iph_table, iphtent_t **, 335 iph->iph_size * sizeof(*iph->iph_table)); 336 if (iph->iph_table == NULL) { 337 KFREE(iph); 338 softh->ipht_nomem[unit + 1]++; 339 IPFERROR(30006); 340 return(ENOMEM); 341 } 342 343 bzero((char *)iph->iph_table, iph->iph_size * sizeof(*iph->iph_table)); 344 iph->iph_maskset[0] = 0; 345 iph->iph_maskset[1] = 0; 346 iph->iph_maskset[2] = 0; 347 iph->iph_maskset[3] = 0; 348 349 iph->iph_ref = 1; 350 iph->iph_list = NULL; 351 iph->iph_tail = &iph->iph_list; 352 iph->iph_next = softh->ipf_htables[unit + 1]; 353 iph->iph_pnext = &softh->ipf_htables[unit + 1]; 354 if (softh->ipf_htables[unit + 1] != NULL) 355 softh->ipf_htables[unit + 1]->iph_pnext = &iph->iph_next; 356 softh->ipf_htables[unit + 1] = iph; 357 358 softh->ipf_nhtables[unit + 1]++; 359 360 return(0); 361 } 362 363 364 /* ------------------------------------------------------------------------ */ 365 /* Function: ipf_htable_table_del */ 366 /* Returns: int - 0 = success, else error */ 367 /* Parameters: softc(I) - pointer to soft context main structure */ 368 /* arg(I) - pointer to local context to use */ 369 /* op(I) - pointer to lookup operation data */ 370 /* */ 371 /* ------------------------------------------------------------------------ */ 372 static int 373 ipf_htable_table_del(ipf_main_softc_t *softc, void *arg, iplookupop_t *op) 374 { 375 return(ipf_htable_destroy(softc, arg, op->iplo_unit, op->iplo_name)); 376 } 377 378 379 /* ------------------------------------------------------------------------ */ 380 /* Function: ipf_htable_destroy */ 381 /* Returns: int - 0 = success, else error */ 382 /* Parameters: softc(I) - pointer to soft context main structure */ 383 /* arg(I) - pointer to local context to use */ 384 /* op(I) - pointer to lookup operation data */ 385 /* */ 386 /* Find the hash table that belongs to the relevant part of ipfilter with a */ 387 /* matching name and attempt to destroy it. If it is in use, empty it out */ 388 /* and mark it for deletion so that when all the references disappear, it */ 389 /* can be removed. */ 390 /* ------------------------------------------------------------------------ */ 391 static int 392 ipf_htable_destroy(ipf_main_softc_t *softc, void *arg, int unit, char *name) 393 { 394 iphtable_t *iph; 395 396 iph = ipf_htable_find(arg, unit, name); 397 if (iph == NULL) { 398 IPFERROR(30007); 399 return(ESRCH); 400 } 401 402 if (iph->iph_unit != unit) { 403 IPFERROR(30008); 404 return(EINVAL); 405 } 406 407 if (iph->iph_ref != 0) { 408 ipf_htable_clear(softc, arg, iph); 409 iph->iph_flags |= IPHASH_DELETE; 410 return(0); 411 } 412 413 ipf_htable_remove(softc, arg, iph); 414 415 return(0); 416 } 417 418 419 /* ------------------------------------------------------------------------ */ 420 /* Function: ipf_htable_clear */ 421 /* Returns: int - 0 = success, else error */ 422 /* Parameters: softc(I) - pointer to soft context main structure */ 423 /* arg(I) - pointer to local context to use */ 424 /* iph(I) - pointer to hash table to destroy */ 425 /* */ 426 /* Clean out the hash table by walking the list of entries and removing */ 427 /* each one, one by one. */ 428 /* ------------------------------------------------------------------------ */ 429 static int 430 ipf_htable_clear(ipf_main_softc_t *softc, void *arg, iphtable_t *iph) 431 { 432 iphtent_t *ipe; 433 434 while ((ipe = iph->iph_list) != NULL) 435 if (ipf_htent_remove(softc, arg, iph, ipe) != 0) 436 return(1); 437 return(0); 438 } 439 440 441 /* ------------------------------------------------------------------------ */ 442 /* Function: ipf_htable_free */ 443 /* Returns: Nil */ 444 /* Parameters: arg(I) - pointer to local context to use */ 445 /* iph(I) - pointer to hash table to destroy */ 446 /* */ 447 /* ------------------------------------------------------------------------ */ 448 static void 449 ipf_htable_free(void *arg, iphtable_t *iph) 450 { 451 ipf_htable_softc_t *softh = arg; 452 453 if (iph->iph_next != NULL) 454 iph->iph_next->iph_pnext = iph->iph_pnext; 455 if (iph->iph_pnext != NULL) 456 *iph->iph_pnext = iph->iph_next; 457 iph->iph_pnext = NULL; 458 iph->iph_next = NULL; 459 460 softh->ipf_nhtables[iph->iph_unit + 1]--; 461 462 KFREES(iph->iph_table, iph->iph_size * sizeof(*iph->iph_table)); 463 KFREE(iph); 464 } 465 466 467 /* ------------------------------------------------------------------------ */ 468 /* Function: ipf_htable_remove */ 469 /* Returns: int - 0 = success, else error */ 470 /* Parameters: softc(I) - pointer to soft context main structure */ 471 /* arg(I) - pointer to local context to use */ 472 /* iph(I) - pointer to hash table to destroy */ 473 /* */ 474 /* It is necessary to unlink here as well as free (called by deref) so that */ 475 /* the while loop in ipf_htable_flush() functions properly. */ 476 /* ------------------------------------------------------------------------ */ 477 static int 478 ipf_htable_remove(ipf_main_softc_t *softc, void *arg, iphtable_t *iph) 479 { 480 481 if (ipf_htable_clear(softc, arg, iph) != 0) 482 return(1); 483 484 if (iph->iph_pnext != NULL) 485 *iph->iph_pnext = iph->iph_next; 486 if (iph->iph_next != NULL) 487 iph->iph_next->iph_pnext = iph->iph_pnext; 488 iph->iph_pnext = NULL; 489 iph->iph_next = NULL; 490 491 return(ipf_htable_deref(softc, arg, iph)); 492 } 493 494 495 /* ------------------------------------------------------------------------ */ 496 /* Function: ipf_htable_node_del */ 497 /* Returns: int - 0 = success, else error */ 498 /* Parameters: softc(I) - pointer to soft context main structure */ 499 /* arg(I) - pointer to local context to use */ 500 /* op(I) - pointer to lookup operation data */ 501 /* uid(I) - real uid of process doing operation */ 502 /* */ 503 /* ------------------------------------------------------------------------ */ 504 static int 505 ipf_htable_node_del(ipf_main_softc_t *softc, void *arg, iplookupop_t *op, 506 int uid) 507 { 508 iphtable_t *iph; 509 iphtent_t hte, *ent; 510 int err; 511 512 if (op->iplo_size != sizeof(hte)) { 513 IPFERROR(30014); 514 return(EINVAL); 515 } 516 517 err = COPYIN(op->iplo_struct, &hte, sizeof(hte)); 518 if (err != 0) { 519 IPFERROR(30015); 520 return(EFAULT); 521 } 522 523 iph = ipf_htable_find(arg, op->iplo_unit, op->iplo_name); 524 if (iph == NULL) { 525 IPFERROR(30016); 526 return(ESRCH); 527 } 528 529 ent = ipf_htent_find(iph, &hte); 530 if (ent == NULL) { 531 IPFERROR(30022); 532 return(ESRCH); 533 } 534 535 if ((uid != 0) && (ent->ipe_uid != uid)) { 536 IPFERROR(30023); 537 return(EACCES); 538 } 539 540 err = ipf_htent_remove(softc, arg, iph, ent); 541 542 return(err); 543 } 544 545 546 /* ------------------------------------------------------------------------ */ 547 /* Function: ipf_htable_node_del */ 548 /* Returns: int - 0 = success, else error */ 549 /* Parameters: softc(I) - pointer to soft context main structure */ 550 /* arg(I) - pointer to local context to use */ 551 /* op(I) - pointer to lookup operation data */ 552 /* */ 553 /* ------------------------------------------------------------------------ */ 554 static int 555 ipf_htable_table_add(ipf_main_softc_t *softc, void *arg, iplookupop_t *op) 556 { 557 int err; 558 559 if (ipf_htable_find(arg, op->iplo_unit, op->iplo_name) != NULL) { 560 IPFERROR(30017); 561 err = EEXIST; 562 } else { 563 err = ipf_htable_create(softc, arg, op); 564 } 565 566 return(err); 567 } 568 569 570 /* ------------------------------------------------------------------------ */ 571 /* Function: ipf_htent_remove */ 572 /* Returns: int - 0 = success, else error */ 573 /* Parameters: softc(I) - pointer to soft context main structure */ 574 /* arg(I) - pointer to local context to use */ 575 /* iph(I) - pointer to hash table */ 576 /* ipe(I) - pointer to hash table entry to remove */ 577 /* */ 578 /* Delete an entry from a hash table. */ 579 /* ------------------------------------------------------------------------ */ 580 static int 581 ipf_htent_remove(ipf_main_softc_t *softc, void *arg, iphtable_t *iph, 582 iphtent_t *ipe) 583 { 584 585 if (iph->iph_tail == &ipe->ipe_next) 586 iph->iph_tail = ipe->ipe_pnext; 587 588 if (ipe->ipe_hnext != NULL) 589 ipe->ipe_hnext->ipe_phnext = ipe->ipe_phnext; 590 if (ipe->ipe_phnext != NULL) 591 *ipe->ipe_phnext = ipe->ipe_hnext; 592 ipe->ipe_phnext = NULL; 593 ipe->ipe_hnext = NULL; 594 595 if (ipe->ipe_dnext != NULL) 596 ipe->ipe_dnext->ipe_pdnext = ipe->ipe_pdnext; 597 if (ipe->ipe_pdnext != NULL) 598 *ipe->ipe_pdnext = ipe->ipe_dnext; 599 ipe->ipe_pdnext = NULL; 600 ipe->ipe_dnext = NULL; 601 602 if (ipe->ipe_next != NULL) 603 ipe->ipe_next->ipe_pnext = ipe->ipe_pnext; 604 if (ipe->ipe_pnext != NULL) 605 *ipe->ipe_pnext = ipe->ipe_next; 606 ipe->ipe_pnext = NULL; 607 ipe->ipe_next = NULL; 608 609 switch (iph->iph_type & ~IPHASH_ANON) 610 { 611 case IPHASH_GROUPMAP : 612 if (ipe->ipe_group != NULL) 613 ipf_group_del(softc, ipe->ipe_ptr, NULL); 614 break; 615 616 default : 617 ipe->ipe_ptr = NULL; 618 ipe->ipe_value = 0; 619 break; 620 } 621 622 return(ipf_htent_deref(arg, ipe)); 623 } 624 625 626 /* ------------------------------------------------------------------------ */ 627 /* Function: ipf_htable_deref */ 628 /* Returns: int - 0 = success, else error */ 629 /* Parameters: softc(I) - pointer to soft context main structure */ 630 /* arg(I) - pointer to local context to use */ 631 /* object(I) - pointer to hash table */ 632 /* */ 633 /* ------------------------------------------------------------------------ */ 634 static int 635 ipf_htable_deref(ipf_main_softc_t *softc, void *arg, void *object) 636 { 637 ipf_htable_softc_t *softh = arg; 638 iphtable_t *iph = object; 639 int refs; 640 641 iph->iph_ref--; 642 refs = iph->iph_ref; 643 644 if (iph->iph_ref == 0) { 645 ipf_htable_free(softh, iph); 646 } 647 648 return(refs); 649 } 650 651 652 /* ------------------------------------------------------------------------ */ 653 /* Function: ipf_htent_deref */ 654 /* Parameters: arg(I) - pointer to local context to use */ 655 /* ipe(I) - */ 656 /* */ 657 /* ------------------------------------------------------------------------ */ 658 static int 659 ipf_htent_deref(void *arg, iphtent_t *ipe) 660 { 661 ipf_htable_softc_t *softh = arg; 662 663 ipe->ipe_ref--; 664 if (ipe->ipe_ref == 0) { 665 softh->ipf_nhtnodes[ipe->ipe_unit + 1]--; 666 KFREE(ipe); 667 668 return(0); 669 } 670 671 return(ipe->ipe_ref); 672 } 673 674 675 /* ------------------------------------------------------------------------ */ 676 /* Function: ipf_htable_exists */ 677 /* Parameters: arg(I) - pointer to local context to use */ 678 /* */ 679 /* ------------------------------------------------------------------------ */ 680 static void * 681 ipf_htable_exists(void *arg, int unit, char *name) 682 { 683 ipf_htable_softc_t *softh = arg; 684 iphtable_t *iph; 685 686 if (unit == IPL_LOGALL) { 687 int i; 688 689 for (i = 0; i <= LOOKUP_POOL_MAX; i++) { 690 for (iph = softh->ipf_htables[i]; iph != NULL; 691 iph = iph->iph_next) { 692 if (strncmp(iph->iph_name, name, 693 sizeof(iph->iph_name)) == 0) 694 break; 695 } 696 if (iph != NULL) 697 break; 698 } 699 } else { 700 for (iph = softh->ipf_htables[unit + 1]; iph != NULL; 701 iph = iph->iph_next) { 702 if (strncmp(iph->iph_name, name, 703 sizeof(iph->iph_name)) == 0) 704 break; 705 } 706 } 707 return(iph); 708 } 709 710 711 /* ------------------------------------------------------------------------ */ 712 /* Function: ipf_htable_select_add_ref */ 713 /* Returns: void * - NULL = failure, else pointer to the hash table */ 714 /* Parameters: arg(I) - pointer to local context to use */ 715 /* unit(I) - ipfilter device to which we are working on */ 716 /* name(I) - name of the hash table */ 717 /* */ 718 /* ------------------------------------------------------------------------ */ 719 static void * 720 ipf_htable_select_add_ref(void *arg, int unit, char *name) 721 { 722 iphtable_t *iph; 723 724 iph = ipf_htable_exists(arg, unit, name); 725 if (iph != NULL) { 726 ATOMIC_INC32(iph->iph_ref); 727 } 728 return(iph); 729 } 730 731 732 /* ------------------------------------------------------------------------ */ 733 /* Function: ipf_htable_find */ 734 /* Returns: void * - NULL = failure, else pointer to the hash table */ 735 /* Parameters: arg(I) - pointer to local context to use */ 736 /* unit(I) - ipfilter device to which we are working on */ 737 /* name(I) - name of the hash table */ 738 /* */ 739 /* This function is exposed becaues it is used in the group-map feature. */ 740 /* ------------------------------------------------------------------------ */ 741 iphtable_t * 742 ipf_htable_find(void *arg, int unit, char *name) 743 { 744 iphtable_t *iph; 745 746 iph = ipf_htable_exists(arg, unit, name); 747 if ((iph != NULL) && (iph->iph_flags & IPHASH_DELETE) == 0) 748 return(iph); 749 750 return(NULL); 751 } 752 753 754 /* ------------------------------------------------------------------------ */ 755 /* Function: ipf_htable_flush */ 756 /* Returns: size_t - number of entries flushed */ 757 /* Parameters: softc(I) - pointer to soft context main structure */ 758 /* arg(I) - pointer to local context to use */ 759 /* op(I) - pointer to lookup operation data */ 760 /* */ 761 /* ------------------------------------------------------------------------ */ 762 static size_t 763 ipf_htable_flush(ipf_main_softc_t *softc, void *arg, iplookupflush_t *op) 764 { 765 ipf_htable_softc_t *softh = arg; 766 iphtable_t *iph; 767 size_t freed; 768 int i; 769 770 freed = 0; 771 772 for (i = -1; i <= IPL_LOGMAX; i++) { 773 if (op->iplf_unit == i || op->iplf_unit == IPL_LOGALL) { 774 while ((iph = softh->ipf_htables[i + 1]) != NULL) { 775 if (ipf_htable_remove(softc, arg, iph) == 0) { 776 freed++; 777 } else { 778 iph->iph_flags |= IPHASH_DELETE; 779 } 780 } 781 } 782 } 783 784 return(freed); 785 } 786 787 788 /* ------------------------------------------------------------------------ */ 789 /* Function: ipf_htable_node_add */ 790 /* Returns: int - 0 = success, else error */ 791 /* Parameters: softc(I) - pointer to soft context main structure */ 792 /* arg(I) - pointer to local context to use */ 793 /* op(I) - pointer to lookup operation data */ 794 /* uid(I) - real uid of process doing operation */ 795 /* */ 796 /* ------------------------------------------------------------------------ */ 797 static int 798 ipf_htable_node_add(ipf_main_softc_t *softc, void *arg, iplookupop_t *op, 799 int uid) 800 { 801 iphtable_t *iph; 802 iphtent_t hte; 803 int err; 804 805 if (op->iplo_size != sizeof(hte)) { 806 IPFERROR(30018); 807 return(EINVAL); 808 } 809 810 err = COPYIN(op->iplo_struct, &hte, sizeof(hte)); 811 if (err != 0) { 812 IPFERROR(30019); 813 return(EFAULT); 814 } 815 hte.ipe_uid = uid; 816 817 iph = ipf_htable_find(arg, op->iplo_unit, op->iplo_name); 818 if (iph == NULL) { 819 IPFERROR(30020); 820 return(ESRCH); 821 } 822 823 if (ipf_htent_find(iph, &hte) != NULL) { 824 IPFERROR(30021); 825 return(EEXIST); 826 } 827 828 err = ipf_htent_insert(softc, arg, iph, &hte); 829 830 return(err); 831 } 832 833 834 /* ------------------------------------------------------------------------ */ 835 /* Function: ipf_htent_insert */ 836 /* Returns: int - 0 = success, -1 = error */ 837 /* Parameters: softc(I) - pointer to soft context main structure */ 838 /* arg(I) - pointer to local context to use */ 839 /* op(I) - pointer to lookup operation data */ 840 /* ipeo(I) - */ 841 /* */ 842 /* Add an entry to a hash table. */ 843 /* ------------------------------------------------------------------------ */ 844 static int 845 ipf_htent_insert(ipf_main_softc_t *softc, void *arg, iphtable_t *iph, 846 iphtent_t *ipeo) 847 { 848 ipf_htable_softc_t *softh = arg; 849 iphtent_t *ipe; 850 u_int hv; 851 int bits; 852 853 KMALLOC(ipe, iphtent_t *); 854 if (ipe == NULL) 855 return(-1); 856 857 bcopy((char *)ipeo, (char *)ipe, sizeof(*ipe)); 858 ipe->ipe_addr.i6[0] &= ipe->ipe_mask.i6[0]; 859 if (ipe->ipe_family == AF_INET) { 860 bits = count4bits(ipe->ipe_mask.in4_addr); 861 ipe->ipe_addr.i6[1] = 0; 862 ipe->ipe_addr.i6[2] = 0; 863 ipe->ipe_addr.i6[3] = 0; 864 ipe->ipe_mask.i6[1] = 0; 865 ipe->ipe_mask.i6[2] = 0; 866 ipe->ipe_mask.i6[3] = 0; 867 hv = IPE_V4_HASH_FN(ipe->ipe_addr.in4_addr, 868 ipe->ipe_mask.in4_addr, iph->iph_size); 869 } else 870 #ifdef USE_INET6 871 if (ipe->ipe_family == AF_INET6) { 872 ipe->ipe_addr.i6[1] &= ipe->ipe_mask.i6[1]; 873 ipe->ipe_addr.i6[2] &= ipe->ipe_mask.i6[2]; 874 ipe->ipe_addr.i6[3] &= ipe->ipe_mask.i6[3]; 875 876 bits = count6bits(ipe->ipe_mask.i6); 877 hv = IPE_V6_HASH_FN(ipe->ipe_addr.i6, 878 ipe->ipe_mask.i6, iph->iph_size); 879 } else 880 #endif 881 { 882 KFREE(ipe); 883 return(-1); 884 } 885 886 ipe->ipe_owner = iph; 887 ipe->ipe_ref = 1; 888 ipe->ipe_hnext = iph->iph_table[hv]; 889 ipe->ipe_phnext = iph->iph_table + hv; 890 891 if (iph->iph_table[hv] != NULL) 892 iph->iph_table[hv]->ipe_phnext = &ipe->ipe_hnext; 893 iph->iph_table[hv] = ipe; 894 895 ipe->ipe_pnext = iph->iph_tail; 896 *iph->iph_tail = ipe; 897 iph->iph_tail = &ipe->ipe_next; 898 ipe->ipe_next = NULL; 899 900 if (ipe->ipe_die != 0) { 901 /* 902 * If the new node has a given expiration time, insert it 903 * into the list of expiring nodes with the ones to be 904 * removed first added to the front of the list. The 905 * insertion is O(n) but it is kept sorted for quick scans 906 * at expiration interval checks. 907 */ 908 iphtent_t *n; 909 910 ipe->ipe_die = softc->ipf_ticks + IPF_TTLVAL(ipe->ipe_die); 911 for (n = softh->ipf_node_explist; n != NULL; n = n->ipe_dnext) { 912 if (ipe->ipe_die < n->ipe_die) 913 break; 914 if (n->ipe_dnext == NULL) { 915 /* 916 * We've got to the last node and everything 917 * wanted to be expired before this new node, 918 * so we have to tack it on the end... 919 */ 920 n->ipe_dnext = ipe; 921 ipe->ipe_pdnext = &n->ipe_dnext; 922 n = NULL; 923 break; 924 } 925 } 926 927 if (softh->ipf_node_explist == NULL) { 928 softh->ipf_node_explist = ipe; 929 ipe->ipe_pdnext = &softh->ipf_node_explist; 930 } else if (n != NULL) { 931 ipe->ipe_dnext = n; 932 ipe->ipe_pdnext = n->ipe_pdnext; 933 n->ipe_pdnext = &ipe->ipe_dnext; 934 } 935 } 936 937 if (ipe->ipe_family == AF_INET) { 938 ipf_inet_mask_add(bits, &iph->iph_v4_masks); 939 } 940 #ifdef USE_INET6 941 else if (ipe->ipe_family == AF_INET6) { 942 ipf_inet6_mask_add(bits, &ipe->ipe_mask, &iph->iph_v6_masks); 943 } 944 #endif 945 946 switch (iph->iph_type & ~IPHASH_ANON) 947 { 948 case IPHASH_GROUPMAP : 949 ipe->ipe_ptr = ipf_group_add(softc, ipe->ipe_group, NULL, 950 iph->iph_flags, IPL_LOGIPF, 951 softc->ipf_active); 952 break; 953 954 default : 955 ipe->ipe_ptr = NULL; 956 ipe->ipe_value = 0; 957 break; 958 } 959 960 ipe->ipe_unit = iph->iph_unit; 961 softh->ipf_nhtnodes[ipe->ipe_unit + 1]++; 962 963 return(0); 964 } 965 966 967 /* ------------------------------------------------------------------------ */ 968 /* Function: ipf_htent_find */ 969 /* Returns: int - 0 = success, else error */ 970 /* Parameters: iph(I) - pointer to table to search */ 971 /* ipeo(I) - pointer to entry to find */ 972 /* */ 973 /* While it isn't absolutely necessary to for the address and mask to be */ 974 /* passed in through an iphtent_t structure, one is always present when it */ 975 /* is time to call this function, so it is just more convenient. */ 976 /* ------------------------------------------------------------------------ */ 977 static iphtent_t * 978 ipf_htent_find(iphtable_t *iph, iphtent_t *ipeo) 979 { 980 iphtent_t ipe, *ent; 981 u_int hv; 982 int bits; 983 984 bcopy((char *)ipeo, (char *)&ipe, sizeof(ipe)); 985 ipe.ipe_addr.i6[0] &= ipe.ipe_mask.i6[0]; 986 ipe.ipe_addr.i6[1] &= ipe.ipe_mask.i6[1]; 987 ipe.ipe_addr.i6[2] &= ipe.ipe_mask.i6[2]; 988 ipe.ipe_addr.i6[3] &= ipe.ipe_mask.i6[3]; 989 if (ipe.ipe_family == AF_INET) { 990 bits = count4bits(ipe.ipe_mask.in4_addr); 991 ipe.ipe_addr.i6[1] = 0; 992 ipe.ipe_addr.i6[2] = 0; 993 ipe.ipe_addr.i6[3] = 0; 994 ipe.ipe_mask.i6[1] = 0; 995 ipe.ipe_mask.i6[2] = 0; 996 ipe.ipe_mask.i6[3] = 0; 997 hv = IPE_V4_HASH_FN(ipe.ipe_addr.in4_addr, 998 ipe.ipe_mask.in4_addr, iph->iph_size); 999 } else 1000 #ifdef USE_INET6 1001 if (ipe.ipe_family == AF_INET6) { 1002 bits = count6bits(ipe.ipe_mask.i6); 1003 hv = IPE_V6_HASH_FN(ipe.ipe_addr.i6, 1004 ipe.ipe_mask.i6, iph->iph_size); 1005 } else 1006 #endif 1007 return(NULL); 1008 1009 for (ent = iph->iph_table[hv]; ent != NULL; ent = ent->ipe_hnext) { 1010 if (ent->ipe_family != ipe.ipe_family) 1011 continue; 1012 if (IP6_NEQ(&ipe.ipe_addr, &ent->ipe_addr)) 1013 continue; 1014 if (IP6_NEQ(&ipe.ipe_mask, &ent->ipe_mask)) 1015 continue; 1016 break; 1017 } 1018 1019 return(ent); 1020 } 1021 1022 1023 /* ------------------------------------------------------------------------ */ 1024 /* Function: ipf_iphmfindgroup */ 1025 /* Returns: int - 0 = success, else error */ 1026 /* Parameters: softc(I) - pointer to soft context main structure */ 1027 /* tptr(I) - */ 1028 /* aptr(I) - */ 1029 /* */ 1030 /* Search a hash table for a matching entry and return the pointer stored */ 1031 /* in it for use as the next group of rules to search. */ 1032 /* */ 1033 /* This function is exposed becaues it is used in the group-map feature. */ 1034 /* ------------------------------------------------------------------------ */ 1035 void * 1036 ipf_iphmfindgroup(ipf_main_softc_t *softc, void *tptr, void *aptr) 1037 { 1038 struct in_addr *addr; 1039 iphtable_t *iph; 1040 iphtent_t *ipe; 1041 void *rval; 1042 1043 READ_ENTER(&softc->ipf_poolrw); 1044 iph = tptr; 1045 addr = aptr; 1046 1047 ipe = ipf_iphmfind(iph, addr); 1048 if (ipe != NULL) 1049 rval = ipe->ipe_ptr; 1050 else 1051 rval = NULL; 1052 RWLOCK_EXIT(&softc->ipf_poolrw); 1053 return(rval); 1054 } 1055 1056 1057 /* ------------------------------------------------------------------------ */ 1058 /* Function: ipf_iphmfindip */ 1059 /* Returns: int - 0 == +ve match, -1 == error, 1 == -ve/no match */ 1060 /* Parameters: softc(I) - pointer to soft context main structure */ 1061 /* tptr(I) - pointer to the pool to search */ 1062 /* ipversion(I) - IP protocol version (4 or 6) */ 1063 /* aptr(I) - pointer to address information */ 1064 /* bytes(I) - packet length */ 1065 /* */ 1066 /* Search the hash table for a given address and return a search result. */ 1067 /* ------------------------------------------------------------------------ */ 1068 static int 1069 ipf_iphmfindip(ipf_main_softc_t *softc, void *tptr, int ipversion, void *aptr, 1070 u_int bytes) 1071 { 1072 struct in_addr *addr; 1073 iphtable_t *iph; 1074 iphtent_t *ipe; 1075 int rval; 1076 1077 if (tptr == NULL || aptr == NULL) 1078 return(-1); 1079 1080 iph = tptr; 1081 addr = aptr; 1082 1083 READ_ENTER(&softc->ipf_poolrw); 1084 if (ipversion == 4) { 1085 ipe = ipf_iphmfind(iph, addr); 1086 #ifdef USE_INET6 1087 } else if (ipversion == 6) { 1088 ipe = ipf_iphmfind6(iph, (i6addr_t *)addr); 1089 #endif 1090 } else { 1091 ipe = NULL; 1092 } 1093 1094 if (ipe != NULL) { 1095 rval = 0; 1096 ipe->ipe_hits++; 1097 ipe->ipe_bytes += bytes; 1098 } else { 1099 rval = 1; 1100 } 1101 RWLOCK_EXIT(&softc->ipf_poolrw); 1102 return(rval); 1103 } 1104 1105 1106 /* ------------------------------------------------------------------------ */ 1107 /* Function: ipf_iphmfindip */ 1108 /* Parameters: iph(I) - pointer to hash table */ 1109 /* addr(I) - pointer to IPv4 address */ 1110 /* Locks: ipf_poolrw */ 1111 /* */ 1112 /* ------------------------------------------------------------------------ */ 1113 static iphtent_t * 1114 ipf_iphmfind(iphtable_t *iph, struct in_addr *addr) 1115 { 1116 u_32_t msk, ips; 1117 iphtent_t *ipe; 1118 u_int hv; 1119 int i; 1120 1121 i = 0; 1122 maskloop: 1123 msk = iph->iph_v4_masks.imt4_active[i]; 1124 ips = addr->s_addr & msk; 1125 hv = IPE_V4_HASH_FN(ips, msk, iph->iph_size); 1126 for (ipe = iph->iph_table[hv]; (ipe != NULL); ipe = ipe->ipe_hnext) { 1127 if ((ipe->ipe_family != AF_INET) || 1128 (ipe->ipe_mask.in4_addr != msk) || 1129 (ipe->ipe_addr.in4_addr != ips)) { 1130 continue; 1131 } 1132 break; 1133 } 1134 1135 if (ipe == NULL) { 1136 i++; 1137 if (i < iph->iph_v4_masks.imt4_max) 1138 goto maskloop; 1139 } 1140 return(ipe); 1141 } 1142 1143 1144 /* ------------------------------------------------------------------------ */ 1145 /* Function: ipf_htable_iter_next */ 1146 /* Returns: int - 0 = success, else error */ 1147 /* Parameters: softc(I) - pointer to soft context main structure */ 1148 /* arg(I) - pointer to local context to use */ 1149 /* token(I) - */ 1150 /* ilp(I) - */ 1151 /* */ 1152 /* ------------------------------------------------------------------------ */ 1153 static int 1154 ipf_htable_iter_next(ipf_main_softc_t *softc, void *arg, ipftoken_t *token, 1155 ipflookupiter_t *ilp) 1156 { 1157 ipf_htable_softc_t *softh = arg; 1158 iphtent_t *node, zn, *nextnode; 1159 iphtable_t *iph, zp, *nextiph; 1160 void *hnext; 1161 int err; 1162 1163 err = 0; 1164 iph = NULL; 1165 node = NULL; 1166 nextiph = NULL; 1167 nextnode = NULL; 1168 1169 READ_ENTER(&softc->ipf_poolrw); 1170 1171 switch (ilp->ili_otype) 1172 { 1173 case IPFLOOKUPITER_LIST : 1174 iph = token->ipt_data; 1175 if (iph == NULL) { 1176 nextiph = softh->ipf_htables[(int)ilp->ili_unit + 1]; 1177 } else { 1178 nextiph = iph->iph_next; 1179 } 1180 1181 if (nextiph != NULL) { 1182 ATOMIC_INC(nextiph->iph_ref); 1183 token->ipt_data = nextiph; 1184 } else { 1185 bzero((char *)&zp, sizeof(zp)); 1186 nextiph = &zp; 1187 token->ipt_data = NULL; 1188 } 1189 hnext = nextiph->iph_next; 1190 break; 1191 1192 case IPFLOOKUPITER_NODE : 1193 node = token->ipt_data; 1194 if (node == NULL) { 1195 iph = ipf_htable_find(arg, ilp->ili_unit, 1196 ilp->ili_name); 1197 if (iph == NULL) { 1198 IPFERROR(30009); 1199 err = ESRCH; 1200 } else { 1201 nextnode = iph->iph_list; 1202 } 1203 } else { 1204 nextnode = node->ipe_next; 1205 } 1206 1207 if (nextnode != NULL) { 1208 ATOMIC_INC(nextnode->ipe_ref); 1209 token->ipt_data = nextnode; 1210 } else { 1211 bzero((char *)&zn, sizeof(zn)); 1212 nextnode = &zn; 1213 token->ipt_data = NULL; 1214 } 1215 hnext = nextnode->ipe_next; 1216 break; 1217 1218 default : 1219 IPFERROR(30010); 1220 err = EINVAL; 1221 hnext = NULL; 1222 break; 1223 } 1224 1225 RWLOCK_EXIT(&softc->ipf_poolrw); 1226 if (err != 0) 1227 return(err); 1228 1229 switch (ilp->ili_otype) 1230 { 1231 case IPFLOOKUPITER_LIST : 1232 err = COPYOUT(nextiph, ilp->ili_data, sizeof(*nextiph)); 1233 if (err != 0) { 1234 IPFERROR(30011); 1235 err = EFAULT; 1236 } 1237 if (iph != NULL) { 1238 WRITE_ENTER(&softc->ipf_poolrw); 1239 ipf_htable_deref(softc, softh, iph); 1240 RWLOCK_EXIT(&softc->ipf_poolrw); 1241 } 1242 break; 1243 1244 case IPFLOOKUPITER_NODE : 1245 err = COPYOUT(nextnode, ilp->ili_data, sizeof(*nextnode)); 1246 if (err != 0) { 1247 IPFERROR(30012); 1248 err = EFAULT; 1249 } 1250 if (node != NULL) { 1251 WRITE_ENTER(&softc->ipf_poolrw); 1252 ipf_htent_deref(softc, node); 1253 RWLOCK_EXIT(&softc->ipf_poolrw); 1254 } 1255 break; 1256 } 1257 1258 if (hnext == NULL) 1259 ipf_token_mark_complete(token); 1260 1261 return(err); 1262 } 1263 1264 1265 /* ------------------------------------------------------------------------ */ 1266 /* Function: ipf_htable_iter_deref */ 1267 /* Returns: int - 0 = success, else error */ 1268 /* Parameters: softc(I) - pointer to soft context main structure */ 1269 /* arg(I) - pointer to local context to use */ 1270 /* otype(I) - which data structure type is being walked */ 1271 /* unit(I) - ipfilter device to which we are working on */ 1272 /* data(I) - pointer to old data structure */ 1273 /* */ 1274 /* ------------------------------------------------------------------------ */ 1275 static int 1276 ipf_htable_iter_deref(ipf_main_softc_t *softc, void *arg, int otype, int unit, 1277 void *data) 1278 { 1279 1280 if (data == NULL) 1281 return(EFAULT); 1282 1283 if (unit < -1 || unit > IPL_LOGMAX) 1284 return(EINVAL); 1285 1286 switch (otype) 1287 { 1288 case IPFLOOKUPITER_LIST : 1289 ipf_htable_deref(softc, arg, (iphtable_t *)data); 1290 break; 1291 1292 case IPFLOOKUPITER_NODE : 1293 ipf_htent_deref(arg, (iphtent_t *)data); 1294 break; 1295 default : 1296 break; 1297 } 1298 1299 return(0); 1300 } 1301 1302 1303 #ifdef USE_INET6 1304 /* ------------------------------------------------------------------------ */ 1305 /* Function: ipf_iphmfind6 */ 1306 /* Parameters: iph(I) - pointer to hash table */ 1307 /* addr(I) - pointer to IPv6 address */ 1308 /* Locks: ipf_poolrw */ 1309 /* */ 1310 /* ------------------------------------------------------------------------ */ 1311 static iphtent_t * 1312 ipf_iphmfind6(iphtable_t *iph, i6addr_t *addr) 1313 { 1314 i6addr_t *msk, ips; 1315 iphtent_t *ipe; 1316 u_int hv; 1317 int i; 1318 1319 i = 0; 1320 maskloop: 1321 msk = iph->iph_v6_masks.imt6_active + i; 1322 ips.i6[0] = addr->i6[0] & msk->i6[0]; 1323 ips.i6[1] = addr->i6[1] & msk->i6[1]; 1324 ips.i6[2] = addr->i6[2] & msk->i6[2]; 1325 ips.i6[3] = addr->i6[3] & msk->i6[3]; 1326 hv = IPE_V6_HASH_FN(ips.i6, msk->i6, iph->iph_size); 1327 for (ipe = iph->iph_table[hv]; (ipe != NULL); ipe = ipe->ipe_next) { 1328 if ((ipe->ipe_family != AF_INET6) || 1329 IP6_NEQ(&ipe->ipe_mask, msk) || 1330 IP6_NEQ(&ipe->ipe_addr, &ips)) { 1331 continue; 1332 } 1333 break; 1334 } 1335 1336 if (ipe == NULL) { 1337 i++; 1338 if (i < iph->iph_v6_masks.imt6_max) 1339 goto maskloop; 1340 } 1341 return(ipe); 1342 } 1343 #endif 1344 1345 1346 static void 1347 ipf_htable_expire(ipf_main_softc_t *softc, void *arg) 1348 { 1349 ipf_htable_softc_t *softh = arg; 1350 iphtent_t *n; 1351 1352 while ((n = softh->ipf_node_explist) != NULL) { 1353 if (n->ipe_die > softc->ipf_ticks) 1354 break; 1355 1356 ipf_htent_remove(softc, softh, n->ipe_owner, n); 1357 } 1358 } 1359 1360 1361 #ifndef _KERNEL 1362 1363 /* ------------------------------------------------------------------------ */ 1364 /* */ 1365 /* ------------------------------------------------------------------------ */ 1366 void 1367 ipf_htable_dump(ipf_main_softc_t *softc, void *arg) 1368 { 1369 ipf_htable_softc_t *softh = arg; 1370 iphtable_t *iph; 1371 int i; 1372 1373 printf("List of configured hash tables\n"); 1374 for (i = 0; i < IPL_LOGSIZE; i++) 1375 for (iph = softh->ipf_htables[i]; iph != NULL; 1376 iph = iph->iph_next) 1377 printhash(iph, bcopywrap, NULL, opts, NULL); 1378 1379 } 1380 #endif 1381