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