options.c

   1 /*
   2  * firewall3 - 3rd OpenWrt UCI firewall implementation
   3  *
   4  *   Copyright (C) 2013 Jo-Philipp Wich <jow@openwrt.org>
   5  *
   6  * Permission to use, copy, modify, and/or distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 #include "options.h"
  20 #include "ubus.h"
  21
  22
  23 static bool
  24 put_value(void *ptr, void *val, int elem_size, bool is_list)
  25 {
  26         void *copy;
  27
  28         if (is_list)
  29         {
  30                 copy = malloc(elem_size);
  31
  32                 if (!copy)
  33                         return false;
  34
  35                 memcpy(copy, val, elem_size);
  36                 list_add_tail((struct list_head *)copy, (struct list_head *)ptr);
  37                 return true;
  38         }
  39
  40         memcpy(ptr, val, elem_size);
  41         return false;
  42 }
  43
  44 static bool
  45 parse_enum(void *ptr, const char *val, const char **values, int min, int max)
  46 {
  47         int i, l = strlen(val);
  48
  49         if (l > 0)
  50         {
  51                 for (i = 0; i <= (max - min); i++)
  52                 {
  53                         if (!strncasecmp(val, values[i], l))
  54                         {
  55                                 *((int *)ptr) = min + i;
  56                                 return true;
  57                         }
  58                 }
  59         }
  60
  61         return false;
  62 }
  63
  64
  65 const char *fw3_flag_names[__FW3_FLAG_MAX] = {
  66         "filter",
  67         "nat",
  68         "mangle",
  69         "raw",
  70
  71         "IPv4",
  72         "IPv6",
  73
  74         "ACCEPT",
  75         "REJECT",
  76         "DROP",
  77         "NOTRACK",
  78         "MARK",
  79         "DNAT",
  80         "SNAT",
  81
  82         "ACCEPT",
  83         "REJECT",
  84         "DROP",
  85 };
  86
  87 static const char *limit_units[] = {
  88         "second",
  89         "minute",
  90         "hour",
  91         "day",
  92 };
  93
  94 static const char *ipset_methods[] = {
  95         "bitmap",
  96         "hash",
  97         "list",
  98 };
  99
 100 static const char *ipset_types[] = {
 101         "ip",
 102         "port",
 103         "mac",
 104         "net",
 105         "set",
 106 };
 107
 108 static const char *weekdays[] = {
 109         "monday",
 110         "tuesday",
 111         "wednesday",
 112         "thursday",
 113         "friday",
 114         "saturday",
 115         "sunday",
 116 };
 117
 118 static const char *include_types[] = {
 119         "script",
 120         "restore",
 121 };
 122
 123 static const char *reflection_sources[] = {
 124         "internal",
 125         "external",
 126 };
 127
 128
 129 bool
 130 fw3_parse_bool(void *ptr, const char *val, bool is_list)
 131 {
 132         if (!strcmp(val, "true") || !strcmp(val, "yes") || !strcmp(val, "1"))
 133                 *((bool *)ptr) = true;
 134         else
 135                 *((bool *)ptr) = false;
 136
 137         return true;
 138 }
 139
 140 bool
 141 fw3_parse_int(void *ptr, const char *val, bool is_list)
 142 {
 143         int n = strtol(val, NULL, 10);
 144
 145         if (errno == ERANGE || errno == EINVAL)
 146                 return false;
 147
 148         *((int *)ptr) = n;
 149
 150         return true;
 151 }
 152
 153 bool
 154 fw3_parse_string(void *ptr, const char *val, bool is_list)
 155 {
 156         *((char **)ptr) = (char *)val;
 157         return true;
 158 }
 159
 160 bool
 161 fw3_parse_target(void *ptr, const char *val, bool is_list)
 162 {
 163         return parse_enum(ptr, val, &fw3_flag_names[FW3_FLAG_ACCEPT],
 164                           FW3_FLAG_ACCEPT, FW3_FLAG_SNAT);
 165 }
 166
 167 bool
 168 fw3_parse_limit(void *ptr, const char *val, bool is_list)
 169 {
 170         struct fw3_limit *limit = ptr;
 171         enum fw3_limit_unit u = FW3_LIMIT_UNIT_SECOND;
 172         char *e;
 173         int n;
 174
 175         if (*val == '!')
 176         {
 177                 limit->invert = true;
 178                 while (isspace(*++val));
 179         }
 180
 181         n = strtol(val, &e, 10);
 182
 183         if (errno == ERANGE || errno == EINVAL)
 184                 return false;
 185
 186         if (*e && *e++ != '/')
 187                 return false;
 188
 189         if (!strlen(e))
 190                 return false;
 191
 192         if (!parse_enum(&u, e, limit_units, 0, FW3_LIMIT_UNIT_DAY))
 193                 return false;
 194
 195         limit->rate = n;
 196         limit->unit = u;
 197
 198         return true;
 199 }
 200
 201 bool
 202 fw3_parse_device(void *ptr, const char *val, bool is_list)
 203 {
 204         struct fw3_device dev = { };
 205
 206         if (*val == '*')
 207         {
 208                 dev.set = true;
 209                 dev.any = true;
 210                 put_value(ptr, &dev, sizeof(dev), is_list);
 211                 return true;
 212         }
 213
 214         if (*val == '!')
 215         {
 216                 dev.invert = true;
 217                 while (isspace(*++val));
 218         }
 219
 220         if (*val)
 221                 snprintf(dev.name, sizeof(dev.name), "%s", val);
 222         else
 223                 return false;
 224
 225         dev.set = true;
 226         put_value(ptr, &dev, sizeof(dev), is_list);
 227         return true;
 228 }
 229
 230 bool
 231 fw3_parse_address(void *ptr, const char *val, bool is_list)
 232 {
 233         struct fw3_address addr = { };
 234         struct in_addr v4;
 235         struct in6_addr v6;
 236         char *p, *s, *e;
 237         int i, m = -1;
 238
 239         if (*val == '!')
 240         {
 241                 addr.invert = true;
 242                 while (isspace(*++val));
 243         }
 244
 245         s = strdup(val);
 246
 247         if (!s)
 248                 return false;
 249
 250         if ((p = strchr(s, '/')) != NULL)
 251         {
 252                 *p++ = 0;
 253                 m = strtoul(p, &e, 10);
 254
 255                 if ((e == p) || (*e != 0))
 256                 {
 257                         if (strchr(s, ':') || !inet_pton(AF_INET, p, &v4))
 258                         {
 259                                 free(s);
 260                                 return false;
 261                         }
 262
 263                         for (i = 0, m = 32; !(v4.s_addr & 1) && (i < 32); i++)
 264                         {
 265                                 m--;
 266                                 v4.s_addr >>= 1;
 267                         }
 268                 }
 269         }
 270         else if ((p = strchr(s, '-')) != NULL)
 271         {
 272                 *p++ = 0;
 273
 274                 if (inet_pton(AF_INET6, p, &v6))
 275                 {
 276                         addr.family = FW3_FAMILY_V6;
 277                         addr.address2.v6 = v6;
 278                         addr.range = true;
 279                 }
 280                 else if (inet_pton(AF_INET, p, &v4))
 281                 {
 282                         addr.family = FW3_FAMILY_V4;
 283                         addr.address2.v4 = v4;
 284                         addr.range = true;
 285                 }
 286                 else
 287                 {
 288                         free(s);
 289                         return false;
 290                 }
 291         }
 292
 293         if (inet_pton(AF_INET6, s, &v6))
 294         {
 295                 addr.family = FW3_FAMILY_V6;
 296                 addr.address.v6 = v6;
 297                 addr.mask = (m >= 0) ? m : 128;
 298         }
 299         else if (inet_pton(AF_INET, s, &v4))
 300         {
 301                 addr.family = FW3_FAMILY_V4;
 302                 addr.address.v4 = v4;
 303                 addr.mask = (m >= 0) ? m : 32;
 304         }
 305         else
 306         {
 307                 free(s);
 308                 return false;
 309         }
 310
 311         free(s);
 312         addr.set = true;
 313         put_value(ptr, &addr, sizeof(addr), is_list);
 314         return true;
 315 }
 316
 317 bool
 318 fw3_parse_network(void *ptr, const char *val, bool is_list)
 319 {
 320         struct fw3_device dev = { };
 321         struct fw3_address *addr;
 322         struct list_head *addr_list;
 323
 324         if (!fw3_parse_address(ptr, val, is_list))
 325         {
 326                 if (!fw3_parse_device(&dev, val, false))
 327                         return false;
 328
 329                 addr_list = fw3_ubus_address(dev.name);
 330
 331                 if (addr_list)
 332                 {
 333                         list_for_each_entry(addr, addr_list, list)
 334                         {
 335                                 addr->invert = dev.invert;
 336
 337                                 if (!put_value(ptr, addr, sizeof(*addr), is_list))
 338                                         break;
 339                         }
 340
 341                         fw3_ubus_address_free(addr_list);
 342                 }
 343         }
 344
 345         return true;
 346 }
 347
 348 bool
 349 fw3_parse_mac(void *ptr, const char *val, bool is_list)
 350 {
 351         struct fw3_mac addr = { };
 352         struct ether_addr *mac;
 353
 354         if (*val == '!')
 355         {
 356                 addr.invert = true;
 357                 while (isspace(*++val));
 358         }
 359
 360         if ((mac = ether_aton(val)) != NULL)
 361         {
 362                 addr.mac = *mac;
 363                 addr.set = true;
 364
 365                 put_value(ptr, &addr, sizeof(addr), is_list);
 366                 return true;
 367         }
 368
 369         return false;
 370 }
 371
 372 bool
 373 fw3_parse_port(void *ptr, const char *val, bool is_list)
 374 {
 375         struct fw3_port range = { };
 376         uint16_t n;
 377         uint16_t m;
 378         char *p;
 379
 380         if (*val == '!')
 381         {
 382                 range.invert = true;
 383                 while (isspace(*++val));
 384         }
 385
 386         n = strtoul(val, &p, 10);
 387
 388         if (errno == ERANGE || errno == EINVAL)
 389                 return false;
 390
 391         if (*p && *p != '-' && *p != ':')
 392                 return false;
 393
 394         if (*p)
 395         {
 396                 m = strtoul(++p, NULL, 10);
 397
 398                 if (errno == ERANGE || errno == EINVAL || m < n)
 399                         return false;
 400
 401                 range.port_min = n;
 402                 range.port_max = m;
 403         }
 404         else
 405         {
 406                 range.port_min = n;
 407                 range.port_max = n;
 408         }
 409
 410         range.set = true;
 411         put_value(ptr, &range, sizeof(range), is_list);
 412         return true;
 413 }
 414
 415 bool
 416 fw3_parse_family(void *ptr, const char *val, bool is_list)
 417 {
 418         if (!strcmp(val, "any"))
 419                 *((enum fw3_family *)ptr) = FW3_FAMILY_ANY;
 420         else if (!strcmp(val, "inet") || strrchr(val, '4'))
 421                 *((enum fw3_family *)ptr) = FW3_FAMILY_V4;
 422         else if (!strcmp(val, "inet6") || strrchr(val, '6'))
 423                 *((enum fw3_family *)ptr) = FW3_FAMILY_V6;
 424         else
 425                 return false;
 426
 427         return true;
 428 }
 429
 430 bool
 431 fw3_parse_icmptype(void *ptr, const char *val, bool is_list)
 432 {
 433         struct fw3_icmptype icmp = { };
 434         bool v4 = false;
 435         bool v6 = false;
 436         char *p;
 437         int i;
 438
 439         for (i = 0; i < ARRAY_SIZE(fw3_icmptype_list_v4); i++)
 440         {
 441                 if (!strcmp(val, fw3_icmptype_list_v4[i].name))
 442                 {
 443                         icmp.type     = fw3_icmptype_list_v4[i].type;
 444                         icmp.code_min = fw3_icmptype_list_v4[i].code_min;
 445                         icmp.code_max = fw3_icmptype_list_v4[i].code_max;
 446
 447                         v4 = true;
 448                         break;
 449                 }
 450         }
 451
 452         for (i = 0; i < ARRAY_SIZE(fw3_icmptype_list_v6); i++)
 453         {
 454                 if (!strcmp(val, fw3_icmptype_list_v6[i].name))
 455                 {
 456                         icmp.type6     = fw3_icmptype_list_v6[i].type;
 457                         icmp.code6_min = fw3_icmptype_list_v6[i].code_min;
 458                         icmp.code6_max = fw3_icmptype_list_v6[i].code_max;
 459
 460                         v6 = true;
 461                         break;
 462                 }
 463         }
 464
 465         if (!v4 && !v6)
 466         {
 467                 i = strtoul(val, &p, 10);
 468
 469                 if ((p == val) || (*p != '/' && *p != 0) || (i > 0xFF))
 470                         return false;
 471
 472                 icmp.type = i;
 473
 474                 if (*p == '/')
 475                 {
 476                         val = ++p;
 477                         i = strtoul(val, &p, 10);
 478
 479                         if ((p == val) || (*p != 0) || (i > 0xFF))
 480                                 return false;
 481
 482                         icmp.code_min = i;
 483                         icmp.code_max = i;
 484                 }
 485                 else
 486                 {
 487                         icmp.code_min = 0;
 488                         icmp.code_max = 0xFF;
 489                 }
 490
 491                 icmp.type6     = icmp.type;
 492                 icmp.code6_min = icmp.code_max;
 493                 icmp.code6_max = icmp.code_max;
 494
 495                 v4 = true;
 496                 v6 = true;
 497         }
 498
 499         icmp.family = (v4 && v6) ? FW3_FAMILY_ANY
 500                                  : (v6 ? FW3_FAMILY_V6 : FW3_FAMILY_V4);
 501
 502         put_value(ptr, &icmp, sizeof(icmp), is_list);
 503         return true;
 504 }
 505
 506 bool
 507 fw3_parse_protocol(void *ptr, const char *val, bool is_list)
 508 {
 509         struct fw3_protocol proto = { };
 510         struct protoent *ent;
 511
 512         if (*val == '!')
 513         {
 514                 proto.invert = true;
 515                 while (isspace(*++val));
 516         }
 517
 518         if (!strcmp(val, "all"))
 519         {
 520                 proto.any = true;
 521                 put_value(ptr, &proto, sizeof(proto), is_list);
 522                 return true;
 523         }
 524         else if (!strcmp(val, "icmpv6"))
 525         {
 526                 val = "ipv6-icmp";
 527         }
 528         else if (!strcmp(val, "tcpudp"))
 529         {
 530                 proto.protocol = 6;
 531                 if (put_value(ptr, &proto, sizeof(proto), is_list))
 532                 {
 533                         proto.protocol = 17;
 534                         put_value(ptr, &proto, sizeof(proto), is_list);
 535                 }
 536
 537                 return true;
 538         }
 539
 540         ent = getprotobyname(val);
 541
 542         if (ent)
 543         {
 544                 proto.protocol = ent->p_proto;
 545                 put_value(ptr, &proto, sizeof(proto), is_list);
 546                 return true;
 547         }
 548
 549         proto.protocol = strtoul(val, NULL, 10);
 550
 551         if (errno == ERANGE || errno == EINVAL)
 552                 return false;
 553
 554         put_value(ptr, &proto, sizeof(proto), is_list);
 555         return true;
 556 }
 557
 558 bool
 559 fw3_parse_ipset_method(void *ptr, const char *val, bool is_list)
 560 {
 561         return parse_enum(ptr, val, ipset_methods,
 562                           FW3_IPSET_METHOD_BITMAP, FW3_IPSET_METHOD_LIST);
 563 }
 564
 565 bool
 566 fw3_parse_ipset_datatype(void *ptr, const char *val, bool is_list)
 567 {
 568         struct fw3_ipset_datatype *type = ptr;
 569
 570         if (!strncmp(val, "dest_", 5))
 571         {
 572                 val += 5;
 573                 type->dest = true;
 574         }
 575         else if (!strncmp(val, "dst_", 4))
 576         {
 577                 val += 4;
 578                 type->dest = true;
 579         }
 580         else if (!strncmp(val, "src_", 4))
 581         {
 582                 val += 4;
 583                 type->dest = false;
 584         }
 585
 586         return parse_enum(&type->type, val, ipset_types,
 587                           FW3_IPSET_TYPE_IP, FW3_IPSET_TYPE_SET);
 588 }
 589
 590 bool
 591 fw3_parse_date(void *ptr, const char *val, bool is_list)
 592 {
 593         unsigned int year = 1970, mon = 1, day = 1, hour = 0, min = 0, sec = 0;
 594         struct tm tm = { 0 };
 595         char *p;
 596
 597         year = strtoul(val, &p, 10);
 598         if ((*p != '-' && *p) || year < 1970 || year > 2038)
 599                 goto fail;
 600         else if (!*p)
 601                 goto ret;
 602
 603         mon = strtoul(++p, &p, 10);
 604         if ((*p != '-' && *p) || mon > 12)
 605                 goto fail;
 606         else if (!*p)
 607                 goto ret;
 608
 609         day = strtoul(++p, &p, 10);
 610         if ((*p != 'T' && *p) || day > 31)
 611                 goto fail;
 612         else if (!*p)
 613                 goto ret;
 614
 615         hour = strtoul(++p, &p, 10);
 616         if ((*p != ':' && *p) || hour > 23)
 617                 goto fail;
 618         else if (!*p)
 619                 goto ret;
 620
 621         min = strtoul(++p, &p, 10);
 622         if ((*p != ':' && *p) || min > 59)
 623                 goto fail;
 624         else if (!*p)
 625                 goto ret;
 626
 627         sec = strtoul(++p, &p, 10);
 628         if (*p || sec > 59)
 629                 goto fail;
 630
 631 ret:
 632         tm.tm_year = year - 1900;
 633         tm.tm_mon  = mon - 1;
 634         tm.tm_mday = day;
 635         tm.tm_hour = hour;
 636         tm.tm_min  = min;
 637         tm.tm_sec  = sec;
 638
 639         if (mktime(&tm) >= 0)
 640         {
 641                 *((struct tm *)ptr) = tm;
 642                 return true;
 643         }
 644
 645 fail:
 646         return false;
 647 }
 648
 649 bool
 650 fw3_parse_time(void *ptr, const char *val, bool is_list)
 651 {
 652         unsigned int hour = 0, min = 0, sec = 0;
 653         char *p;
 654
 655         hour = strtoul(val, &p, 10);
 656         if (*p != ':' || hour > 23)
 657                 goto fail;
 658
 659         min = strtoul(++p, &p, 10);
 660         if ((*p != ':' && *p) || min > 59)
 661                 goto fail;
 662         else if (!*p)
 663                 goto ret;
 664
 665         sec = strtoul(++p, &p, 10);
 666         if (*p || sec > 59)
 667                 goto fail;
 668
 669 ret:
 670         *((int *)ptr) = 60 * 60 * hour + 60 * min + sec;
 671         return true;
 672
 673 fail:
 674         return false;
 675 }
 676
 677 bool
 678 fw3_parse_weekdays(void *ptr, const char *val, bool is_list)
 679 {
 680         unsigned int w = 0;
 681         char *p, *s;
 682
 683         if (*val == '!')
 684         {
 685                 setbit(*(uint8_t *)ptr, 0);
 686                 while (isspace(*++val));
 687         }
 688
 689         if (!(s = strdup(val)))
 690                 return false;
 691
 692         for (p = strtok(s, " \t"); p; p = strtok(NULL, " \t"))
 693         {
 694                 if (!parse_enum(&w, p, weekdays, 1, 7))
 695                 {
 696                         w = strtoul(p, &p, 10);
 697
 698                         if (*p || w < 1 || w > 7)
 699                         {
 700                                 free(s);
 701                                 return false;
 702                         }
 703                 }
 704
 705                 setbit(*(uint8_t *)ptr, w);
 706         }
 707
 708         free(s);
 709         return true;
 710 }
 711
 712 bool
 713 fw3_parse_monthdays(void *ptr, const char *val, bool is_list)
 714 {
 715         unsigned int d;
 716         char *p, *s;
 717
 718         if (*val == '!')
 719         {
 720                 setbit(*(uint32_t *)ptr, 0);
 721                 while (isspace(*++val));
 722         }
 723
 724         if (!(s = strdup(val)))
 725                 return false;
 726
 727         for (p = strtok(s, " \t"); p; p = strtok(NULL, " \t"))
 728         {
 729                 d = strtoul(p, &p, 10);
 730
 731                 if (*p || d < 1 || d > 31)
 732                 {
 733                         free(s);
 734                         return false;
 735                 }
 736
 737                 setbit(*(uint32_t *)ptr, d);
 738         }
 739
 740         free(s);
 741         return true;
 742 }
 743
 744 bool
 745 fw3_parse_include_type(void *ptr, const char *val, bool is_list)
 746 {
 747         return parse_enum(ptr, val, include_types,
 748                           FW3_INC_TYPE_SCRIPT, FW3_INC_TYPE_RESTORE);
 749 }
 750
 751 bool
 752 fw3_parse_reflection_source(void *ptr, const char *val, bool is_list)
 753 {
 754         return parse_enum(ptr, val, reflection_sources,
 755                           FW3_REFLECTION_INTERNAL, FW3_REFLECTION_EXTERNAL);
 756 }
 757
 758 bool
 759 fw3_parse_mark(void *ptr, const char *val, bool is_list)
 760 {
 761         uint32_t n;
 762         char *s, *e;
 763         struct fw3_mark *m = ptr;
 764
 765         if (*val == '!')
 766         {
 767                 m->invert = true;
 768                 while (isspace(*++val));
 769         }
 770
 771         if ((s = strchr(val, '/')) != NULL)
 772                 *s++ = 0;
 773
 774         n = strtoul(val, &e, 0);
 775
 776         if (e == val || *e)
 777                 return false;
 778
 779         m->mark = n;
 780         m->mask = 0xFFFFFFFF;
 781
 782         if (s)
 783         {
 784                 n = strtoul(s, &e, 0);
 785
 786                 if (e == s || *e)
 787                         return false;
 788
 789                 m->mask = n;
 790         }
 791
 792         m->set = true;
 793         return true;
 794 }
 795
 796
 797 void
 798 fw3_parse_options(void *s, const struct fw3_option *opts,
 799                   struct uci_section *section)
 800 {
 801         char *p, *v;
 802         bool known;
 803         struct uci_element *e, *l;
 804         struct uci_option *o;
 805         const struct fw3_option *opt;
 806         struct list_head *dest;
 807
 808         uci_foreach_element(&section->options, e)
 809         {
 810                 o = uci_to_option(e);
 811                 known = false;
 812
 813                 for (opt = opts; opt->name; opt++)
 814                 {
 815                         if (!opt->parse)
 816                                 continue;
 817
 818                         if (strcmp(opt->name, e->name))
 819                                 continue;
 820
 821                         if (o->type == UCI_TYPE_LIST)
 822                         {
 823                                 if (!opt->elem_size)
 824                                 {
 825                                         warn_elem(e, "must not be a list");
 826                                 }
 827                                 else
 828                                 {
 829                                         dest = (struct list_head *)((char *)s + opt->offset);
 830
 831                                         uci_foreach_element(&o->v.list, l)
 832                                         {
 833                                                 if (!l->name)
 834                                                         continue;
 835
 836                                                 if (!opt->parse(dest, l->name, true))
 837                                                 {
 838                                                         warn_elem(e, "has invalid value '%s'", l->name);
 839                                                         continue;
 840                                                 }
 841                                         }
 842                                 }
 843                         }
 844                         else
 845                         {
 846                                 v = o->v.string;
 847
 848                                 if (!v)
 849                                         continue;
 850
 851                                 if (!opt->elem_size)
 852                                 {
 853                                         if (!opt->parse((char *)s + opt->offset, o->v.string, false))
 854                                                 warn_elem(e, "has invalid value '%s'", o->v.string);
 855                                 }
 856                                 else
 857                                 {
 858                                         dest = (struct list_head *)((char *)s + opt->offset);
 859
 860                                         for (p = strtok(v, " \t"); p != NULL; p = strtok(NULL, " \t"))
 861                                         {
 862                                                 if (!opt->parse(dest, p, true))
 863                                                 {
 864                                                         warn_elem(e, "has invalid value '%s'", p);
 865                                                         continue;
 866                                                 }
 867                                         }
 868                                 }
 869                         }
 870
 871                         known = true;
 872                         break;
 873                 }
 874
 875                 if (!known)
 876                         warn_elem(e, "is unknown");
 877         }
 878 }
 879
 880
 881 void
 882 fw3_format_in_out(struct fw3_device *in, struct fw3_device *out)
 883 {
 884         if (in && !in->any)
 885                 fw3_pr(" %s-i %s", in->invert ? "! " : "", in->name);
 886
 887         if (out && !out->any)
 888                 fw3_pr(" %s-o %s", out->invert ? "! " : "", out->name);
 889 }
 890
 891 const char *
 892 fw3_address_to_string(struct fw3_address *address, bool allow_invert)
 893 {
 894         char *p, ip[INET6_ADDRSTRLEN];
 895         static char buf[INET6_ADDRSTRLEN * 2 + 2];
 896
 897         p = buf;
 898
 899         if (address->invert && allow_invert)
 900                 p += sprintf(p, "!");
 901
 902         inet_ntop(address->family == FW3_FAMILY_V4 ? AF_INET : AF_INET6,
 903                   &address->address.v4, ip, sizeof(ip));
 904
 905         p += sprintf(p, "%s", ip);
 906
 907         if (address->range)
 908         {
 909                 inet_ntop(address->family == FW3_FAMILY_V4 ? AF_INET : AF_INET6,
 910                           &address->address2.v4, ip, sizeof(ip));
 911
 912                 p += sprintf(p, "-%s", ip);
 913         }
 914         else
 915         {
 916                 p += sprintf(p, "/%u", address->mask);
 917         }
 918
 919         return buf;
 920 }
 921
 922 void
 923 fw3_format_src_dest(struct fw3_address *src, struct fw3_address *dest)
 924 {
 925         if ((src && src->range) || (dest && dest->range))
 926                 fw3_pr(" -m iprange");
 927
 928         if (src && src->set)
 929         {
 930                 fw3_pr(" %s%s %s", src->invert ? "! " : "",
 931                                    src->range ? "--src-range" : "-s",
 932                                    fw3_address_to_string(src, false));
 933         }
 934
 935         if (dest && dest->set)
 936         {
 937                 fw3_pr(" %s%s %s", dest->invert ? "! " : "",
 938                                    dest->range ? "--dst-range" : "-d",
 939                                    fw3_address_to_string(dest, false));
 940         }
 941 }
 942
 943 void
 944 fw3_format_sport_dport(struct fw3_port *sp, struct fw3_port *dp)
 945 {
 946         if (sp && sp->set)
 947         {
 948                 if (sp->port_min == sp->port_max)
 949                         fw3_pr(" %s--sport %u", sp->invert ? "! " : "", sp->port_min);
 950                 else
 951                         fw3_pr(" %s--sport %u:%u",
 952                                sp->invert ? "! " : "", sp->port_min, sp->port_max);
 953         }
 954
 955         if (dp && dp->set)
 956         {
 957                 if (dp->port_min == dp->port_max)
 958                         fw3_pr(" %s--dport %u", dp->invert ? "! " : "", dp->port_min);
 959                 else
 960                         fw3_pr(" %s--dport %u:%u",
 961                                dp->invert ? "! " : "", dp->port_min, dp->port_max);
 962         }
 963 }
 964
 965 void
 966 fw3_format_mac(struct fw3_mac *mac)
 967 {
 968         if (!mac)
 969                 return;
 970
 971         fw3_pr(" -m mac %s--mac-source %s",
 972                mac->invert ? "! " : "", ether_ntoa(&mac->mac));
 973 }
 974
 975 void
 976 fw3_format_protocol(struct fw3_protocol *proto, enum fw3_family family)
 977 {
 978         uint16_t pr;
 979
 980         if (!proto)
 981                 return;
 982
 983         pr = proto->protocol;
 984
 985         if (pr == 1 && family == FW3_FAMILY_V6)
 986                 pr = 58;
 987
 988         if (proto->any)
 989                 fw3_pr(" -p all");
 990         else
 991                 fw3_pr(" %s-p %u", proto->invert ? "! " : "", pr);
 992 }
 993
 994 void
 995 fw3_format_icmptype(struct fw3_icmptype *icmp, enum fw3_family family)
 996 {
 997         if (!icmp)
 998                 return;
 999
1000         if (family != FW3_FAMILY_V6)
1001         {
1002                 if (icmp->code_min == 0 && icmp->code_max == 0xFF)
1003                         fw3_pr(" %s--icmp-type %u", icmp->invert ? "! " : "", icmp->type);
1004                 else
1005                         fw3_pr(" %s--icmp-type %u/%u",
1006                                    icmp->invert ? "! " : "", icmp->type, icmp->code_min);
1007         }
1008         else
1009         {
1010                 if (icmp->code6_min == 0 && icmp->code6_max == 0xFF)
1011                         fw3_pr(" %s--icmpv6-type %u", icmp->invert ? "! " : "", icmp->type6);
1012                 else
1013                         fw3_pr(" %s--icmpv6-type %u/%u",
1014                                    icmp->invert ? "! " : "", icmp->type6, icmp->code6_min);
1015         }
1016 }
1017
1018 void
1019 fw3_format_limit(struct fw3_limit *limit)
1020 {
1021         if (!limit)
1022                 return;
1023
1024         if (limit->rate > 0)
1025         {
1026                 fw3_pr(" -m limit %s--limit %u/%s",
1027                        limit->invert ? "! " : "",
1028                        limit->rate, limit_units[limit->unit]);
1029
1030                 if (limit->burst > 0)
1031                         fw3_pr(" --limit-burst %u", limit->burst);
1032         }
1033 }
1034
1035 void
1036 fw3_format_ipset(struct fw3_ipset *ipset, bool invert)
1037 {
1038         bool first = true;
1039         const char *name = NULL;
1040         struct fw3_ipset_datatype *type;
1041
1042         if (!ipset)
1043                 return;
1044
1045         if (ipset->external && *ipset->external)
1046                 name = ipset->external;
1047         else
1048                 name = ipset->name;
1049
1050         fw3_pr(" -m set %s--match-set %s", invert ? "! " : "", name);
1051
1052         list_for_each_entry(type, &ipset->datatypes, list)
1053         {
1054                 fw3_pr("%c%s", first ? ' ' : ',', type->dest ? "dst" : "src");
1055                 first = false;
1056         }
1057 }
1058
1059 void
1060 fw3_format_time(struct fw3_time *time)
1061 {
1062         int i;
1063         struct tm empty = { 0 };
1064         char buf[sizeof("9999-99-99T23:59:59\0")];
1065         bool d1 = memcmp(&time->datestart, &empty, sizeof(empty));
1066         bool d2 = memcmp(&time->datestop, &empty, sizeof(empty));
1067         bool first;
1068
1069         if (!d1 && !d2 && !time->timestart && !time->timestop &&
1070             !(time->monthdays & 0xFFFFFFFE) && !(time->weekdays & 0xFE))
1071         {
1072                 return;
1073         }
1074
1075         fw3_pr(" -m time");
1076
1077         if (time->utc)
1078                 fw3_pr(" --utc");
1079
1080         if (d1)
1081         {
1082                 strftime(buf, sizeof(buf), "%Y-%m-%dT%H:%M:%S", &time->datestart);
1083                 fw3_pr(" --datestart %s", buf);
1084         }
1085
1086         if (d2)
1087         {
1088                 strftime(buf, sizeof(buf), "%Y-%m-%dT%H:%M:%S", &time->datestop);
1089                 fw3_pr(" --datestop %s", buf);
1090         }
1091
1092         if (time->timestart)
1093         {
1094                 fw3_pr(" --timestart %02d:%02d:%02d",
1095                        time->timestart / 3600,
1096                        time->timestart % 3600 / 60,
1097                        time->timestart % 60);
1098         }
1099
1100         if (time->timestop)
1101         {
1102                 fw3_pr(" --timestop %02d:%02d:%02d",
1103                        time->timestop / 3600,
1104                        time->timestop % 3600 / 60,
1105                        time->timestop % 60);
1106         }
1107
1108         if (time->monthdays & 0xFFFFFFFE)
1109         {
1110                 fw3_pr(" %s--monthdays", hasbit(time->monthdays, 0) ? "! " : "");
1111
1112                 for (i = 1, first = true; i < 32; i++)
1113                 {
1114                         if (hasbit(time->monthdays, i))
1115                         {
1116                                 fw3_pr("%c%u", first ? ' ' : ',', i);
1117                                 first = false;
1118                         }
1119                 }
1120         }
1121
1122         if (time->weekdays & 0xFE)
1123         {
1124                 fw3_pr(" %s--weekdays", hasbit(time->weekdays, 0) ? "! " : "");
1125
1126                 for (i = 1, first = true; i < 8; i++)
1127                 {
1128                         if (hasbit(time->weekdays, i))
1129                         {
1130                                 fw3_pr("%c%u", first ? ' ' : ',', i);
1131                                 first = false;
1132                         }
1133                 }
1134         }
1135 }
1136
1137 void
1138 fw3_format_mark(struct fw3_mark *mark)
1139 {
1140         if (!mark->set)
1141                 return;
1142
1143         fw3_pr(" -m mark %s--mark 0x%x", mark->invert ? "! " : "", mark->mark);
1144
1145         if (mark->mask < 0xFFFFFFFF)
1146                 fw3_pr("/0x%x", mark->mask);
1147 }
1148
1149 void
1150 __fw3_format_comment(const char *comment, ...)
1151 {
1152         va_list ap;
1153         int len = 0;
1154         const char *c;
1155
1156         if (!comment || !*comment)
1157                 return;
1158
1159         fw3_pr(" -m comment --comment \"");
1160
1161         c = comment;
1162
1163         va_start(ap, comment);
1164
1165         do
1166         {
1167                 while (*c)
1168                 {
1169                         switch (*c)
1170                         {
1171                         case '"':
1172                         case '$':
1173                         case '`':
1174                         case '\\':
1175                                 fw3_pr("\\");
1176                                 /* fall through */
1177
1178                         default:
1179                                 fw3_pr("%c", *c);
1180                                 break;
1181                         }
1182
1183                         c++;
1184
1185                         if (len++ >= 255)
1186                                 goto end;
1187                 }
1188
1189                 c = va_arg(ap, const char *);
1190         }
1191         while (c);
1192
1193 end:
1194         va_end(ap);
1195         fw3_pr("\"");
1196 }
1197
1198 void
1199 fw3_format_extra(const char *extra)
1200 {
1201         if (!extra || !*extra)
1202                 return;
1203
1204         fw3_pr(" %s", extra);
1205 }