ubus: fix fw3_ubus_address()
[project/firewall3.git] / ubus.c
diff --git a/ubus.c b/ubus.c
index f8b0143..5161922 100644 (file)
--- a/ubus.c
+++ b/ubus.c
 #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)
 {
+       static const struct blobmsg_policy policy = { "interface", BLOBMSG_TYPE_ARRAY };
        struct blob_attr *cur;
-       unsigned rem = blob_len(msg);
-       __blob_for_each_attr(cur, blob_data(msg), rem)
-               if (!strcmp(blobmsg_name(cur), "interface"))
-                       interfaces = blob_memdup(cur);
+
+       blobmsg_parse(&policy, 1, &cur, blob_data(msg), blob_len(msg));
+       if (cur)
+               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
@@ -36,6 +43,7 @@ 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;
@@ -48,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);
@@ -67,13 +83,10 @@ parse_subnet(enum fw3_family family, struct blob_attr *dict, int rem)
        struct blob_attr *cur;
        struct fw3_address *addr;
 
-       addr = malloc(sizeof(*addr));
-
+       addr = calloc(1, sizeof(*addr));
        if (!addr)
                return NULL;
 
-       memset(addr, 0, sizeof(*addr));
-
        addr->set = true;
        addr->family = family;
 
@@ -97,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));
@@ -106,85 +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 = malloc(sizeof(*dev));
-       else
-               addr = malloc(sizeof(*addr));
-
-       if ((device && !dev) || (!device && !addr))
-               goto fail;
-
-       if (device)
-               memset(dev, 0, sizeof(*dev));
-       else
-               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
@@ -212,3 +236,67 @@ fw3_ubus_zone_devices(struct fw3_zone *zone)
                        fw3_parse_device(&zone->networks, name, true);
        }
 }
+
+void
+fw3_ubus_rules(struct blob_buf *b)
+{
+       blob_buf_init(b, 0);
+
+       struct blob_attr *c, *cur, *dcur, *rule, *ropt;
+       unsigned r, rem, drem, rrem, orem;
+
+       blobmsg_for_each_attr(c, interfaces, r) {
+               const char *l3_device = NULL;
+               struct blob_attr *data = NULL;
+
+               blobmsg_for_each_attr(cur, c, rem) {
+                       if (!strcmp(blobmsg_name(cur), "l3_device"))
+                               l3_device = blobmsg_get_string(cur);
+                       else if (!strcmp(blobmsg_name(cur), "data"))
+                               data = cur;
+               }
+
+               if (!data || !l3_device)
+                       continue;
+
+               blobmsg_for_each_attr(dcur, data, drem) {
+                       if (strcmp(blobmsg_name(dcur), "firewall"))
+                               continue;
+
+                       blobmsg_for_each_attr(rule, dcur, rrem) {
+                               void *k = blobmsg_open_table(b, "");
+
+                               blobmsg_for_each_attr(ropt, rule, orem)
+                                       if (strcmp(blobmsg_name(ropt), "device"))
+                                               blobmsg_add_blob(b, ropt);
+
+                               blobmsg_add_string(b, "device", l3_device);
+                               blobmsg_close_table(b, k);
+                       }
+               }
+       }
+
+       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);
+                       }
+               }
+       }
+}