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