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