ubus: fix fw3_ubus_address()
[project/firewall3.git] / ubus.c
diff --git a/ubus.c b/ubus.c
index 34e21b8..5161922 100644 (file)
--- a/ubus.c
+++ b/ubus.c
@@ -19,6 +19,7 @@
 #include "ubus.h"
 
 static struct blob_attr *interfaces = NULL;
+static struct blob_attr *procd_data;
 
 
 static void dump_cb(struct ubus_request *req, int type, struct blob_attr *msg)
@@ -31,12 +32,18 @@ static void dump_cb(struct ubus_request *req, int type, struct blob_attr *msg)
                interfaces = blob_memdup(cur);
 }
 
+static void procd_data_cb(struct ubus_request *req, int type, struct blob_attr *msg)
+{
+       procd_data = blob_memdup(msg);
+}
+
 bool
 fw3_ubus_connect(void)
 {
        bool status = false;
        uint32_t id;
        struct ubus_context *ctx = ubus_connect(NULL);
+       struct blob_buf b = { };
 
        if (!ctx)
                goto out;
@@ -49,6 +56,14 @@ fw3_ubus_connect(void)
 
        status = true;
 
+       if (ubus_lookup_id(ctx, "service", &id))
+               goto out;
+
+       blob_buf_init(&b, 0);
+       blobmsg_add_string(&b, "type", "firewall");
+       ubus_invoke(ctx, id, "get_data", b.head, procd_data_cb, NULL, 2000);
+       blob_buf_free(&b);
+
 out:
        if (ctx)
                ubus_free(ctx);
@@ -95,6 +110,9 @@ parse_subnets(struct list_head *head, enum fw3_family family,
        struct blob_attr *cur;
        struct fw3_address *addr;
 
+       if (!list)
+               return;
+
        __blob_for_each_attr(cur, list, rem)
        {
                addr = parse_subnet(family, blobmsg_data(cur), blobmsg_data_len(cur));
@@ -104,83 +122,93 @@ parse_subnets(struct list_head *head, enum fw3_family family,
        }
 }
 
-static void *
-invoke_common(const char *net, bool device)
+struct fw3_device *
+fw3_ubus_device(const char *net)
 {
+       enum {
+               DEV_INTERFACE,
+               DEV_DEVICE,
+               DEV_L3_DEVICE,
+               __DEV_MAX
+       };
+       static const struct blobmsg_policy policy[__DEV_MAX] = {
+               [DEV_INTERFACE] = { "interface", BLOBMSG_TYPE_STRING },
+               [DEV_DEVICE] = { "device", BLOBMSG_TYPE_STRING },
+               [DEV_L3_DEVICE] = { "l3_device", BLOBMSG_TYPE_STRING },
+       };
        struct fw3_device *dev = NULL;
-       struct list_head *addr = NULL;
-       struct blob_attr *c, *cur;
-       unsigned r, rem;
-       char *data;
-       bool matched;
+       struct blob_attr *tb[__DEV_MAX];
+       struct blob_attr *cur;
+       char *name = NULL;
+       int rem;
 
        if (!net || !interfaces)
                return NULL;
 
-       if (device)
-               dev = calloc(1, sizeof(*dev));
-       else
-               addr = malloc(sizeof(*addr));
-
-       if ((device && !dev) || (!device && !addr))
-               goto fail;
-
-       if (!device)
-               INIT_LIST_HEAD(addr);
-
-       blobmsg_for_each_attr(c, interfaces, r) {
-               matched = false;
-               blobmsg_for_each_attr(cur, c, rem)
-                       if (!strcmp(blobmsg_name(cur), "interface"))
-                               matched = !strcmp(blobmsg_get_string(cur), net);
-
-               if (!matched)
+       blobmsg_for_each_attr(cur, interfaces, rem) {
+               blobmsg_parse(policy, __DEV_MAX, tb, blobmsg_data(cur), blobmsg_len(cur));
+               if (!tb[DEV_INTERFACE] ||
+                   strcmp(blobmsg_data(tb[DEV_INTERFACE]), net) != 0)
                        continue;
 
-               blobmsg_for_each_attr(cur, c, rem) {
-                       data = blobmsg_data(cur);
-
-                       if (dev && !strcmp(blobmsg_name(cur), "device") && !dev->name[0])
-                               snprintf(dev->name, sizeof(dev->name), "%s", data);
-                       else if (dev && !strcmp(blobmsg_name(cur), "l3_device"))
-                               snprintf(dev->name, sizeof(dev->name), "%s", data);
-                       else if (!dev && !strcmp(blobmsg_name(cur), "ipv4-address"))
-                               parse_subnets(addr, FW3_FAMILY_V4,
-                                             blobmsg_data(cur), blobmsg_data_len(cur));
-                       else if (!dev && (!strcmp(blobmsg_name(cur), "ipv6-address") ||
-                                         !strcmp(blobmsg_name(cur), "ipv6-prefix-assignment")))
-                               parse_subnets(addr, FW3_FAMILY_V6,
-                                             blobmsg_data(cur), blobmsg_data_len(cur));
-               }
-
-               if (dev)
-                       dev->set = !!dev->name[0];
+               if (tb[DEV_L3_DEVICE])
+                       name = blobmsg_data(tb[DEV_L3_DEVICE]);
+               else if (tb[DEV_DEVICE])
+                       name = blobmsg_data(tb[DEV_DEVICE]);
+               else
+                       continue;
 
                break;
        }
 
-       if (device && dev->set)
-               return dev;
-       else if (!device && !list_empty(addr))
-               return addr;
+       if (!name)
+               return NULL;
 
-fail:
-       free(dev);
-       free(addr);
+       dev = calloc(1, sizeof(*dev));
 
-       return NULL;
-}
+       if (!dev)
+               return NULL;
 
-struct fw3_device *
-fw3_ubus_device(const char *net)
-{
-       return invoke_common(net, true);
+       snprintf(dev->name, sizeof(dev->name), "%s", name);
+       dev->set = true;
+
+       return dev;
 }
 
-struct list_head *
-fw3_ubus_address(const char *net)
+void
+fw3_ubus_address(struct list_head *list, const char *net)
 {
-       return invoke_common(net, false);
+       enum {
+               ADDR_INTERFACE,
+               ADDR_IPV4,
+               ADDR_IPV6,
+               ADDR_IPV6_PREFIX,
+               __ADDR_MAX
+       };
+       static const struct blobmsg_policy policy[__ADDR_MAX] = {
+               [ADDR_INTERFACE] = { "interface", BLOBMSG_TYPE_STRING },
+               [ADDR_IPV4] = { "ipv4-address", BLOBMSG_TYPE_ARRAY },
+               [ADDR_IPV6] = { "ipv6-address", BLOBMSG_TYPE_ARRAY },
+               [ADDR_IPV6_PREFIX] = { "ipv6-prefix-assignment", BLOBMSG_TYPE_ARRAY },
+       };
+       struct blob_attr *tb[__ADDR_MAX];
+       struct blob_attr *cur;
+       int rem;
+
+       if (!net || !interfaces)
+               return;
+
+       blobmsg_for_each_attr(cur, interfaces, rem) {
+               blobmsg_parse(policy, __ADDR_MAX, tb, blobmsg_data(cur), blobmsg_len(cur));
+
+               if (!tb[ADDR_INTERFACE] ||
+                   strcmp(blobmsg_data(tb[ADDR_INTERFACE]), net) != 0)
+                       continue;
+
+               parse_subnets(list, FW3_FAMILY_V4, blobmsg_data(tb[ADDR_IPV4]), blobmsg_data_len(tb[ADDR_IPV4]));
+               parse_subnets(list, FW3_FAMILY_V6, blobmsg_data(tb[ADDR_IPV6]), blobmsg_data_len(tb[ADDR_IPV6]));
+               parse_subnets(list, FW3_FAMILY_V6, blobmsg_data(tb[ADDR_IPV6_PREFIX]), blobmsg_data_len(tb[ADDR_IPV6_PREFIX]));
+       }
 }
 
 void
@@ -247,4 +275,28 @@ fw3_ubus_rules(struct blob_buf *b)
                        }
                }
        }
+
+       if (!procd_data)
+               return;
+
+       /* service */
+       blobmsg_for_each_attr(c, procd_data, r) {
+               if (!blobmsg_check_attr(c, true))
+                       continue;
+
+               /* instance */
+               blobmsg_for_each_attr(cur, c, rem) {
+                       if (!blobmsg_check_attr(cur, true))
+                               continue;
+
+                       /* type */
+                       blobmsg_for_each_attr(dcur, cur, drem) {
+                               if (!blobmsg_check_attr(dcur, true))
+                                       continue;
+
+                               blobmsg_for_each_attr(rule, dcur, rrem)
+                                       blobmsg_add_blob(b, rule);
+                       }
+               }
+       }
 }