usr/src/cmd/ipf/tools/ippool.c

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