sbin/ipfw/tables.c

   1 /*
   2  * Copyright (c) 2014 Yandex LLC
   3  * Copyright (c) 2014 Alexander V. Chernikov
   4  *
   5  * Redistribution and use in source forms, with and without modification,
   6  * are permitted provided that this entire comment appears intact.
   7  *
   8  * Redistribution in binary form may occur without any restrictions.
   9  * Obviously, it would be nice if you gave credit where credit is due
  10  * but requiring it would be too onerous.
  11  *
  12  * This software is provided ``AS IS'' without any warranties of any kind.
  13  *
  14  * in-kernel ipfw tables support.
  15  *
  16  * $FreeBSD$
  17  */
  18
  19
  20 #include <sys/types.h>
  21 #include <sys/param.h>
  22 #include <sys/socket.h>
  23 #include <sys/sysctl.h>
  24
  25 #include <ctype.h>
  26 #include <err.h>
  27 #include <errno.h>
  28 #include <netdb.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <sysexits.h>
  33
  34 #include <net/if.h>
  35 #include <netinet/in.h>
  36 #include <netinet/ip_fw.h>
  37 #include <arpa/inet.h>
  38 #include <netdb.h>
  39
  40 #include "ipfw2.h"
  41
  42 static void table_modify_record(ipfw_obj_header *oh, int ac, char *av[],
  43     int add, int quiet, int update, int atomic);
  44 static int table_flush(ipfw_obj_header *oh);
  45 static int table_destroy(ipfw_obj_header *oh);
  46 static int table_do_create(ipfw_obj_header *oh, ipfw_xtable_info *i);
  47 static int table_do_modify(ipfw_obj_header *oh, ipfw_xtable_info *i);
  48 static int table_do_swap(ipfw_obj_header *oh, char *second);
  49 static void table_create(ipfw_obj_header *oh, int ac, char *av[]);
  50 static void table_modify(ipfw_obj_header *oh, int ac, char *av[]);
  51 static void table_lookup(ipfw_obj_header *oh, int ac, char *av[]);
  52 static void table_lock(ipfw_obj_header *oh, int lock);
  53 static int table_swap(ipfw_obj_header *oh, char *second);
  54 static int table_get_info(ipfw_obj_header *oh, ipfw_xtable_info *i);
  55 static int table_show_info(ipfw_xtable_info *i, void *arg);
  56
  57 static int table_destroy_one(ipfw_xtable_info *i, void *arg);
  58 static int table_flush_one(ipfw_xtable_info *i, void *arg);
  59 static int table_show_one(ipfw_xtable_info *i, void *arg);
  60 static int table_do_get_list(ipfw_xtable_info *i, ipfw_obj_header **poh);
  61 static void table_show_list(ipfw_obj_header *oh, int need_header);
  62 static void table_show_entry(ipfw_xtable_info *i, ipfw_obj_tentry *tent);
  63
  64 static void tentry_fill_key(ipfw_obj_header *oh, ipfw_obj_tentry *tent,
  65     char *key, int add, uint8_t *ptype, uint32_t *pvmask, ipfw_xtable_info *xi);
  66 static void tentry_fill_value(ipfw_obj_header *oh, ipfw_obj_tentry *tent,
  67     char *arg, uint8_t type, uint32_t vmask);
  68 static void table_show_value(char *buf, size_t bufsize, ipfw_table_value *v,
  69     uint32_t vmask, int print_ip);
  70
  71 typedef int (table_cb_t)(ipfw_xtable_info *i, void *arg);
  72 static int tables_foreach(table_cb_t *f, void *arg, int sort);
  73
  74 #ifndef s6_addr32
  75 #define s6_addr32 __u6_addr.__u6_addr32
  76 #endif
  77
  78 static struct _s_x tabletypes[] = {
  79       { "addr",         IPFW_TABLE_ADDR },
  80       { "iface",        IPFW_TABLE_INTERFACE },
  81       { "number",       IPFW_TABLE_NUMBER },
  82       { "flow",         IPFW_TABLE_FLOW },
  83       { NULL, 0 }
  84 };
  85
  86 static struct _s_x tablevaltypes[] = {
  87       { "skipto",       IPFW_VTYPE_SKIPTO },
  88       { "pipe",         IPFW_VTYPE_PIPE },
  89       { "fib",          IPFW_VTYPE_FIB },
  90       { "nat",          IPFW_VTYPE_NAT },
  91       { "dscp",         IPFW_VTYPE_DSCP },
  92       { "tag",          IPFW_VTYPE_TAG },
  93       { "divert",       IPFW_VTYPE_DIVERT },
  94       { "netgraph",     IPFW_VTYPE_NETGRAPH },
  95       { "limit",        IPFW_VTYPE_LIMIT },
  96       { "ipv4",         IPFW_VTYPE_NH4 },
  97       { "ipv6",         IPFW_VTYPE_NH6 },
  98       { NULL, 0 }
  99 };
 100
 101 static struct _s_x tablecmds[] = {
 102       { "add",          TOK_ADD },
 103       { "delete",       TOK_DEL },
 104       { "create",       TOK_CREATE },
 105       { "destroy",      TOK_DESTROY },
 106       { "flush",        TOK_FLUSH },
 107       { "modify",       TOK_MODIFY },
 108       { "swap",         TOK_SWAP },
 109       { "info",         TOK_INFO },
 110       { "detail",       TOK_DETAIL },
 111       { "list",         TOK_LIST },
 112       { "lookup",       TOK_LOOKUP },
 113       { "atomic",       TOK_ATOMIC },
 114       { "lock",         TOK_LOCK },
 115       { "unlock",       TOK_UNLOCK },
 116       { NULL, 0 }
 117 };
 118
 119 static int
 120 lookup_host (char *host, struct in_addr *ipaddr)
 121 {
 122         struct hostent *he;
 123
 124         if (!inet_aton(host, ipaddr)) {
 125                 if ((he = gethostbyname(host)) == NULL)
 126                         return(-1);
 127                 *ipaddr = *(struct in_addr *)he->h_addr_list[0];
 128         }
 129         return(0);
 130 }
 131
 132 /*
 133  * This one handles all table-related commands
 134  *      ipfw table NAME create ...
 135  *      ipfw table NAME modify ...
 136  *      ipfw table {NAME | all} destroy
 137  *      ipfw table NAME swap NAME
 138  *      ipfw table NAME lock
 139  *      ipfw table NAME unlock
 140  *      ipfw table NAME add addr[/masklen] [value]
 141  *      ipfw table NAME add [addr[/masklen] value] [addr[/masklen] value] ..
 142  *      ipfw table NAME delete addr[/masklen] [addr[/masklen]] ..
 143  *      ipfw table NAME lookup addr
 144  *      ipfw table {NAME | all} flush
 145  *      ipfw table {NAME | all} list
 146  *      ipfw table {NAME | all} info
 147  *      ipfw table {NAME | all} detail
 148  */
 149 void
 150 ipfw_table_handler(int ac, char *av[])
 151 {
 152         int do_add, is_all;
 153         int atomic, error, tcmd;
 154         ipfw_xtable_info i;
 155         ipfw_obj_header oh;
 156         char *tablename;
 157         uint8_t set;
 158         void *arg;
 159
 160         memset(&oh, 0, sizeof(oh));
 161         is_all = 0;
 162         if (co.use_set != 0)
 163                 set = co.use_set - 1;
 164         else
 165                 set = 0;
 166
 167         ac--; av++;
 168         NEED1("table needs name");
 169         tablename = *av;
 170
 171         if (table_check_name(tablename) == 0) {
 172                 table_fill_ntlv(&oh.ntlv, *av, set, 1);
 173                 oh.idx = 1;
 174         } else {
 175                 if (strcmp(tablename, "all") == 0)
 176                         is_all = 1;
 177                 else
 178                         errx(EX_USAGE, "table name %s is invalid", tablename);
 179         }
 180         ac--; av++;
 181         NEED1("table needs command");
 182
 183         tcmd = get_token(tablecmds, *av, "table command");
 184         /* Check if atomic operation was requested */
 185         atomic = 0;
 186         if (tcmd == TOK_ATOMIC) {
 187                 ac--; av++;
 188                 NEED1("atomic needs command");
 189                 tcmd = get_token(tablecmds, *av, "table command");
 190                 switch (tcmd) {
 191                 case TOK_ADD:
 192                         break;
 193                 default:
 194                         errx(EX_USAGE, "atomic is not compatible with %s", *av);
 195                 }
 196                 atomic = 1;
 197         }
 198
 199         switch (tcmd) {
 200         case TOK_LIST:
 201         case TOK_INFO:
 202         case TOK_DETAIL:
 203         case TOK_FLUSH:
 204         case TOK_DESTROY:
 205                 break;
 206         default:
 207                 if (is_all != 0)
 208                         errx(EX_USAGE, "table name required");
 209         }
 210
 211         switch (tcmd) {
 212         case TOK_ADD:
 213         case TOK_DEL:
 214                 do_add = **av == 'a';
 215                 ac--; av++;
 216                 table_modify_record(&oh, ac, av, do_add, co.do_quiet,
 217                     co.do_quiet, atomic);
 218                 break;
 219         case TOK_CREATE:
 220                 ac--; av++;
 221                 table_create(&oh, ac, av);
 222                 break;
 223         case TOK_MODIFY:
 224                 ac--; av++;
 225                 table_modify(&oh, ac, av);
 226                 break;
 227         case TOK_DESTROY:
 228                 if (is_all == 0) {
 229                         if (table_destroy(&oh) == 0)
 230                                 break;
 231                         if (errno != ESRCH)
 232                                 err(EX_OSERR, "failed to destroy table %s",
 233                                     tablename);
 234                         /* ESRCH isn't fatal, warn if not quiet mode */
 235                         if (co.do_quiet == 0)
 236                                 warn("failed to destroy table %s", tablename);
 237                 } else {
 238                         error = tables_foreach(table_destroy_one, &oh, 1);
 239                         if (error != 0)
 240                                 err(EX_OSERR,
 241                                     "failed to destroy tables list");
 242                 }
 243                 break;
 244         case TOK_FLUSH:
 245                 if (is_all == 0) {
 246                         if ((error = table_flush(&oh)) == 0)
 247                                 break;
 248                         if (errno != ESRCH)
 249                                 err(EX_OSERR, "failed to flush table %s info",
 250                                     tablename);
 251                         /* ESRCH isn't fatal, warn if not quiet mode */
 252                         if (co.do_quiet == 0)
 253                                 warn("failed to flush table %s info",
 254                                     tablename);
 255                 } else {
 256                         error = tables_foreach(table_flush_one, &oh, 1);
 257                         if (error != 0)
 258                                 err(EX_OSERR, "failed to flush tables list");
 259                         /* XXX: we ignore errors here */
 260                 }
 261                 break;
 262         case TOK_SWAP:
 263                 ac--; av++;
 264                 NEED1("second table name required");
 265                 table_swap(&oh, *av);
 266                 break;
 267         case TOK_LOCK:
 268         case TOK_UNLOCK:
 269                 table_lock(&oh, (tcmd == TOK_LOCK));
 270                 break;
 271         case TOK_DETAIL:
 272         case TOK_INFO:
 273                 arg = (tcmd == TOK_DETAIL) ? (void *)1 : NULL;
 274                 if (is_all == 0) {
 275                         if ((error = table_get_info(&oh, &i)) != 0)
 276                                 err(EX_OSERR, "failed to request table info");
 277                         table_show_info(&i, arg);
 278                 } else {
 279                         error = tables_foreach(table_show_info, arg, 1);
 280                         if (error != 0)
 281                                 err(EX_OSERR, "failed to request tables list");
 282                 }
 283                 break;
 284         case TOK_LIST:
 285                 if (is_all == 0) {
 286                         ipfw_xtable_info i;
 287                         if ((error = table_get_info(&oh, &i)) != 0)
 288                                 err(EX_OSERR, "failed to request table info");
 289                         table_show_one(&i, NULL);
 290                 } else {
 291                         error = tables_foreach(table_show_one, NULL, 1);
 292                         if (error != 0)
 293                                 err(EX_OSERR, "failed to request tables list");
 294                 }
 295                 break;
 296         case TOK_LOOKUP:
 297                 ac--; av++;
 298                 table_lookup(&oh, ac, av);
 299                 break;
 300         }
 301 }
 302
 303 void
 304 table_fill_ntlv(ipfw_obj_ntlv *ntlv, const char *name, uint8_t set,
 305     uint16_t uidx)
 306 {
 307
 308         ntlv->head.type = IPFW_TLV_TBL_NAME;
 309         ntlv->head.length = sizeof(ipfw_obj_ntlv);
 310         ntlv->idx = uidx;
 311         ntlv->set = set;
 312         strlcpy(ntlv->name, name, sizeof(ntlv->name));
 313 }
 314
 315 static void
 316 table_fill_objheader(ipfw_obj_header *oh, ipfw_xtable_info *i)
 317 {
 318
 319         oh->idx = 1;
 320         table_fill_ntlv(&oh->ntlv, i->tablename, i->set, 1);
 321 }
 322
 323 static struct _s_x tablenewcmds[] = {
 324       { "type",         TOK_TYPE },
 325       { "valtype",      TOK_VALTYPE },
 326       { "algo",         TOK_ALGO },
 327       { "limit",        TOK_LIMIT },
 328       { "locked",       TOK_LOCK },
 329       { NULL, 0 }
 330 };
 331
 332 static struct _s_x flowtypecmds[] = {
 333       { "src-ip",       IPFW_TFFLAG_SRCIP },
 334       { "proto",        IPFW_TFFLAG_PROTO },
 335       { "src-port",     IPFW_TFFLAG_SRCPORT },
 336       { "dst-ip",       IPFW_TFFLAG_DSTIP },
 337       { "dst-port",     IPFW_TFFLAG_DSTPORT },
 338       { NULL, 0 }
 339 };
 340
 341 int
 342 table_parse_type(uint8_t ttype, char *p, uint8_t *tflags)
 343 {
 344         uint32_t fset, fclear;
 345         char *e;
 346
 347         /* Parse type options */
 348         switch(ttype) {
 349         case IPFW_TABLE_FLOW:
 350                 fset = fclear = 0;
 351                 if (fill_flags(flowtypecmds, p, &e, &fset, &fclear) != 0)
 352                         errx(EX_USAGE,
 353                             "unable to parse flow option %s", e);
 354                 *tflags = fset;
 355                 break;
 356         default:
 357                 return (EX_USAGE);
 358         }
 359
 360         return (0);
 361 }
 362
 363 void
 364 table_print_type(char *tbuf, size_t size, uint8_t type, uint8_t tflags)
 365 {
 366         const char *tname;
 367         int l;
 368
 369         if ((tname = match_value(tabletypes, type)) == NULL)
 370                 tname = "unknown";
 371
 372         l = snprintf(tbuf, size, "%s", tname);
 373         tbuf += l;
 374         size -= l;
 375
 376         switch(type) {
 377         case IPFW_TABLE_FLOW:
 378                 if (tflags != 0) {
 379                         *tbuf++ = ':';
 380                         l--;
 381                         print_flags_buffer(tbuf, size, flowtypecmds, tflags);
 382                 }
 383                 break;
 384         }
 385 }
 386
 387 /*
 388  * Creates new table
 389  *
 390  * ipfw table NAME create [ type { addr | iface | number | flow } ]
 391  *     [ algo algoname ]
 392  */
 393 static void
 394 table_create(ipfw_obj_header *oh, int ac, char *av[])
 395 {
 396         ipfw_xtable_info xi;
 397         int error, tcmd, val;
 398         uint32_t fset, fclear;
 399         char *e, *p;
 400         char tbuf[128];
 401
 402         memset(&xi, 0, sizeof(xi));
 403
 404         while (ac > 0) {
 405                 tcmd = get_token(tablenewcmds, *av, "option");
 406                 ac--; av++;
 407
 408                 switch (tcmd) {
 409                 case TOK_LIMIT:
 410                         NEED1("limit value required");
 411                         xi.limit = strtol(*av, NULL, 10);
 412                         ac--; av++;
 413                         break;
 414                 case TOK_TYPE:
 415                         NEED1("table type required");
 416                         /* Type may have suboptions after ':' */
 417                         if ((p = strchr(*av, ':')) != NULL)
 418                                 *p++ = '\0';
 419                         val = match_token(tabletypes, *av);
 420                         if (val == -1) {
 421                                 concat_tokens(tbuf, sizeof(tbuf), tabletypes,
 422                                     ", ");
 423                                 errx(EX_USAGE,
 424                                     "Unknown tabletype: %s. Supported: %s",
 425                                     *av, tbuf);
 426                         }
 427                         xi.type = val;
 428                         if (p != NULL) {
 429                                 error = table_parse_type(val, p, &xi.tflags);
 430                                 if (error != 0)
 431                                         errx(EX_USAGE,
 432                                             "Unsupported suboptions: %s", p);
 433                         }
 434                         ac--; av++;
 435                         break;
 436                 case TOK_VALTYPE:
 437                         NEED1("table value type required");
 438                         fset = fclear = 0;
 439                         val = fill_flags(tablevaltypes, *av, &e, &fset, &fclear);
 440                         if (val != -1) {
 441                                 xi.vmask = fset;
 442                                 ac--; av++;
 443                                 break;
 444                         }
 445                         concat_tokens(tbuf, sizeof(tbuf), tablevaltypes, ", ");
 446                         errx(EX_USAGE, "Unknown value type: %s. Supported: %s",
 447                             e, tbuf);
 448                         break;
 449                 case TOK_ALGO:
 450                         NEED1("table algorithm name required");
 451                         if (strlen(*av) > sizeof(xi.algoname))
 452                                 errx(EX_USAGE, "algorithm name too long");
 453                         strlcpy(xi.algoname, *av, sizeof(xi.algoname));
 454                         ac--; av++;
 455                         break;
 456                 case TOK_LOCK:
 457                         xi.flags |= IPFW_TGFLAGS_LOCKED;
 458                         break;
 459                 }
 460         }
 461
 462         /* Set some defaults to preserve compatibility. */
 463         if (xi.algoname[0] == '\0' && xi.type == 0)
 464                 xi.type = IPFW_TABLE_ADDR;
 465         if (xi.vmask == 0)
 466                 xi.vmask = IPFW_VTYPE_LEGACY;
 467
 468         if ((error = table_do_create(oh, &xi)) != 0)
 469                 err(EX_OSERR, "Table creation failed");
 470 }
 471
 472 /*
 473  * Creates new table
 474  *
 475  * Request: [ ipfw_obj_header ipfw_xtable_info ]
 476  *
 477  * Returns 0 on success.
 478  */
 479 static int
 480 table_do_create(ipfw_obj_header *oh, ipfw_xtable_info *i)
 481 {
 482         char tbuf[sizeof(ipfw_obj_header) + sizeof(ipfw_xtable_info)];
 483         int error;
 484
 485         memcpy(tbuf, oh, sizeof(*oh));
 486         memcpy(tbuf + sizeof(*oh), i, sizeof(*i));
 487         oh = (ipfw_obj_header *)tbuf;
 488
 489         error = do_set3(IP_FW_TABLE_XCREATE, &oh->opheader, sizeof(tbuf));
 490
 491         return (error);
 492 }
 493
 494 /*
 495  * Modifies existing table
 496  *
 497  * ipfw table NAME modify [ limit number ]
 498  */
 499 static void
 500 table_modify(ipfw_obj_header *oh, int ac, char *av[])
 501 {
 502         ipfw_xtable_info xi;
 503         int tcmd;
 504
 505         memset(&xi, 0, sizeof(xi));
 506
 507         while (ac > 0) {
 508                 tcmd = get_token(tablenewcmds, *av, "option");
 509                 ac--; av++;
 510
 511                 switch (tcmd) {
 512                 case TOK_LIMIT:
 513                         NEED1("limit value required");
 514                         xi.limit = strtol(*av, NULL, 10);
 515                         xi.mflags |= IPFW_TMFLAGS_LIMIT;
 516                         ac--; av++;
 517                         break;
 518                 default:
 519                         errx(EX_USAGE, "cmd is not supported for modification");
 520                 }
 521         }
 522
 523         if (table_do_modify(oh, &xi) != 0)
 524                 err(EX_OSERR, "Table modification failed");
 525 }
 526
 527 /*
 528  * Modifies existing table.
 529  *
 530  * Request: [ ipfw_obj_header ipfw_xtable_info ]
 531  *
 532  * Returns 0 on success.
 533  */
 534 static int
 535 table_do_modify(ipfw_obj_header *oh, ipfw_xtable_info *i)
 536 {
 537         char tbuf[sizeof(ipfw_obj_header) + sizeof(ipfw_xtable_info)];
 538         int error;
 539
 540         memcpy(tbuf, oh, sizeof(*oh));
 541         memcpy(tbuf + sizeof(*oh), i, sizeof(*i));
 542         oh = (ipfw_obj_header *)tbuf;
 543
 544         error = do_set3(IP_FW_TABLE_XMODIFY, &oh->opheader, sizeof(tbuf));
 545
 546         return (error);
 547 }
 548
 549 /*
 550  * Locks or unlocks given table
 551  */
 552 static void
 553 table_lock(ipfw_obj_header *oh, int lock)
 554 {
 555         ipfw_xtable_info xi;
 556
 557         memset(&xi, 0, sizeof(xi));
 558
 559         xi.mflags |= IPFW_TMFLAGS_LOCK;
 560         xi.flags |= (lock != 0) ? IPFW_TGFLAGS_LOCKED : 0;
 561
 562         if (table_do_modify(oh, &xi) != 0)
 563                 err(EX_OSERR, "Table %s failed", lock != 0 ? "lock" : "unlock");
 564 }
 565
 566 /*
 567  * Destroys given table specified by @oh->ntlv.
 568  * Returns 0 on success.
 569  */
 570 static int
 571 table_destroy(ipfw_obj_header *oh)
 572 {
 573
 574         if (do_set3(IP_FW_TABLE_XDESTROY, &oh->opheader, sizeof(*oh)) != 0)
 575                 return (-1);
 576
 577         return (0);
 578 }
 579
 580 static int
 581 table_destroy_one(ipfw_xtable_info *i, void *arg)
 582 {
 583         ipfw_obj_header *oh;
 584
 585         oh = (ipfw_obj_header *)arg;
 586         table_fill_ntlv(&oh->ntlv, i->tablename, i->set, 1);
 587         if (table_destroy(oh) != 0) {
 588                 if (co.do_quiet == 0)
 589                         warn("failed to destroy table(%s) in set %u",
 590                             i->tablename, i->set);
 591                 return (-1);
 592         }
 593         return (0);
 594 }
 595
 596 /*
 597  * Flushes given table specified by @oh->ntlv.
 598  * Returns 0 on success.
 599  */
 600 static int
 601 table_flush(ipfw_obj_header *oh)
 602 {
 603
 604         if (do_set3(IP_FW_TABLE_XFLUSH, &oh->opheader, sizeof(*oh)) != 0)
 605                 return (-1);
 606
 607         return (0);
 608 }
 609
 610 static int
 611 table_do_swap(ipfw_obj_header *oh, char *second)
 612 {
 613         char tbuf[sizeof(ipfw_obj_header) + sizeof(ipfw_obj_ntlv)];
 614         int error;
 615
 616         memset(tbuf, 0, sizeof(tbuf));
 617         memcpy(tbuf, oh, sizeof(*oh));
 618         oh = (ipfw_obj_header *)tbuf;
 619         table_fill_ntlv((ipfw_obj_ntlv *)(oh + 1), second, oh->ntlv.set, 1);
 620
 621         error = do_set3(IP_FW_TABLE_XSWAP, &oh->opheader, sizeof(tbuf));
 622
 623         return (error);
 624 }
 625
 626 /*
 627  * Swaps given table with @second one.
 628  */
 629 static int
 630 table_swap(ipfw_obj_header *oh, char *second)
 631 {
 632
 633         if (table_check_name(second) != 0)
 634                 errx(EX_USAGE, "table name %s is invalid", second);
 635
 636         if (table_do_swap(oh, second) == 0)
 637                 return (0);
 638
 639         switch (errno) {
 640         case EINVAL:
 641                 errx(EX_USAGE, "Unable to swap table: check types");
 642         case EFBIG:
 643                 errx(EX_USAGE, "Unable to swap table: check limits");
 644         }
 645
 646         return (0);
 647 }
 648
 649
 650 /*
 651  * Retrieves table in given table specified by @oh->ntlv.
 652  * it inside @i.
 653  * Returns 0 on success.
 654  */
 655 static int
 656 table_get_info(ipfw_obj_header *oh, ipfw_xtable_info *i)
 657 {
 658         char tbuf[sizeof(ipfw_obj_header) + sizeof(ipfw_xtable_info)];
 659         size_t sz;
 660
 661         sz = sizeof(tbuf);
 662         memset(tbuf, 0, sizeof(tbuf));
 663         memcpy(tbuf, oh, sizeof(*oh));
 664         oh = (ipfw_obj_header *)tbuf;
 665
 666         if (do_get3(IP_FW_TABLE_XINFO, &oh->opheader, &sz) != 0)
 667                 return (errno);
 668
 669         if (sz < sizeof(tbuf))
 670                 return (EINVAL);
 671
 672         *i = *(ipfw_xtable_info *)(oh + 1);
 673
 674         return (0);
 675 }
 676
 677 static struct _s_x tablealgoclass[] = {
 678       { "hash",         IPFW_TACLASS_HASH },
 679       { "array",        IPFW_TACLASS_ARRAY },
 680       { "radix",        IPFW_TACLASS_RADIX },
 681       { NULL, 0 }
 682 };
 683
 684 struct ta_cldata {
 685         uint8_t         taclass;
 686         uint8_t         spare4;
 687         uint16_t        itemsize;
 688         uint16_t        itemsize6;
 689         uint32_t        size;
 690         uint32_t        count;
 691 };
 692
 693 /*
 694  * Print global/per-AF table @i algorithm info.
 695  */
 696 static void
 697 table_show_tainfo(ipfw_xtable_info *i, struct ta_cldata *d,
 698     const char *af, const char *taclass)
 699 {
 700
 701         switch (d->taclass) {
 702         case IPFW_TACLASS_HASH:
 703         case IPFW_TACLASS_ARRAY:
 704                 printf(" %salgorithm %s info\n", af, taclass);
 705                 if (d->itemsize == d->itemsize6)
 706                         printf("  size: %u items: %u itemsize: %u\n",
 707                             d->size, d->count, d->itemsize);
 708                 else
 709                         printf("  size: %u items: %u "
 710                             "itemsize4: %u itemsize6: %u\n",
 711                             d->size, d->count,
 712                             d->itemsize, d->itemsize6);
 713                 break;
 714         case IPFW_TACLASS_RADIX:
 715                 printf(" %salgorithm %s info\n", af, taclass);
 716                 if (d->itemsize == d->itemsize6)
 717                         printf("  items: %u itemsize: %u\n",
 718                             d->count, d->itemsize);
 719                 else
 720                         printf("  items: %u "
 721                             "itemsize4: %u itemsize6: %u\n",
 722                             d->count, d->itemsize, d->itemsize6);
 723                 break;
 724         default:
 725                 printf(" algo class: %s\n", taclass);
 726         }
 727 }
 728
 729 static void
 730 table_print_valheader(char *buf, size_t bufsize, uint32_t vmask)
 731 {
 732
 733         if (vmask == IPFW_VTYPE_LEGACY) {
 734                 snprintf(buf, bufsize, "legacy");
 735                 return;
 736         }
 737
 738         memset(buf, 0, bufsize);
 739         print_flags_buffer(buf, bufsize, tablevaltypes, vmask);
 740 }
 741
 742 /*
 743  * Prints table info struct @i in human-readable form.
 744  */
 745 static int
 746 table_show_info(ipfw_xtable_info *i, void *arg)
 747 {
 748         const char *vtype;
 749         ipfw_ta_tinfo *tainfo;
 750         int afdata, afitem;
 751         struct ta_cldata d;
 752         char ttype[64], tvtype[64];
 753
 754         table_print_type(ttype, sizeof(ttype), i->type, i->tflags);
 755         table_print_valheader(tvtype, sizeof(tvtype), i->vmask);
 756
 757         printf("--- table(%s), set(%u) ---\n", i->tablename, i->set);
 758         if ((i->flags & IPFW_TGFLAGS_LOCKED) != 0)
 759                 printf(" kindex: %d, type: %s, locked\n", i->kidx, ttype);
 760         else
 761                 printf(" kindex: %d, type: %s\n", i->kidx, ttype);
 762         printf(" references: %u, valtype: %s\n", i->refcnt, tvtype);
 763         printf(" algorithm: %s\n", i->algoname);
 764         printf(" items: %u, size: %u\n", i->count, i->size);
 765         if (i->limit > 0)
 766                 printf(" limit: %u\n", i->limit);
 767
 768         /* Print algo-specific info if requested & set  */
 769         if (arg == NULL)
 770                 return (0);
 771
 772         if ((i->ta_info.flags & IPFW_TATFLAGS_DATA) == 0)
 773                 return (0);
 774         tainfo = &i->ta_info;
 775
 776         afdata = 0;
 777         afitem = 0;
 778         if (tainfo->flags & IPFW_TATFLAGS_AFDATA)
 779                 afdata = 1;
 780         if (tainfo->flags & IPFW_TATFLAGS_AFITEM)
 781                 afitem = 1;
 782
 783         memset(&d, 0, sizeof(d));
 784         d.taclass = tainfo->taclass4;
 785         d.size = tainfo->size4;
 786         d.count = tainfo->count4;
 787         d.itemsize = tainfo->itemsize4;
 788         if (afdata == 0 && afitem != 0)
 789                 d.itemsize6 = tainfo->itemsize6;
 790         else
 791                 d.itemsize6 = d.itemsize;
 792         if ((vtype = match_value(tablealgoclass, d.taclass)) == NULL)
 793                 vtype = "unknown";
 794
 795         if (afdata == 0) {
 796                 table_show_tainfo(i, &d, "", vtype);
 797         } else {
 798                 table_show_tainfo(i, &d, "IPv4 ", vtype);
 799                 memset(&d, 0, sizeof(d));
 800                 d.taclass = tainfo->taclass6;
 801                 if ((vtype = match_value(tablealgoclass, d.taclass)) == NULL)
 802                         vtype = "unknown";
 803                 d.size = tainfo->size6;
 804                 d.count = tainfo->count6;
 805                 d.itemsize = tainfo->itemsize6;
 806                 d.itemsize6 = d.itemsize;
 807                 table_show_tainfo(i, &d, "IPv6 ", vtype);
 808         }
 809
 810         return (0);
 811 }
 812
 813
 814 /*
 815  * Function wrappers which can be used either
 816  * as is or as foreach function parameter.
 817  */
 818
 819 static int
 820 table_show_one(ipfw_xtable_info *i, void *arg)
 821 {
 822         ipfw_obj_header *oh;
 823         int error;
 824
 825         if ((error = table_do_get_list(i, &oh)) != 0) {
 826                 err(EX_OSERR, "Error requesting table %s list", i->tablename);
 827                 return (error);
 828         }
 829
 830         table_show_list(oh, 1);
 831
 832         free(oh);
 833         return (0);
 834 }
 835
 836 static int
 837 table_flush_one(ipfw_xtable_info *i, void *arg)
 838 {
 839         ipfw_obj_header *oh;
 840
 841         oh = (ipfw_obj_header *)arg;
 842
 843         table_fill_ntlv(&oh->ntlv, i->tablename, i->set, 1);
 844
 845         return (table_flush(oh));
 846 }
 847
 848 static int
 849 table_do_modify_record(int cmd, ipfw_obj_header *oh,
 850     ipfw_obj_tentry *tent, int count, int atomic)
 851 {
 852         ipfw_obj_ctlv *ctlv;
 853         ipfw_obj_tentry *tent_base;
 854         caddr_t pbuf;
 855         char xbuf[sizeof(*oh) + sizeof(ipfw_obj_ctlv) + sizeof(*tent)];
 856         int error, i;
 857         size_t sz;
 858
 859         sz = sizeof(*ctlv) + sizeof(*tent) * count;
 860         if (count == 1) {
 861                 memset(xbuf, 0, sizeof(xbuf));
 862                 pbuf = xbuf;
 863         } else {
 864                 if ((pbuf = calloc(1, sizeof(*oh) + sz)) == NULL)
 865                         return (ENOMEM);
 866         }
 867
 868         memcpy(pbuf, oh, sizeof(*oh));
 869         oh = (ipfw_obj_header *)pbuf;
 870         oh->opheader.version = 1;
 871
 872         ctlv = (ipfw_obj_ctlv *)(oh + 1);
 873         ctlv->count = count;
 874         ctlv->head.length = sz;
 875         if (atomic != 0)
 876                 ctlv->flags |= IPFW_CTF_ATOMIC;
 877
 878         tent_base = tent;
 879         memcpy(ctlv + 1, tent, sizeof(*tent) * count);
 880         tent = (ipfw_obj_tentry *)(ctlv + 1);
 881         for (i = 0; i < count; i++, tent++) {
 882                 tent->head.length = sizeof(ipfw_obj_tentry);
 883                 tent->idx = oh->idx;
 884         }
 885
 886         sz += sizeof(*oh);
 887         error = do_get3(cmd, &oh->opheader, &sz);
 888         if (error != 0)
 889                 error = errno;
 890         tent = (ipfw_obj_tentry *)(ctlv + 1);
 891         /* Copy result back to provided buffer */
 892         memcpy(tent_base, ctlv + 1, sizeof(*tent) * count);
 893
 894         if (pbuf != xbuf)
 895                 free(pbuf);
 896
 897         return (error);
 898 }
 899
 900 static void
 901 table_modify_record(ipfw_obj_header *oh, int ac, char *av[], int add,
 902     int quiet, int update, int atomic)
 903 {
 904         ipfw_obj_tentry *ptent, tent, *tent_buf;
 905         ipfw_xtable_info xi;
 906         uint8_t type;
 907         uint32_t vmask;
 908         int cmd, count, error, i, ignored;
 909         char *texterr, *etxt, *px;
 910
 911         if (ac == 0)
 912                 errx(EX_USAGE, "address required");
 913
 914         if (add != 0) {
 915                 cmd = IP_FW_TABLE_XADD;
 916                 texterr = "Adding record failed";
 917         } else {
 918                 cmd = IP_FW_TABLE_XDEL;
 919                 texterr = "Deleting record failed";
 920         }
 921
 922         /*
 923          * Calculate number of entries:
 924          * Assume [key val] x N for add
 925          * and
 926          * key x N for delete
 927          */
 928         count = (add != 0) ? ac / 2 + 1 : ac;
 929
 930         if (count <= 1) {
 931                 /* Adding single entry with/without value */
 932                 memset(&tent, 0, sizeof(tent));
 933                 tent_buf = &tent;
 934         } else {
 935
 936                 if ((tent_buf = calloc(count, sizeof(tent))) == NULL)
 937                         errx(EX_OSERR,
 938                             "Unable to allocate memory for all entries");
 939         }
 940         ptent = tent_buf;
 941
 942         memset(&xi, 0, sizeof(xi));
 943         count = 0;
 944         while (ac > 0) {
 945                 tentry_fill_key(oh, ptent, *av, add, &type, &vmask, &xi);
 946
 947                 /*
 948                  * Compatibility layer: auto-create table if not exists.
 949                  */
 950                 if (xi.tablename[0] == '\0') {
 951                         xi.type = type;
 952                         xi.vmask = vmask;
 953                         strlcpy(xi.tablename, oh->ntlv.name,
 954                             sizeof(xi.tablename));
 955                         if (quiet == 0)
 956                                 warnx("DEPRECATED: inserting data into "
 957                                     "non-existent table %s. (auto-created)",
 958                                     xi.tablename);
 959                         table_do_create(oh, &xi);
 960                 }
 961
 962                 oh->ntlv.type = type;
 963                 ac--; av++;
 964
 965                 if (add != 0 && ac > 0) {
 966                         tentry_fill_value(oh, ptent, *av, type, vmask);
 967                         ac--; av++;
 968                 }
 969
 970                 if (update != 0)
 971                         ptent->head.flags |= IPFW_TF_UPDATE;
 972
 973                 count++;
 974                 ptent++;
 975         }
 976
 977         error = table_do_modify_record(cmd, oh, tent_buf, count, atomic);
 978
 979         /*
 980          * Compatibility stuff: do not yell on duplicate keys or
 981          * failed deletions.
 982          */
 983         if (error == 0 || (error == EEXIST && add != 0) ||
 984             (error == ENOENT && add == 0)) {
 985                 if (quiet != 0) {
 986                         if (tent_buf != &tent)
 987                                 free(tent_buf);
 988                         return;
 989                 }
 990         }
 991
 992         /* Report results back */
 993         ptent = tent_buf;
 994         for (i = 0; i < count; ptent++, i++) {
 995                 ignored = 0;
 996                 switch (ptent->result) {
 997                 case IPFW_TR_ADDED:
 998                         px = "added";
 999                         break;
1000                 case IPFW_TR_DELETED:
1001                         px = "deleted";
1002                         break;
1003                 case IPFW_TR_UPDATED:
1004                         px = "updated";
1005                         break;
1006                 case IPFW_TR_LIMIT:
1007                         px = "limit";
1008                         ignored = 1;
1009                         break;
1010                 case IPFW_TR_ERROR:
1011                         px = "error";
1012                         ignored = 1;
1013                         break;
1014                 case IPFW_TR_NOTFOUND:
1015                         px = "notfound";
1016                         ignored = 1;
1017                         break;
1018                 case IPFW_TR_EXISTS:
1019                         px = "exists";
1020                         ignored = 1;
1021                         break;
1022                 case IPFW_TR_IGNORED:
1023                         px = "ignored";
1024                         ignored = 1;
1025                         break;
1026                 default:
1027                         px = "unknown";
1028                         ignored = 1;
1029                 }
1030
1031                 if (error != 0 && atomic != 0 && ignored == 0)
1032                         printf("%s(reverted): ", px);
1033                 else
1034                         printf("%s: ", px);
1035
1036                 table_show_entry(&xi, ptent);
1037         }
1038
1039         if (tent_buf != &tent)
1040                 free(tent_buf);
1041
1042         if (error == 0)
1043                 return;
1044         /* Get real OS error */
1045         error = errno;
1046
1047         /* Try to provide more human-readable error */
1048         switch (error) {
1049         case EEXIST:
1050                 etxt = "record already exists";
1051                 break;
1052         case EFBIG:
1053                 etxt = "limit hit";
1054                 break;
1055         case ESRCH:
1056                 etxt = "table not found";
1057                 break;
1058         case ENOENT:
1059                 etxt = "record not found";
1060                 break;
1061         case EACCES:
1062                 etxt = "table is locked";
1063                 break;
1064         default:
1065                 etxt = strerror(error);
1066         }
1067
1068         errx(EX_OSERR, "%s: %s", texterr, etxt);
1069 }
1070
1071 static int
1072 table_do_lookup(ipfw_obj_header *oh, char *key, ipfw_xtable_info *xi,
1073     ipfw_obj_tentry *xtent)
1074 {
1075         char xbuf[sizeof(ipfw_obj_header) + sizeof(ipfw_obj_tentry)];
1076         ipfw_obj_tentry *tent;
1077         uint8_t type;
1078         uint32_t vmask;
1079         size_t sz;
1080
1081         memcpy(xbuf, oh, sizeof(*oh));
1082         oh = (ipfw_obj_header *)xbuf;
1083         tent = (ipfw_obj_tentry *)(oh + 1);
1084
1085         memset(tent, 0, sizeof(*tent));
1086         tent->head.length = sizeof(*tent);
1087         tent->idx = 1;
1088
1089         tentry_fill_key(oh, tent, key, 0, &type, &vmask, xi);
1090         oh->ntlv.type = type;
1091
1092         sz = sizeof(xbuf);
1093         if (do_get3(IP_FW_TABLE_XFIND, &oh->opheader, &sz) != 0)
1094                 return (errno);
1095
1096         if (sz < sizeof(xbuf))
1097                 return (EINVAL);
1098
1099         *xtent = *tent;
1100
1101         return (0);
1102 }
1103
1104 static void
1105 table_lookup(ipfw_obj_header *oh, int ac, char *av[])
1106 {
1107         ipfw_obj_tentry xtent;
1108         ipfw_xtable_info xi;
1109         char key[64];
1110         int error;
1111
1112         if (ac == 0)
1113                 errx(EX_USAGE, "address required");
1114
1115         strlcpy(key, *av, sizeof(key));
1116
1117         memset(&xi, 0, sizeof(xi));
1118         error = table_do_lookup(oh, key, &xi, &xtent);
1119
1120         switch (error) {
1121         case 0:
1122                 break;
1123         case ESRCH:
1124                 errx(EX_UNAVAILABLE, "Table %s not found", oh->ntlv.name);
1125         case ENOENT:
1126                 errx(EX_UNAVAILABLE, "Entry %s not found", *av);
1127         case ENOTSUP:
1128                 errx(EX_UNAVAILABLE, "Table %s algo does not support "
1129                     "\"lookup\" method", oh->ntlv.name);
1130         default:
1131                 err(EX_OSERR, "getsockopt(IP_FW_TABLE_XFIND)");
1132         }
1133
1134         table_show_entry(&xi, &xtent);
1135 }
1136
1137 static void
1138 tentry_fill_key_type(char *arg, ipfw_obj_tentry *tentry, uint8_t type,
1139     uint8_t tflags)
1140 {
1141         char *p, *pp;
1142         int mask, af;
1143         struct in6_addr *paddr, tmp;
1144         struct tflow_entry *tfe;
1145         uint32_t key, *pkey;
1146         uint16_t port;
1147         struct protoent *pent;
1148         struct servent *sent;
1149         int masklen;
1150
1151         masklen = 0;
1152         af = 0;
1153         paddr = (struct in6_addr *)&tentry->k;
1154
1155         switch (type) {
1156         case IPFW_TABLE_ADDR:
1157                 /* Remove / if exists */
1158                 if ((p = strchr(arg, '/')) != NULL) {
1159                         *p = '\0';
1160                         mask = atoi(p + 1);
1161                 }
1162
1163                 if (inet_pton(AF_INET, arg, paddr) == 1) {
1164                         if (p != NULL && mask > 32)
1165                                 errx(EX_DATAERR, "bad IPv4 mask width: %s",
1166                                     p + 1);
1167
1168                         masklen = p ? mask : 32;
1169                         af = AF_INET;
1170                 } else if (inet_pton(AF_INET6, arg, paddr) == 1) {
1171                         if (IN6_IS_ADDR_V4COMPAT(paddr))
1172                                 errx(EX_DATAERR,
1173                                     "Use IPv4 instead of v4-compatible");
1174                         if (p != NULL && mask > 128)
1175                                 errx(EX_DATAERR, "bad IPv6 mask width: %s",
1176                                     p + 1);
1177
1178                         masklen = p ? mask : 128;
1179                         af = AF_INET6;
1180                 } else {
1181                         /* Assume FQDN */
1182                         if (lookup_host(arg, (struct in_addr *)paddr) != 0)
1183                                 errx(EX_NOHOST, "hostname ``%s'' unknown", arg);
1184
1185                         masklen = 32;
1186                         type = IPFW_TABLE_ADDR;
1187                         af = AF_INET;
1188                 }
1189                 break;
1190         case IPFW_TABLE_INTERFACE:
1191                 /* Assume interface name. Copy significant data only */
1192                 mask = MIN(strlen(arg), IF_NAMESIZE - 1);
1193                 memcpy(paddr, arg, mask);
1194                 /* Set mask to exact match */
1195                 masklen = 8 * IF_NAMESIZE;
1196                 break;
1197         case IPFW_TABLE_NUMBER:
1198                 /* Port or any other key */
1199                 key = strtol(arg, &p, 10);
1200                 if (*p != '\0')
1201                         errx(EX_DATAERR, "Invalid number: %s", arg);
1202
1203                 pkey = (uint32_t *)paddr;
1204                 *pkey = key;
1205                 masklen = 32;
1206                 break;
1207         case IPFW_TABLE_FLOW:
1208                 /* Assume [src-ip][,proto][,src-port][,dst-ip][,dst-port] */
1209                 tfe = &tentry->k.flow;
1210                 af = 0;
1211
1212                 /* Handle <ipv4|ipv6> */
1213                 if ((tflags & IPFW_TFFLAG_SRCIP) != 0) {
1214                         if ((p = strchr(arg, ',')) != NULL)
1215                                 *p++ = '\0';
1216                         /* Determine family using temporary storage */
1217                         if (inet_pton(AF_INET, arg, &tmp) == 1) {
1218                                 if (af != 0 && af != AF_INET)
1219                                         errx(EX_DATAERR,
1220                                             "Inconsistent address family\n");
1221                                 af = AF_INET;
1222                                 memcpy(&tfe->a.a4.sip, &tmp, 4);
1223                         } else if (inet_pton(AF_INET6, arg, &tmp) == 1) {
1224                                 if (af != 0 && af != AF_INET6)
1225                                         errx(EX_DATAERR,
1226                                             "Inconsistent address family\n");
1227                                 af = AF_INET6;
1228                                 memcpy(&tfe->a.a6.sip6, &tmp, 16);
1229                         }
1230
1231                         arg = p;
1232                 }
1233
1234                 /* Handle <proto-num|proto-name> */
1235                 if ((tflags & IPFW_TFFLAG_PROTO) != 0) {
1236                         if (arg == NULL)
1237                                 errx(EX_DATAERR, "invalid key: proto missing");
1238                         if ((p = strchr(arg, ',')) != NULL)
1239                                 *p++ = '\0';
1240
1241                         key = strtol(arg, &pp, 10);
1242                         if (*pp != '\0') {
1243                                 if ((pent = getprotobyname(arg)) == NULL)
1244                                         errx(EX_DATAERR, "Unknown proto: %s",
1245                                             arg);
1246                                 else
1247                                         key = pent->p_proto;
1248                         }
1249
1250                         if (key > 255)
1251                                 errx(EX_DATAERR, "Bad protocol number: %u",key);
1252
1253                         tfe->proto = key;
1254
1255                         arg = p;
1256                 }
1257
1258                 /* Handle <port-num|service-name> */
1259                 if ((tflags & IPFW_TFFLAG_SRCPORT) != 0) {
1260                         if (arg == NULL)
1261                                 errx(EX_DATAERR, "invalid key: src port missing");
1262                         if ((p = strchr(arg, ',')) != NULL)
1263                                 *p++ = '\0';
1264
1265                         port = htons(strtol(arg, &pp, 10));
1266                         if (*pp != '\0') {
1267                                 if ((sent = getservbyname(arg, NULL)) == NULL)
1268                                         errx(EX_DATAERR, "Unknown service: %s",
1269                                             arg);
1270                                 port = sent->s_port;
1271                         }
1272                         tfe->sport = port;
1273                         arg = p;
1274                 }
1275
1276                 /* Handle <ipv4|ipv6>*/
1277                 if ((tflags & IPFW_TFFLAG_DSTIP) != 0) {
1278                         if (arg == NULL)
1279                                 errx(EX_DATAERR, "invalid key: dst ip missing");
1280                         if ((p = strchr(arg, ',')) != NULL)
1281                                 *p++ = '\0';
1282                         /* Determine family using temporary storage */
1283                         if (inet_pton(AF_INET, arg, &tmp) == 1) {
1284                                 if (af != 0 && af != AF_INET)
1285                                         errx(EX_DATAERR,
1286                                             "Inconsistent address family");
1287                                 af = AF_INET;
1288                                 memcpy(&tfe->a.a4.dip, &tmp, 4);
1289                         } else if (inet_pton(AF_INET6, arg, &tmp) == 1) {
1290                                 if (af != 0 && af != AF_INET6)
1291                                         errx(EX_DATAERR,
1292                                             "Inconsistent address family");
1293                                 af = AF_INET6;
1294                                 memcpy(&tfe->a.a6.dip6, &tmp, 16);
1295                         }
1296
1297                         arg = p;
1298                 }
1299
1300                 /* Handle <port-num|service-name> */
1301                 if ((tflags & IPFW_TFFLAG_DSTPORT) != 0) {
1302                         if (arg == NULL)
1303                                 errx(EX_DATAERR, "invalid key: dst port missing");
1304                         if ((p = strchr(arg, ',')) != NULL)
1305                                 *p++ = '\0';
1306
1307                         port = htons(strtol(arg, &pp, 10));
1308                         if (*pp != '\0') {
1309                                 if ((sent = getservbyname(arg, NULL)) == NULL)
1310                                         errx(EX_DATAERR, "Unknown service: %s",
1311                                             arg);
1312                                 port = sent->s_port;
1313                         }
1314                         tfe->dport = port;
1315                         arg = p;
1316                 }
1317
1318                 tfe->af = af;
1319
1320                 break;
1321
1322         default:
1323                 errx(EX_DATAERR, "Unsupported table type: %d", type);
1324         }
1325
1326         tentry->subtype = af;
1327         tentry->masklen = masklen;
1328 }
1329
1330 /*
1331  * Tries to guess table key type.
1332  * This procedure is used in legacy table auto-create
1333  * code AND in `ipfw -n` ruleset checking.
1334  *
1335  * Imported from old table_fill_xentry() parse code.
1336  */
1337 static int
1338 guess_key_type(char *key, uint8_t *ptype)
1339 {
1340         char *p;
1341         struct in6_addr addr;
1342         uint32_t kv;
1343
1344         if (ishexnumber(*key) != 0 || *key == ':') {
1345                 /* Remove / if exists */
1346                 if ((p = strchr(key, '/')) != NULL)
1347                         *p = '\0';
1348
1349                 if ((inet_pton(AF_INET, key, &addr) == 1) ||
1350                     (inet_pton(AF_INET6, key, &addr) == 1)) {
1351                         *ptype = IPFW_TABLE_CIDR;
1352                         if (p != NULL)
1353                                 *p = '/';
1354                         return (0);
1355                 } else {
1356                         /* Port or any other key */
1357                         /* Skip non-base 10 entries like 'fa1' */
1358                         kv = strtol(key, &p, 10);
1359                         if (*p == '\0') {
1360                                 *ptype = IPFW_TABLE_NUMBER;
1361                                 return (0);
1362                         } else if ((p != key) && (*p == '.')) {
1363                                 /*
1364                                  * Warn on IPv4 address strings
1365                                  * which are "valid" for inet_aton() but not
1366                                  * in inet_pton().
1367                                  *
1368                                  * Typical examples: '10.5' or '10.0.0.05'
1369                                  */
1370                                 return (1);
1371                         }
1372                 }
1373         }
1374
1375         if (strchr(key, '.') == NULL) {
1376                 *ptype = IPFW_TABLE_INTERFACE;
1377                 return (0);
1378         }
1379
1380         if (lookup_host(key, (struct in_addr *)&addr) != 0)
1381                 return (1);
1382
1383         *ptype = IPFW_TABLE_CIDR;
1384         return (0);
1385 }
1386
1387 static void
1388 tentry_fill_key(ipfw_obj_header *oh, ipfw_obj_tentry *tent, char *key,
1389     int add, uint8_t *ptype, uint32_t *pvmask, ipfw_xtable_info *xi)
1390 {
1391         uint8_t type, tflags;
1392         uint32_t vmask;
1393         int error;
1394
1395         type = 0;
1396         tflags = 0;
1397         vmask = 0;
1398
1399         if (xi->tablename[0] == '\0')
1400                 error = table_get_info(oh, xi);
1401         else
1402                 error = 0;
1403
1404         if (error == 0) {
1405                 if (co.test_only == 0) {
1406                         /* Table found */
1407                         type = xi->type;
1408                         tflags = xi->tflags;
1409                         vmask = xi->vmask;
1410                 } else {
1411                         /*
1412                          * We're running `ipfw -n`
1413                          * Compatibility layer: try to guess key type
1414                          * before failing.
1415                          */
1416                         if (guess_key_type(key, &type) != 0) {
1417                                 /* Inknown key */
1418                                 errx(EX_USAGE, "Cannot guess "
1419                                     "key '%s' type", key);
1420                         }
1421                         vmask = IPFW_VTYPE_LEGACY;
1422                 }
1423         } else {
1424                 if (error != ESRCH)
1425                         errx(EX_OSERR, "Error requesting table %s info",
1426                             oh->ntlv.name);
1427                 if (add == 0)
1428                         errx(EX_DATAERR, "Table %s does not exist",
1429                             oh->ntlv.name);
1430                 /*
1431                  * Table does not exist
1432                  * Compatibility layer: try to guess key type before failing.
1433                  */
1434                 if (guess_key_type(key, &type) != 0) {
1435                         /* Inknown key */
1436                         errx(EX_USAGE, "Table %s does not exist, cannot guess "
1437                             "key '%s' type", oh->ntlv.name, key);
1438                 }
1439
1440                 vmask = IPFW_VTYPE_LEGACY;
1441         }
1442
1443         tentry_fill_key_type(key, tent, type, tflags);
1444
1445         *ptype = type;
1446         *pvmask = vmask;
1447 }
1448
1449 static void
1450 set_legacy_value(uint32_t val, ipfw_table_value *v)
1451 {
1452         v->tag = val;
1453         v->pipe = val;
1454         v->divert = val;
1455         v->skipto = val;
1456         v->netgraph = val;
1457         v->fib = val;
1458         v->nat = val;
1459         v->nh4 = val;
1460         v->dscp = (uint8_t)val;
1461         v->limit = val;
1462 }
1463
1464 static void
1465 tentry_fill_value(ipfw_obj_header *oh, ipfw_obj_tentry *tent, char *arg,
1466     uint8_t type, uint32_t vmask)
1467 {
1468         struct addrinfo hints, *res;
1469         uint32_t a4, flag, val;
1470         ipfw_table_value *v;
1471         uint32_t i;
1472         int dval;
1473         char *comma, *e, *etype, *n, *p;
1474         struct in_addr ipaddr;
1475
1476         v = &tent->v.value;
1477
1478         /* Compat layer: keep old behavior for legacy value types */
1479         if (vmask == IPFW_VTYPE_LEGACY) {
1480                 /* Try to interpret as number first */
1481                 val = strtoul(arg, &p, 0);
1482                 if (*p == '\0') {
1483                         set_legacy_value(val, v);
1484                         return;
1485                 }
1486                 if (inet_pton(AF_INET, arg, &val) == 1) {
1487                         set_legacy_value(ntohl(val), v);
1488                         return;
1489                 }
1490                 /* Try hostname */
1491                 if (lookup_host(arg, &ipaddr) == 0) {
1492                         set_legacy_value(ntohl(ipaddr.s_addr), v);
1493                         return;
1494                 }
1495                 errx(EX_OSERR, "Unable to parse value %s", arg);
1496         }
1497
1498         /*
1499          * Shorthands: handle single value if vmask consists
1500          * of numbers only. e.g.:
1501          * vmask = "fib,skipto" -> treat input "1" as "1,1"
1502          */
1503
1504         n = arg;
1505         etype = NULL;
1506         for (i = 1; i < (1 << 31); i *= 2) {
1507                 if ((flag = (vmask & i)) == 0)
1508                         continue;
1509                 vmask &= ~flag;
1510
1511                 if ((comma = strchr(n, ',')) != NULL)
1512                         *comma = '\0';
1513
1514                 switch (flag) {
1515                 case IPFW_VTYPE_TAG:
1516                         v->tag = strtol(n, &e, 10);
1517                         if (*e != '\0')
1518                                 etype = "tag";
1519                         break;
1520                 case IPFW_VTYPE_PIPE:
1521                         v->pipe = strtol(n, &e, 10);
1522                         if (*e != '\0')
1523                                 etype = "pipe";
1524                         break;
1525                 case IPFW_VTYPE_DIVERT:
1526                         v->divert = strtol(n, &e, 10);
1527                         if (*e != '\0')
1528                                 etype = "divert";
1529                         break;
1530                 case IPFW_VTYPE_SKIPTO:
1531                         v->skipto = strtol(n, &e, 10);
1532                         if (*e != '\0')
1533                                 etype = "skipto";
1534                         break;
1535                 case IPFW_VTYPE_NETGRAPH:
1536                         v->netgraph = strtol(n, &e, 10);
1537                         if (*e != '\0')
1538                                 etype = "netgraph";
1539                         break;
1540                 case IPFW_VTYPE_FIB:
1541                         v->fib = strtol(n, &e, 10);
1542                         if (*e != '\0')
1543                                 etype = "fib";
1544                         break;
1545                 case IPFW_VTYPE_NAT:
1546                         v->nat = strtol(n, &e, 10);
1547                         if (*e != '\0')
1548                                 etype = "nat";
1549                         break;
1550                 case IPFW_VTYPE_LIMIT:
1551                         v->limit = strtol(n, &e, 10);
1552                         if (*e != '\0')
1553                                 etype = "limit";
1554                         break;
1555                 case IPFW_VTYPE_NH4:
1556                         if (strchr(n, '.') != NULL &&
1557                             inet_pton(AF_INET, n, &a4) == 1) {
1558                                 v->nh4 = ntohl(a4);
1559                                 break;
1560                         }
1561                         if (lookup_host(n, &ipaddr) == 0) {
1562                                 v->nh4 = ntohl(ipaddr.s_addr);
1563                                 break;
1564                         }
1565                         etype = "ipv4";
1566                         break;
1567                 case IPFW_VTYPE_DSCP:
1568                         if (isalpha(*n)) {
1569                                 if ((dval = match_token(f_ipdscp, n)) != -1) {
1570                                         v->dscp = dval;
1571                                         break;
1572                                 } else
1573                                         etype = "DSCP code";
1574                         } else {
1575                                 v->dscp = strtol(n, &e, 10);
1576                                 if (v->dscp > 63 || *e != '\0')
1577                                         etype = "DSCP value";
1578                         }
1579                         break;
1580                 case IPFW_VTYPE_NH6:
1581                         if (strchr(n, ':') != NULL) {
1582                                 memset(&hints, 0, sizeof(hints));
1583                                 hints.ai_family = AF_INET6;
1584                                 hints.ai_flags = AI_NUMERICHOST;
1585                                 if (getaddrinfo(n, NULL, &hints, &res) == 0) {
1586                                         v->nh6 = ((struct sockaddr_in6 *)
1587                                             res->ai_addr)->sin6_addr;
1588                                         v->zoneid = ((struct sockaddr_in6 *)
1589                                             res->ai_addr)->sin6_scope_id;
1590                                         freeaddrinfo(res);
1591                                         break;
1592                                 }
1593                         }
1594                         etype = "ipv6";
1595                         break;
1596                 }
1597
1598                 if (etype != NULL)
1599                         errx(EX_USAGE, "Unable to parse %s as %s", n, etype);
1600
1601                 if (comma != NULL)
1602                         *comma++ = ',';
1603
1604                 if ((n = comma) != NULL)
1605                         continue;
1606
1607                 /* End of input. */
1608                 if (vmask != 0)
1609                         errx(EX_USAGE, "Not enough fields inside value");
1610         }
1611 }
1612
1613 /*
1614  * Compare table names.
1615  * Honor number comparison.
1616  */
1617 static int
1618 tablename_cmp(const void *a, const void *b)
1619 {
1620         ipfw_xtable_info *ia, *ib;
1621
1622         ia = (ipfw_xtable_info *)a;
1623         ib = (ipfw_xtable_info *)b;
1624
1625         return (stringnum_cmp(ia->tablename, ib->tablename));
1626 }
1627
1628 /*
1629  * Retrieves table list from kernel,
1630  * optionally sorts it and calls requested function for each table.
1631  * Returns 0 on success.
1632  */
1633 static int
1634 tables_foreach(table_cb_t *f, void *arg, int sort)
1635 {
1636         ipfw_obj_lheader *olh;
1637         ipfw_xtable_info *info;
1638         size_t sz;
1639         int i, error;
1640
1641         /* Start with reasonable default */
1642         sz = sizeof(*olh) + 16 * sizeof(ipfw_xtable_info);
1643
1644         for (;;) {
1645                 if ((olh = calloc(1, sz)) == NULL)
1646                         return (ENOMEM);
1647
1648                 olh->size = sz;
1649                 if (do_get3(IP_FW_TABLES_XLIST, &olh->opheader, &sz) != 0) {
1650                         sz = olh->size;
1651                         free(olh);
1652                         if (errno != ENOMEM)
1653                                 return (errno);
1654                         continue;
1655                 }
1656
1657                 if (sort != 0)
1658                         qsort(olh + 1, olh->count, olh->objsize,
1659                             tablename_cmp);
1660
1661                 info = (ipfw_xtable_info *)(olh + 1);
1662                 for (i = 0; i < olh->count; i++) {
1663                         if (co.use_set == 0 || info->set == co.use_set - 1)
1664                                 error = f(info, arg);
1665                         info = (ipfw_xtable_info *)((caddr_t)info +
1666                             olh->objsize);
1667                 }
1668                 free(olh);
1669                 break;
1670         }
1671         return (0);
1672 }
1673
1674
1675 /*
1676  * Retrieves all entries for given table @i in
1677  * eXtended format. Allocate buffer large enough
1678  * to store result. Called needs to free it later.
1679  *
1680  * Returns 0 on success.
1681  */
1682 static int
1683 table_do_get_list(ipfw_xtable_info *i, ipfw_obj_header **poh)
1684 {
1685         ipfw_obj_header *oh;
1686         size_t sz;
1687         int c;
1688
1689         sz = 0;
1690         oh = NULL;
1691         for (c = 0; c < 8; c++) {
1692                 if (sz < i->size)
1693                         sz = i->size + 44;
1694                 if (oh != NULL)
1695                         free(oh);
1696                 if ((oh = calloc(1, sz)) == NULL)
1697                         continue;
1698                 table_fill_objheader(oh, i);
1699                 oh->opheader.version = 1; /* Current version */
1700                 if (do_get3(IP_FW_TABLE_XLIST, &oh->opheader, &sz) == 0) {
1701                         *poh = oh;
1702                         return (0);
1703                 }
1704
1705                 if (errno != ENOMEM)
1706                         break;
1707         }
1708         free(oh);
1709
1710         return (errno);
1711 }
1712
1713 /*
1714  * Shows all entries from @oh in human-readable format
1715  */
1716 static void
1717 table_show_list(ipfw_obj_header *oh, int need_header)
1718 {
1719         ipfw_obj_tentry *tent;
1720         uint32_t count;
1721         ipfw_xtable_info *i;
1722
1723         i = (ipfw_xtable_info *)(oh + 1);
1724         tent = (ipfw_obj_tentry *)(i + 1);
1725
1726         if (need_header)
1727                 printf("--- table(%s), set(%u) ---\n", i->tablename, i->set);
1728
1729         count = i->count;
1730         while (count > 0) {
1731                 table_show_entry(i, tent);
1732                 tent = (ipfw_obj_tentry *)((caddr_t)tent + tent->head.length);
1733                 count--;
1734         }
1735 }
1736
1737 static void
1738 table_show_value(char *buf, size_t bufsize, ipfw_table_value *v,
1739     uint32_t vmask, int print_ip)
1740 {
1741         char abuf[INET6_ADDRSTRLEN + IF_NAMESIZE + 2];
1742         struct sockaddr_in6 sa6;
1743         uint32_t flag, i, l;
1744         size_t sz;
1745         struct in_addr a4;
1746
1747         sz = bufsize;
1748
1749         /*
1750          * Some shorthands for printing values:
1751          * legacy assumes all values are equal, so keep the first one.
1752          */
1753         if (vmask == IPFW_VTYPE_LEGACY) {
1754                 if (print_ip != 0) {
1755                         flag = htonl(v->tag);
1756                         inet_ntop(AF_INET, &flag, buf, sz);
1757                 } else
1758                         snprintf(buf, sz, "%u", v->tag);
1759                 return;
1760         }
1761
1762         for (i = 1; i < (1 << 31); i *= 2) {
1763                 if ((flag = (vmask & i)) == 0)
1764                         continue;
1765                 l = 0;
1766
1767                 switch (flag) {
1768                 case IPFW_VTYPE_TAG:
1769                         l = snprintf(buf, sz, "%u,", v->tag);
1770                         break;
1771                 case IPFW_VTYPE_PIPE:
1772                         l = snprintf(buf, sz, "%u,", v->pipe);
1773                         break;
1774                 case IPFW_VTYPE_DIVERT:
1775                         l = snprintf(buf, sz, "%d,", v->divert);
1776                         break;
1777                 case IPFW_VTYPE_SKIPTO:
1778                         l = snprintf(buf, sz, "%d,", v->skipto);
1779                         break;
1780                 case IPFW_VTYPE_NETGRAPH:
1781                         l = snprintf(buf, sz, "%u,", v->netgraph);
1782                         break;
1783                 case IPFW_VTYPE_FIB:
1784                         l = snprintf(buf, sz, "%u,", v->fib);
1785                         break;
1786                 case IPFW_VTYPE_NAT:
1787                         l = snprintf(buf, sz, "%u,", v->nat);
1788                         break;
1789                 case IPFW_VTYPE_LIMIT:
1790                         l = snprintf(buf, sz, "%u,", v->limit);
1791                         break;
1792                 case IPFW_VTYPE_NH4:
1793                         a4.s_addr = htonl(v->nh4);
1794                         inet_ntop(AF_INET, &a4, abuf, sizeof(abuf));
1795                         l = snprintf(buf, sz, "%s,", abuf);
1796                         break;
1797                 case IPFW_VTYPE_DSCP:
1798                         l = snprintf(buf, sz, "%d,", v->dscp);
1799                         break;
1800                 case IPFW_VTYPE_NH6:
1801                         sa6.sin6_family = AF_INET6;
1802                         sa6.sin6_len = sizeof(sa6);
1803                         sa6.sin6_addr = v->nh6;
1804                         sa6.sin6_port = 0;
1805                         sa6.sin6_scope_id = v->zoneid;
1806                         if (getnameinfo((const struct sockaddr *)&sa6,
1807                             sa6.sin6_len, abuf, sizeof(abuf), NULL, 0,
1808                             NI_NUMERICHOST) == 0)
1809                                 l = snprintf(buf, sz, "%s,", abuf);
1810                         break;
1811                 }
1812
1813                 buf += l;
1814                 sz -= l;
1815         }
1816
1817         if (sz != bufsize)
1818                 *(buf - 1) = '\0';
1819 }
1820
1821 static void
1822 table_show_entry(ipfw_xtable_info *i, ipfw_obj_tentry *tent)
1823 {
1824         char *comma, tbuf[128], pval[128];
1825         void *paddr;
1826         struct tflow_entry *tfe;
1827
1828         table_show_value(pval, sizeof(pval), &tent->v.value, i->vmask,
1829             co.do_value_as_ip);
1830
1831         switch (i->type) {
1832         case IPFW_TABLE_ADDR:
1833                 /* IPv4 or IPv6 prefixes */
1834                 inet_ntop(tent->subtype, &tent->k, tbuf, sizeof(tbuf));
1835                 printf("%s/%u %s\n", tbuf, tent->masklen, pval);
1836                 break;
1837         case IPFW_TABLE_INTERFACE:
1838                 /* Interface names */
1839                 printf("%s %s\n", tent->k.iface, pval);
1840                 break;
1841         case IPFW_TABLE_NUMBER:
1842                 /* numbers */
1843                 printf("%u %s\n", tent->k.key, pval);
1844                 break;
1845         case IPFW_TABLE_FLOW:
1846                 /* flows */
1847                 tfe = &tent->k.flow;
1848                 comma = "";
1849
1850                 if ((i->tflags & IPFW_TFFLAG_SRCIP) != 0) {
1851                         if (tfe->af == AF_INET)
1852                                 paddr = &tfe->a.a4.sip;
1853                         else
1854                                 paddr = &tfe->a.a6.sip6;
1855
1856                         inet_ntop(tfe->af, paddr, tbuf, sizeof(tbuf));
1857                         printf("%s%s", comma, tbuf);
1858                         comma = ",";
1859                 }
1860
1861                 if ((i->tflags & IPFW_TFFLAG_PROTO) != 0) {
1862                         printf("%s%d", comma, tfe->proto);
1863                         comma = ",";
1864                 }
1865
1866                 if ((i->tflags & IPFW_TFFLAG_SRCPORT) != 0) {
1867                         printf("%s%d", comma, ntohs(tfe->sport));
1868                         comma = ",";
1869                 }
1870                 if ((i->tflags & IPFW_TFFLAG_DSTIP) != 0) {
1871                         if (tfe->af == AF_INET)
1872                                 paddr = &tfe->a.a4.dip;
1873                         else
1874                                 paddr = &tfe->a.a6.dip6;
1875
1876                         inet_ntop(tfe->af, paddr, tbuf, sizeof(tbuf));
1877                         printf("%s%s", comma, tbuf);
1878                         comma = ",";
1879                 }
1880
1881                 if ((i->tflags & IPFW_TFFLAG_DSTPORT) != 0) {
1882                         printf("%s%d", comma, ntohs(tfe->dport));
1883                         comma = ",";
1884                 }
1885
1886                 printf(" %s\n", pval);
1887         }
1888 }
1889
1890 static int
1891 table_do_get_stdlist(uint16_t opcode, ipfw_obj_lheader **polh)
1892 {
1893         ipfw_obj_lheader req, *olh;
1894         size_t sz;
1895
1896         memset(&req, 0, sizeof(req));
1897         sz = sizeof(req);
1898
1899         if (do_get3(opcode, &req.opheader, &sz) != 0)
1900                 if (errno != ENOMEM)
1901                         return (errno);
1902
1903         sz = req.size;
1904         if ((olh = calloc(1, sz)) == NULL)
1905                 return (ENOMEM);
1906
1907         olh->size = sz;
1908         if (do_get3(opcode, &olh->opheader, &sz) != 0) {
1909                 free(olh);
1910                 return (errno);
1911         }
1912
1913         *polh = olh;
1914         return (0);
1915 }
1916
1917 static int
1918 table_do_get_algolist(ipfw_obj_lheader **polh)
1919 {
1920
1921         return (table_do_get_stdlist(IP_FW_TABLES_ALIST, polh));
1922 }
1923
1924 static int
1925 table_do_get_vlist(ipfw_obj_lheader **polh)
1926 {
1927
1928         return (table_do_get_stdlist(IP_FW_TABLE_VLIST, polh));
1929 }
1930
1931 void
1932 ipfw_list_ta(int ac, char *av[])
1933 {
1934         ipfw_obj_lheader *olh;
1935         ipfw_ta_info *info;
1936         int error, i;
1937         const char *atype;
1938
1939         error = table_do_get_algolist(&olh);
1940         if (error != 0)
1941                 err(EX_OSERR, "Unable to request algorithm list");
1942
1943         info = (ipfw_ta_info *)(olh + 1);
1944         for (i = 0; i < olh->count; i++) {
1945                 if ((atype = match_value(tabletypes, info->type)) == NULL)
1946                         atype = "unknown";
1947                 printf("--- %s ---\n", info->algoname);
1948                 printf(" type: %s\n refcount: %u\n", atype, info->refcnt);
1949
1950                 info = (ipfw_ta_info *)((caddr_t)info + olh->objsize);
1951         }
1952
1953         free(olh);
1954 }
1955
1956
1957 /* Copy of current kernel table_value structure */
1958 struct _table_value {
1959         uint32_t        tag;            /* O_TAG/O_TAGGED */
1960         uint32_t        pipe;           /* O_PIPE/O_QUEUE */
1961         uint16_t        divert;         /* O_DIVERT/O_TEE */
1962         uint16_t        skipto;         /* skipto, CALLRET */
1963         uint32_t        netgraph;       /* O_NETGRAPH/O_NGTEE */
1964         uint32_t        fib;            /* O_SETFIB */
1965         uint32_t        nat;            /* O_NAT */
1966         uint32_t        nh4;
1967         uint8_t         dscp;
1968         uint8_t         spare0;
1969         uint16_t        spare1;
1970         /* -- 32 bytes -- */
1971         struct in6_addr nh6;
1972         uint32_t        limit;          /* O_LIMIT */
1973         uint32_t        zoneid;
1974         uint64_t        refcnt;         /* Number of references */
1975 };
1976
1977 int
1978 compare_values(const void *_a, const void *_b)
1979 {
1980         struct _table_value *a, *b;
1981
1982         a = (struct _table_value *)_a;
1983         b = (struct _table_value *)_b;
1984
1985         if (a->spare1 < b->spare1)
1986                 return (-1);
1987         else if (a->spare1 > b->spare1)
1988                 return (1);
1989
1990         return (0);
1991 }
1992
1993 void
1994 ipfw_list_values(int ac, char *av[])
1995 {
1996         ipfw_obj_lheader *olh;
1997         struct _table_value *v;
1998         int error, i;
1999         uint32_t vmask;
2000         char buf[128];
2001
2002         error = table_do_get_vlist(&olh);
2003         if (error != 0)
2004                 err(EX_OSERR, "Unable to request value list");
2005
2006         vmask = 0x7FFFFFFF; /* Similar to IPFW_VTYPE_LEGACY */
2007
2008         table_print_valheader(buf, sizeof(buf), vmask);
2009         printf("HEADER: %s\n", buf);
2010         v = (struct _table_value *)(olh + 1);
2011         qsort(v, olh->count, olh->objsize, compare_values);
2012         for (i = 0; i < olh->count; i++) {
2013                 table_show_value(buf, sizeof(buf), (ipfw_table_value *)v,
2014                     vmask, 0);
2015                 printf("[%u] refs=%lu %s\n", v->spare1, (u_long)v->refcnt, buf);
2016                 v = (struct _table_value *)((caddr_t)v + olh->objsize);
2017         }
2018
2019         free(olh);
2020 }
2021
2022 int
2023 table_check_name(const char *tablename)
2024 {
2025
2026         if (ipfw_check_object_name(tablename) != 0)
2027                 return (EINVAL);
2028         /* Restrict some 'special' names */
2029         if (strcmp(tablename, "all") == 0)
2030                 return (EINVAL);
2031         return (0);
2032 }
2033