options: emit an empty address item when resolving networks fails

[project/firewall3.git] / options.c

diff --git a/options.c b/options.c
index f41153c693f35e509a3c531e2a7afa437ae67ddf..6d2a283fdd8a95f03cdfb3295cb54db8720bed9b 100644 (file)
--- a/options.c
+++ b/options.c
@@ -1,7 +1,7 @@
 /*
  * firewall3 - 3rd OpenWrt UCI firewall implementation
  *
- *   Copyright (C) 2013-2014 Jo-Philipp Wich <jow@openwrt.org>
+ *   Copyright (C) 2013-2014 Jo-Philipp Wich <jo@mein.io>
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
@@ -342,19 +342,31 @@ fw3_parse_network(void *ptr, const char *val, bool is_list)
        struct fw3_device dev = { };
        struct fw3_address *addr, *tmp;
        LIST_HEAD(addr_list);
+       int n_addrs;
 
        if (!fw3_parse_address(ptr, val, is_list))
        {
                if (!fw3_parse_device(&dev, val, false))
                        return false;
 
-               fw3_ubus_address(&addr_list, dev.name);
+               n_addrs = fw3_ubus_address(&addr_list, dev.name);
+
                list_for_each_entry(addr, &addr_list, list)
                {
                        addr->invert = dev.invert;
                        addr->resolved = true;
                }
 
+               /* add an empty address member with .set = false, .resolved = true
+                * to signal resolving failure to callers */
+               if (n_addrs == 0)
+               {
+                       tmp = fw3_alloc(sizeof(*tmp));
+                       tmp->resolved = true;
+
+                       list_add_tail(&tmp->list, &addr_list);
+               }
+
                if (is_list)
                {
                        list_splice_tail(&addr_list, ptr);
@@ -718,7 +730,7 @@ fw3_parse_weekdays(void *ptr, const char *val, bool is_list)
 
        if (*val == '!')
        {
-               setbit(*(uint8_t *)ptr, 0);
+               fw3_setbit(*(uint8_t *)ptr, 0);
                while (isspace(*++val));
        }
 
@@ -738,7 +750,7 @@ fw3_parse_weekdays(void *ptr, const char *val, bool is_list)
                        }
                }
 
-               setbit(*(uint8_t *)ptr, w);
+               fw3_setbit(*(uint8_t *)ptr, w);
        }
 
        free(s);
@@ -753,7 +765,7 @@ fw3_parse_monthdays(void *ptr, const char *val, bool is_list)
 
        if (*val == '!')
        {
-               setbit(*(uint32_t *)ptr, 0);
+               fw3_setbit(*(uint32_t *)ptr, 0);
                while (isspace(*++val));
        }
 
@@ -770,7 +782,7 @@ fw3_parse_monthdays(void *ptr, const char *val, bool is_list)
                        return false;
                }
 
-               setbit(*(uint32_t *)ptr, d);
+               fw3_setbit(*(uint32_t *)ptr, d);
        }
 
        free(s);
@@ -891,7 +903,7 @@ fw3_parse_options(void *s, const struct fw3_option *opts,
                   struct uci_section *section)
 {
        char *p, *v;
-       bool known;
+       bool known, inv;
        struct uci_element *e, *l;
        struct uci_option *o;
        const struct fw3_option *opt;
@@ -953,10 +965,30 @@ fw3_parse_options(void *s, const struct fw3_option *opts,
                                }
                                else
                                {
+                                       inv = false;
                                        dest = (struct list_head *)((char *)s + opt->offset);
 
                                        for (p = strtok(v, " \t"); p != NULL; p = strtok(NULL, " \t"))
                                        {
+                                               /* If we encounter a sole "!" token, assume that it
+                                                * is meant to be part of the next token, so silently
+                                                * skip it and remember the state... */
+                                               if (!strcmp(p, "!"))
+                                               {
+                                                       inv = true;
+                                                       continue;
+                                               }
+
+                                               /* The previous token was a sole "!", rewind pointer
+                                                * back by one byte to precede the value with an
+                                                * exclamation mark which effectively turns
+                                                * ("!", "foo") into ("!foo") */
+                                               if (inv)
+                                               {
+                                                       *--p = '!';
+                                                       inv = false;
+                                               }
+
                                                if (!opt->parse(dest, p, true))
                                                {
                                                        warn_elem(e, "has invalid value '%s'", p);
@@ -964,6 +996,14 @@ fw3_parse_options(void *s, const struct fw3_option *opts,
                                                        continue;
                                                }
                                        }
+
+                                       /* The last token was a sole "!" without any subsequent
+                                        * text, so pass it to the option parser as-is. */
+                                       if (inv && !opt->parse(dest, "!", true))
+                                       {
+                                               warn_elem(e, "has invalid value '%s'", p);
+                                               valid = false;
+                                       }
                                }
                        }
 
@@ -981,7 +1021,7 @@ fw3_parse_options(void *s, const struct fw3_option *opts,
 
 bool
 fw3_parse_blob_options(void *s, const struct fw3_option *opts,
-                  struct blob_attr *a)
+                       struct blob_attr *a, const char *name)
 {
        char *p, *v, buf[16];
        bool known;
@@ -1007,7 +1047,9 @@ fw3_parse_blob_options(void *s, const struct fw3_option *opts,
                        {
                                if (!opt->elem_size)
                                {
-                                       fprintf(stderr, "%s must not be a list\n", opt->name);
+                                       fprintf(stderr, "%s: '%s' must not be a list\n",
+                                               name, opt->name);
+
                                        valid = false;
                                }
                                else
@@ -1025,7 +1067,8 @@ fw3_parse_blob_options(void *s, const struct fw3_option *opts,
 
                                                if (!opt->parse(dest, v, true))
                                                {
-                                                       fprintf(stderr, "%s has invalid value '%s'\n", opt->name, v);
+                                                       fprintf(stderr, "%s: '%s' has invalid value '%s'\n",
+                                                               name, opt->name, v);
                                                        valid = false;
                                                        continue;
                                                }
@@ -1048,7 +1091,8 @@ fw3_parse_blob_options(void *s, const struct fw3_option *opts,
                                {
                                        if (!opt->parse((char *)s + opt->offset, v, false))
                                        {
-                                               fprintf(stderr, "%s has invalid value '%s'\n", opt->name, v);
+                                               fprintf(stderr, "%s: '%s' has invalid value '%s'\n",
+                                                       name, opt->name, v);
                                                valid = false;
                                        }
                                }
@@ -1060,7 +1104,8 @@ fw3_parse_blob_options(void *s, const struct fw3_option *opts,
                                        {
                                                if (!opt->parse(dest, p, true))
                                                {
-                                                       fprintf(stderr, "%s has invalid value '%s'\n", opt->name, p);
+                                                       fprintf(stderr, "%s: '%s' has invalid value '%s'\n",
+                                                               name, opt->name, p);
                                                        valid = false;
                                                        continue;
                                                }
@@ -1072,8 +1117,8 @@ fw3_parse_blob_options(void *s, const struct fw3_option *opts,
                        break;
                }
 
-               if (!known)
-                       fprintf(stderr, "%s is unknown\n", blobmsg_name(o));
+               if (!known && strcmp(blobmsg_name(o), "type"))
+                       fprintf(stderr, "%s: '%s' is unknown\n", name, blobmsg_name(o));
        }
 
        return valid;