1 /*
2 * Copyright (C) 2003 by Darren Reed.
3 *
4 * See the IPFILTER.LICENCE file for details on licencing.
5 *
6 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
7 * Use is subject to license terms.
8 *
9 * Copyright (c) 2014, Joyent, Inc. All rights reserved.
10 * Copyright 2017 Gary Mills
11 */
12
13 #include <sys/types.h>
14 #include <sys/time.h>
15 #include <sys/param.h>
16 #include <sys/socket.h>
17 #if defined(BSD) && (BSD >= 199306)
18 # include <sys/cdefs.h>
19 #endif
20 #include <sys/ioctl.h>
21
22 #include <net/if.h>
23 #if __FreeBSD_version >= 300000
24 # include <net/if_var.h>
25 #endif
26 #include <netinet/in.h>
27
28 #include <arpa/inet.h>
29
30 #include <stdio.h>
31 #include <fcntl.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <netdb.h>
35 #include <ctype.h>
36 #include <unistd.h>
37 #include <nlist.h>
38
39 #include "ipf.h"
40 #include "netinet/ipl.h"
41 #include "netinet/ip_lookup.h"
42 #include "netinet/ip_pool.h"
43 #include "netinet/ip_htable.h"
44 #include "kmem.h"
45 #include "ipfzone.h"
46
47 extern int ippool_yyparse __P((void));
48 extern int ippool_yydebug;
49 extern FILE *ippool_yyin;
50 extern char *optarg;
51 extern int lineNum;
52
53 void showpools __P((ip_pool_stat_t *));
54 void usage __P((char *));
55 int main __P((int, char **));
56 int poolcommand __P((int, int, char *[]));
57 int poolnodecommand __P((int, int, char *[]));
58 int loadpoolfile __P((int, char *[], char *));
59 int poollist __P((int, char *[]));
60 int poolflush __P((int, char *[]));
61 int poolstats __P((int, char *[]));
62 int gettype __P((char *, u_int *));
63 int getrole __P((char *));
64 void poollist_dead __P((int, char *, int, char *, char *));
65 void showpools_live(int, int, ip_pool_stat_t *, char *, int);
66 void showhashs_live(int, int, iphtstat_t *, char *, int);
67
68 int opts = 0;
69 int fd = -1;
70 int use_inet6 = 0;
71
72
73 void usage(prog)
74 char *prog;
75 {
76 const char *zoneopt = "[-G|-z zonename] ";
77 fprintf(stderr, "Usage:\t%s\n", prog);
78 fprintf(stderr, "\t\t\t-a [-dnv] %s[-m <name>] [-o <role>] -i <ipaddr>[/netmask]\n",
79 zoneopt);
80 fprintf(stderr, "\t\t\t-A [-dnv] %s[-m <name>] [-o <role>] [-S <seed>] [-t <type>]\n",
81 zoneopt);
82 fprintf(stderr, "\t\t\t-f <file> %s[-dnuv]\n", zoneopt);
83 fprintf(stderr, "\t\t\t-F [-dv] %s[-o <role>] [-t <type>]\n", zoneopt);
84 fprintf(stderr, "\t\t\t-l [-dv] %s[-m <name>] [-t <type>]\n", zoneopt);
85 fprintf(stderr, "\t\t\t-r [-dnv] %s[-m <name>] [-o <role>] -i <ipaddr>[/netmask]\n",
86 zoneopt);
87 fprintf(stderr, "\t\t\t-R [-dnv] %s[-m <name>] [-o <role>] [-t <type>]\n",
88 zoneopt);
89 fprintf(stderr, "\t\t\t-s [-dtv] %s[-M <core>] [-N <namelist>]\n",
90 zoneopt);
91 exit(1);
92 }
93
94
95 int main(argc, argv)
96 int argc;
97 char *argv[];
98 {
99 int err;
100
101 if (argc < 2)
102 usage(argv[0]);
103
104 switch (getopt(argc, argv, "aAf:FlrRs"))
105 {
106 case 'a' :
107 err = poolnodecommand(0, argc, argv);
108 break;
109 case 'A' :
110 err = poolcommand(0, argc, argv);
111 break;
112 case 'f' :
113 err = loadpoolfile(argc, argv, optarg);
114 break;
115 case 'F' :
116 err = poolflush(argc, argv);
117 break;
118 case 'l' :
119 err = poollist(argc, argv);
120 break;
121 case 'r' :
122 err = poolnodecommand(1, argc, argv);
123 break;
124 case 'R' :
125 err = poolcommand(1, argc, argv);
126 break;
127 case 's' :
128 err = poolstats(argc, argv);
129 break;
130 default :
131 exit(1);
132 }
133
134 return err;
135 }
136
137
138 int poolnodecommand(remove, argc, argv)
139 int remove, argc;
140 char *argv[];
141 {
142 char *poolname = NULL, *s;
143 int err, c, ipset, role;
144 ip_pool_node_t node;
145 struct in_addr mask;
146
147 ipset = 0;
148 role = IPL_LOGIPF;
149 bzero((char *)&node, sizeof(node));
150
151 while ((c = getopt(argc, argv, "di:G:m:no:Rvz:")) != -1)
152 switch (c)
153 {
154 case 'd' :
155 opts |= OPT_DEBUG;
156 ippool_yydebug++;
157 break;
158 case 'G' :
159 setzonename_global(optarg);
160 break;
161 case 'i' :
162 s = strchr(optarg, '/');
163 if (s == NULL)
164 mask.s_addr = 0xffffffff;
165 else if (strchr(s, '.') == NULL) {
166 if (ntomask(4, atoi(s + 1), &mask.s_addr) != 0)
167 return -1;
168 } else {
169 mask.s_addr = inet_addr(s + 1);
170 }
171 if (s != NULL)
172 *s = '\0';
173 ipset = 1;
174 node.ipn_addr.adf_len = sizeof(node.ipn_addr);
175 node.ipn_addr.adf_addr.in4.s_addr = inet_addr(optarg);
176 node.ipn_mask.adf_len = sizeof(node.ipn_mask);
177 node.ipn_mask.adf_addr.in4.s_addr = mask.s_addr;
178 break;
179 case 'm' :
180 poolname = optarg;
181 break;
182 case 'n' :
183 opts |= OPT_DONOTHING;
184 break;
185 case 'o' :
186 role = getrole(optarg);
187 if (role == IPL_LOGNONE)
188 return -1;
189 break;
190 case 'R' :
191 opts |= OPT_NORESOLVE;
192 break;
193 case 'v' :
194 opts |= OPT_VERBOSE;
195 break;
196 case 'z' :
197 setzonename(optarg);
198 break;
199 }
200
201 if (opts & OPT_DEBUG)
202 fprintf(stderr, "poolnodecommand: opts = %#x\n", opts);
203
204 if (ipset == 0)
205 return -1;
206 if (poolname == NULL) {
207 fprintf(stderr, "poolname not given with add/remove node\n");
208 return -1;
209 }
210
211 if (remove == 0)
212 err = load_poolnode(0, poolname, &node, ioctl);
213 else
214 err = remove_poolnode(0, poolname, &node, ioctl);
215 return err;
216 }
217
218
219 int poolcommand(remove, argc, argv)
220 int remove, argc;
221 char *argv[];
222 {
223 int type, role, c, err;
224 char *poolname;
225 iphtable_t iph;
226 ip_pool_t pool;
227
228 err = 1;
229 role = 0;
230 type = 0;
231 poolname = NULL;
232 role = IPL_LOGIPF;
233 bzero((char *)&iph, sizeof(iph));
234 bzero((char *)&pool, sizeof(pool));
235
236 while ((c = getopt(argc, argv, "dG:m:no:RS:t:vz:")) != -1)
237 switch (c)
238 {
239 case 'd' :
240 opts |= OPT_DEBUG;
241 ippool_yydebug++;
242 break;
243 case 'G' :
244 setzonename_global(optarg);
245 break;
246 case 'm' :
247 poolname = optarg;
248 break;
249 case 'n' :
250 opts |= OPT_DONOTHING;
251 break;
252 case 'o' :
253 role = getrole(optarg);
254 if (role == IPL_LOGNONE) {
255 fprintf(stderr, "unknown role '%s'\n", optarg);
256 return -1;
257 }
258 break;
259 case 'R' :
260 opts |= OPT_NORESOLVE;
261 break;
262 case 'S' :
263 iph.iph_seed = atoi(optarg);
264 break;
265 case 't' :
266 type = gettype(optarg, &iph.iph_type);
267 if (type == IPLT_NONE) {
268 fprintf(stderr, "unknown type '%s'\n", optarg);
269 return -1;
270 }
271 break;
272 case 'v' :
273 opts |= OPT_VERBOSE;
274 break;
275 case 'z' :
276 setzonename(optarg);
277 break;
278 }
279
280 if (opts & OPT_DEBUG)
281 fprintf(stderr, "poolcommand: opts = %#x\n", opts);
282
283 if (poolname == NULL) {
284 fprintf(stderr, "poolname not given with add/remove pool\n");
285 return -1;
286 }
287
288 if (type == IPLT_HASH) {
289 strncpy(iph.iph_name, poolname, sizeof(iph.iph_name));
290 iph.iph_name[sizeof(iph.iph_name) - 1] = '\0';
291 iph.iph_unit = role;
292 } else if (type == IPLT_POOL) {
293 strncpy(pool.ipo_name, poolname, sizeof(pool.ipo_name));
294 pool.ipo_name[sizeof(pool.ipo_name) - 1] = '\0';
295 pool.ipo_unit = role;
296 }
297
298 if (remove == 0) {
299 switch (type)
300 {
301 case IPLT_HASH :
302 err = load_hash(&iph, NULL, ioctl);
303 break;
304 case IPLT_POOL :
305 err = load_pool(&pool, ioctl);
306 break;
307 }
308 } else {
309 switch (type)
310 {
311 case IPLT_HASH :
312 err = remove_hash(&iph, ioctl);
313 break;
314 case IPLT_POOL :
315 err = remove_pool(&pool, ioctl);
316 break;
317 }
318 }
319 return err;
320 }
321
322
323 int loadpoolfile(argc, argv, infile)
324 int argc;
325 char *argv[], *infile;
326 {
327 int c;
328
329 infile = optarg;
330
331 while ((c = getopt(argc, argv, "dG:nRuvz:")) != -1)
332 switch (c)
333 {
334 case 'd' :
335 opts |= OPT_DEBUG;
336 ippool_yydebug++;
337 break;
338 case 'G' :
339 setzonename_global(optarg);
340 break;
341 case 'n' :
342 opts |= OPT_DONOTHING;
343 break;
344 case 'R' :
345 opts |= OPT_NORESOLVE;
346 break;
347 case 'u' :
348 opts |= OPT_REMOVE;
349 break;
350 case 'v' :
351 opts |= OPT_VERBOSE;
352 break;
353 case 'z' :
354 setzonename(optarg);
355 break;
356 }
357
358 if (opts & OPT_DEBUG)
359 fprintf(stderr, "loadpoolfile: opts = %#x\n", opts);
360
361 if (!(opts & OPT_DONOTHING) && (fd == -1)) {
362 fd = open(IPLOOKUP_NAME, O_RDWR);
363 if (fd == -1) {
364 perror("open(IPLOOKUP_NAME)");
365 exit(1);
366 }
367
368 if (setzone(fd) != 0) {
369 close(fd);
370 exit(1);
371 }
372 }
373
374 if (ippool_parsefile(fd, infile, ioctl) != 0)
375 return -1;
376 return 0;
377 }
378
379
380 int poollist(argc, argv)
381 int argc;
382 char *argv[];
383 {
384 char *kernel, *core, *poolname;
385 int c, role, type, live_kernel;
386 ip_pool_stat_t plstat;
387 iphtstat_t htstat;
388 iphtable_t *hptr;
389 iplookupop_t op;
390 ip_pool_t *ptr;
391
392 core = NULL;
393 kernel = NULL;
394 live_kernel = 1;
395 type = IPLT_ALL;
396 poolname = NULL;
397 role = IPL_LOGALL;
398
399 while ((c = getopt(argc, argv, "dG:m:M:N:o:Rt:vz:")) != -1)
400 switch (c)
401 {
402 case 'd' :
403 opts |= OPT_DEBUG;
404 break;
405 case 'G' :
406 setzonename_global(optarg);
407 break;
408 case 'm' :
409 poolname = optarg;
410 break;
411 case 'M' :
412 live_kernel = 0;
413 core = optarg;
414 break;
415 case 'N' :
416 live_kernel = 0;
417 kernel = optarg;
418 break;
419 case 'o' :
420 role = getrole(optarg);
421 if (role == IPL_LOGNONE) {
422 fprintf(stderr, "unknown role '%s'\n", optarg);
423 return -1;
424 }
425 break;
426 case 'R' :
427 opts |= OPT_NORESOLVE;
428 break;
429 case 't' :
430 type = gettype(optarg, NULL);
431 if (type == IPLT_NONE) {
432 fprintf(stderr, "unknown type '%s'\n", optarg);
433 return -1;
434 }
435 break;
436 case 'v' :
437 opts |= OPT_VERBOSE;
438 break;
439 case 'z' :
440 setzonename(optarg);
441 break;
442 }
443
444 if (opts & OPT_DEBUG)
445 fprintf(stderr, "poollist: opts = %#x\n", opts);
446
447 if (!(opts & OPT_DONOTHING) && (fd == -1)) {
448 fd = open(IPLOOKUP_NAME, O_RDWR);
449 if (fd == -1) {
450 perror("open(IPLOOKUP_NAME)");
451 exit(1);
452 }
453
454 if (setzone(fd) != 0) {
455 close(fd);
456 exit(1);
457 }
458 }
459
460 bzero((char *)&op, sizeof(op));
461 if (poolname != NULL) {
462 strncpy(op.iplo_name, poolname, sizeof(op.iplo_name));
463 op.iplo_name[sizeof(op.iplo_name) - 1] = '\0';
464 }
465 op.iplo_unit = role;
466
467 if (live_kernel == 0) {
468 poollist_dead(role, poolname, type, kernel, core);
469 return (0);
470 }
471
472 if (type == IPLT_ALL || type == IPLT_POOL) {
473 op.iplo_type = IPLT_POOL;
474 op.iplo_size = sizeof(plstat);
475 op.iplo_struct = &plstat;
476 op.iplo_name[0] = '\0';
477 op.iplo_arg = 0;
478
479 if (role != IPL_LOGALL) {
480 op.iplo_unit = role;
481
482 c = ioctl(fd, SIOCLOOKUPSTAT, &op);
483 if (c == -1) {
484 perror("ioctl(SIOCLOOKUPSTAT)");
485 return -1;
486 }
487
488 showpools_live(fd, role, &plstat, poolname, opts);
489 } else {
490 for (role = 0; role <= IPL_LOGMAX; role++) {
491 op.iplo_unit = role;
492
493 c = ioctl(fd, SIOCLOOKUPSTAT, &op);
494 if (c == -1) {
495 perror("ioctl(SIOCLOOKUPSTAT)");
496 return -1;
497 }
498
499 showpools_live(fd, role, &plstat, poolname, opts);
500 }
501
502 role = IPL_LOGALL;
503 }
504 }
505 if (type == IPLT_ALL || type == IPLT_HASH) {
506 op.iplo_type = IPLT_HASH;
507 op.iplo_size = sizeof(htstat);
508 op.iplo_struct = &htstat;
509 op.iplo_name[0] = '\0';
510 op.iplo_arg = 0;
511
512 if (role != IPL_LOGALL) {
513 op.iplo_unit = role;
514
515 c = ioctl(fd, SIOCLOOKUPSTAT, &op);
516 if (c == -1) {
517 perror("ioctl(SIOCLOOKUPSTAT)");
518 return -1;
519 }
520 showhashs_live(fd, role, &htstat, poolname, opts);
521 } else {
522 for (role = 0; role <= IPL_LOGMAX; role++) {
523
524 op.iplo_unit = role;
525 c = ioctl(fd, SIOCLOOKUPSTAT, &op);
526 if (c == -1) {
527 perror("ioctl(SIOCLOOKUPSTAT)");
528 return -1;
529 }
530
531 showhashs_live(fd, role, &htstat, poolname, opts);
532 }
533 }
534 }
535 return 0;
536 }
537
538 void poollist_dead(role, poolname, type, kernel, core)
539 int role, type;
540 char *poolname, *kernel, *core;
541 {
542 iphtable_t *hptr;
543 ip_pool_t *ptr;
544
545 if (openkmem(kernel, core) == -1)
546 exit(-1);
547
548 if (type == IPLT_ALL || type == IPLT_POOL) {
549 ip_pool_t *pools[IPL_LOGSIZE];
550 struct nlist names[2] = { { "ip_pool_list" } , { "" } };
551
552 if (nlist(kernel, names) != 1)
553 return;
554
555 bzero(&pools, sizeof(pools));
556 if (kmemcpy((char *)&pools, names[0].n_value, sizeof(pools)))
557 return;
558
559 if (role != IPL_LOGALL) {
560 ptr = pools[role];
561 while (ptr != NULL) {
562 ptr = printpool(ptr, kmemcpywrap,
563 poolname, opts);
564 }
565 } else {
566 for (role = 0; role <= IPL_LOGMAX; role++) {
567 ptr = pools[role];
568 while (ptr != NULL) {
569 ptr = printpool(ptr, kmemcpywrap,
570 poolname, opts);
571 }
572 }
573 role = IPL_LOGALL;
574 }
575 }
576 if (type == IPLT_ALL || type == IPLT_HASH) {
577 iphtable_t *tables[IPL_LOGSIZE];
578 struct nlist names[2] = { { "ipf_htables" } , { "" } };
579
580 if (nlist(kernel, names) != 1)
581 return;
582
583 bzero(&tables, sizeof(tables));
584 if (kmemcpy((char *)&tables, names[0].n_value, sizeof(tables)))
585 return;
586
587 if (role != IPL_LOGALL) {
588 hptr = tables[role];
589 while (hptr != NULL) {
590 hptr = printhash(hptr, kmemcpywrap,
591 poolname, opts);
592 }
593 } else {
594 for (role = 0; role <= IPL_LOGMAX; role++) {
595 hptr = tables[role];
596 while (hptr != NULL) {
597 hptr = printhash(hptr, kmemcpywrap,
598 poolname, opts);
599 }
600 }
601 }
602 }
603 }
604
605
606 void
607 showpools_live(fd, role, plstp, poolname, opts)
608 int fd, role;
609 ip_pool_stat_t *plstp;
610 char *poolname;
611 int opts;
612 {
613 ipflookupiter_t iter;
614 ip_pool_t pool;
615 ipfobj_t obj;
616
617 obj.ipfo_rev = IPFILTER_VERSION;
618 obj.ipfo_type = IPFOBJ_LOOKUPITER;
619 obj.ipfo_size = sizeof(iter);
620 obj.ipfo_ptr = &iter;
621
622 iter.ili_type = IPLT_POOL;
623 iter.ili_otype = IPFLOOKUPITER_LIST;
624 iter.ili_ival = IPFGENITER_LOOKUP;
625 iter.ili_data = &pool;
626 iter.ili_unit = role;
627 *iter.ili_name = '\0';
628
629 while (plstp->ipls_list[role] != NULL) {
630 if (ioctl(fd, SIOCLOOKUPITER, &obj)) {
631 perror("ioctl(SIOCLOOKUPITER)");
632 break;
633 }
634 (void) printpool_live(&pool, fd, poolname, opts);
635
636 plstp->ipls_list[role] = pool.ipo_next;
637 }
638 }
639
640 int poolstats(argc, argv)
641 int argc;
642 char *argv[];
643 {
644 int c, type, role;
645 ip_pool_stat_t plstat;
646 iphtstat_t htstat;
647 iplookupop_t op;
648
649 type = IPLT_ALL;
650 role = IPL_LOGALL;
651
652 bzero((char *)&op, sizeof(op));
653
654 while ((c = getopt(argc, argv, "dG:M:N:o:t:vz:")) != -1)
655 switch (c)
656 {
657 case 'd' :
658 opts |= OPT_DEBUG;
659 break;
660 case 'G' :
661 setzonename_global(optarg);
662 break;
663 case 'M' :
664 break;
665 case 'N' :
666 break;
667 case 'o' :
668 role = getrole(optarg);
669 if (role == IPL_LOGNONE) {
670 fprintf(stderr, "unknown role '%s'\n", optarg);
671 return -1;
672 }
673 break;
674 case 't' :
675 type = gettype(optarg, NULL);
676 if (type != IPLT_POOL) {
677 fprintf(stderr,
678 "-s not supported for this type yet\n");
679 return -1;
680 }
681 break;
682 case 'v' :
683 opts |= OPT_VERBOSE;
684 break;
685 case 'z' :
686 setzonename(optarg);
687 break;
688 }
689
690 if (opts & OPT_DEBUG)
691 fprintf(stderr, "poolstats: opts = %#x\n", opts);
692
693 if (!(opts & OPT_DONOTHING) && (fd == -1)) {
694 fd = open(IPLOOKUP_NAME, O_RDWR);
695 if (fd == -1) {
696 perror("open(IPLOOKUP_NAME)");
697 exit(1);
698 }
699
700 if (setzone(fd) != 0) {
701 close(fd);
702 exit(1);
703 }
704 }
705
706 if (type == IPLT_ALL || type == IPLT_POOL) {
707 op.iplo_type = IPLT_POOL;
708 op.iplo_struct = &plstat;
709 op.iplo_size = sizeof(plstat);
710 if (!(opts & OPT_DONOTHING)) {
711 c = ioctl(fd, SIOCLOOKUPSTAT, &op);
712 if (c == -1) {
713 perror("ioctl(SIOCLOOKUPSTAT)");
714 return -1;
715 }
716 printf("Pools:\t%lu\n", plstat.ipls_pools);
717 printf("Nodes:\t%lu\n", plstat.ipls_nodes);
718 }
719 }
720
721 if (type == IPLT_ALL || type == IPLT_HASH) {
722 op.iplo_type = IPLT_HASH;
723 op.iplo_struct = &htstat;
724 op.iplo_size = sizeof(htstat);
725 if (!(opts & OPT_DONOTHING)) {
726 c = ioctl(fd, SIOCLOOKUPSTAT, &op);
727 if (c == -1) {
728 perror("ioctl(SIOCLOOKUPSTAT)");
729 return -1;
730 }
731 printf("Hash Tables:\t%lu\n", htstat.iphs_numtables);
732 printf("Nodes:\t%lu\n", htstat.iphs_numnodes);
733 printf("Out of Memory:\t%lu\n", htstat.iphs_nomem);
734 }
735 }
736 return 0;
737 }
738
739
740 int poolflush(argc, argv)
741 int argc;
742 char *argv[];
743 {
744 int c, role, type, arg;
745 iplookupflush_t flush;
746
747 arg = IPLT_ALL;
748 type = IPLT_ALL;
749 role = IPL_LOGALL;
750
751 while ((c = getopt(argc, argv, "do:t:vz:")) != -1)
752 switch (c)
753 {
754 case 'd' :
755 opts |= OPT_DEBUG;
756 break;
757 case 'o' :
758 role = getrole(optarg);
759 if (role == IPL_LOGNONE) {
760 fprintf(stderr, "unknown role '%s'\n", optarg);
761 return -1;
762 }
763 break;
764 case 't' :
765 type = gettype(optarg, NULL);
766 if (type == IPLT_NONE) {
767 fprintf(stderr, "unknown type '%s'\n", optarg);
768 return -1;
769 }
770 break;
771 case 'v' :
772 opts |= OPT_VERBOSE;
773 break;
774 case 'z' :
775 setzonename(optarg);
776 break;
777 }
778
779 if (opts & OPT_DEBUG)
780 fprintf(stderr, "poolflush: opts = %#x\n", opts);
781
782 if (!(opts & OPT_DONOTHING) && (fd == -1)) {
783 fd = open(IPLOOKUP_NAME, O_RDWR);
784 if (fd == -1) {
785 perror("open(IPLOOKUP_NAME)");
786 exit(1);
787 }
788
789 if (setzone(fd) != 0) {
790 close(fd);
791 exit(1);
792 }
793 }
794
795 bzero((char *)&flush, sizeof(flush));
796 flush.iplf_type = type;
797 flush.iplf_unit = role;
798 flush.iplf_arg = arg;
799
800 if (!(opts & OPT_DONOTHING)) {
801 if (ioctl(fd, SIOCLOOKUPFLUSH, &flush) == -1) {
802 perror("ioctl(SIOCLOOKUPFLUSH)");
803 exit(1);
804 }
805
806 }
807 printf("%u object%s flushed\n", flush.iplf_count,
808 (flush.iplf_count == 1) ? "" : "s");
809
810 return 0;
811 }
812
813
814 int getrole(rolename)
815 char *rolename;
816 {
817 int role;
818
819 if (!strcasecmp(rolename, "ipf")) {
820 role = IPL_LOGIPF;
821 #if 0
822 } else if (!strcasecmp(rolename, "nat")) {
823 role = IPL_LOGNAT;
824 } else if (!strcasecmp(rolename, "state")) {
825 role = IPL_LOGSTATE;
826 } else if (!strcasecmp(rolename, "auth")) {
827 role = IPL_LOGAUTH;
828 } else if (!strcasecmp(rolename, "sync")) {
829 role = IPL_LOGSYNC;
830 } else if (!strcasecmp(rolename, "scan")) {
831 role = IPL_LOGSCAN;
832 } else if (!strcasecmp(rolename, "pool")) {
833 role = IPL_LOGLOOKUP;
834 } else if (!strcasecmp(rolename, "count")) {
835 role = IPL_LOGCOUNT;
836 #endif
837 } else {
838 role = IPL_LOGNONE;
839 }
840
841 return role;
842 }
843
844
845 int gettype(typename, minor)
846 char *typename;
847 u_int *minor;
848 {
849 int type;
850
851 if (!strcasecmp(optarg, "tree")) {
852 type = IPLT_POOL;
853 } else if (!strcasecmp(optarg, "hash")) {
854 type = IPLT_HASH;
855 if (minor != NULL)
856 *minor = IPHASH_LOOKUP;
857 } else if (!strcasecmp(optarg, "group-map")) {
858 type = IPLT_HASH;
859 if (minor != NULL)
860 *minor = IPHASH_GROUPMAP;
861 } else {
862 type = IPLT_NONE;
863 }
864 return type;
865 }
866
867 void showhashs_live(fd, role, htstp, poolname, opts)
868 int fd, role;
869 iphtstat_t *htstp;
870 char *poolname;
871 int opts;
872 {
873 ipflookupiter_t iter;
874 iphtable_t table;
875 ipfobj_t obj;
876
877 obj.ipfo_rev = IPFILTER_VERSION;
878 obj.ipfo_type = IPFOBJ_LOOKUPITER;
879 obj.ipfo_size = sizeof(iter);
880 obj.ipfo_ptr = &iter;
881
882 iter.ili_type = IPLT_HASH;
883 iter.ili_otype = IPFLOOKUPITER_LIST;
884 iter.ili_ival = IPFGENITER_LOOKUP;
885 iter.ili_data = &table;
886 iter.ili_unit = role;
887 *iter.ili_name = '\0';
888
889 while (htstp->iphs_tables != NULL) {
890 if (ioctl(fd, SIOCLOOKUPITER, &obj)) {
891 perror("ioctl(SIOCLOOKUPITER)");
892 break;
893 }
894
895 printhash_live(&table, fd, poolname, opts);
896
897 htstp->iphs_tables = table.iph_next;
898 }
899 }