ubus: assume that the service iface can be NULL

[project/mdnsd.git] / ubus.c

diff --git a/ubus.c b/ubus.c
index cf75cdcf58ab26f4b0a51846d822c11a8dade020..69912784784b80e3bb01bd233a8379a8554b8969 100644 (file)
--- a/ubus.c
+++ b/ubus.c
@@ -28,6 +28,7 @@
 
 static struct ubus_auto_conn conn;
 static struct blob_buf b;
+static struct ubus_subscriber udebug_sub;
 
 static int
 umdns_reload(struct ubus_context *ctx, struct ubus_object *obj,
@@ -83,6 +84,7 @@ umdns_browse(struct ubus_context *ctx, struct ubus_object *obj,
 
        blob_buf_init(&b, 0);
        avl_for_each_element(&services, s, avl) {
+               const char *hostname = buffer;
                char *local;
 
                snprintf(buffer, MAX_NAME_LEN, "%s", (const char *) s->avl.key);
@@ -102,10 +104,11 @@ umdns_browse(struct ubus_context *ctx, struct ubus_object *obj,
                        *local = '\0';
                c2 = blobmsg_open_table(&b, buffer);
                strncat(buffer, ".local", MAX_NAME_LEN);
-               blobmsg_add_string(&b, "iface", s->iface->name);
+               if (s->iface)
+                       blobmsg_add_string(&b, "iface", s->iface->name);
+               cache_dump_records(&b, s->entry, array, &hostname);
                if (address)
-                       cache_dump_records(&b, buffer, array);
-               cache_dump_records(&b, s->entry, array);
+                       cache_dump_records(&b, hostname, array, NULL);
                blobmsg_close_table(&b, c2);
                q = avl_next_element(s, avl);
                if (!q || avl_is_last(&services, &s->avl) || strcmp(s->avl.key, q->avl.key)) {
@@ -118,15 +121,29 @@ umdns_browse(struct ubus_context *ctx, struct ubus_object *obj,
        return UBUS_STATUS_OK;
 }
 
+enum {
+       HOSTS_ARRAY,
+       __HOSTS_MAX
+};
+static const struct blobmsg_policy hosts_policy[] = {
+       [HOSTS_ARRAY] = { "array", BLOBMSG_TYPE_BOOL }
+};
+
 static int
 umdns_hosts(struct ubus_context *ctx, struct ubus_object *obj,
                struct ubus_request_data *req, const char *method,
                struct blob_attr *msg)
 {
        struct cache_record *prev = NULL;
+       struct blob_attr *tb[__HOSTS_MAX];
        struct cache_record *r;
+       bool array = false;
        void *c;
 
+       blobmsg_parse(hosts_policy, __HOSTS_MAX, tb, blobmsg_data(msg), blobmsg_len(msg));
+       if (tb[HOSTS_ARRAY])
+               array = blobmsg_get_bool(tb[HOSTS_ARRAY]);
+
        blob_buf_init(&b, 0);
        avl_for_each_element(&records, r, avl) {
                if (r->type != TYPE_A && r->type != TYPE_AAAA)
@@ -134,7 +151,7 @@ umdns_hosts(struct ubus_context *ctx, struct ubus_object *obj,
                /* Query each domain just once */
                if (!prev || strcmp(r->record, prev->record)) {
                        c = blobmsg_open_table(&b, r->record);
-                       cache_dump_records(&b, r->record, false);
+                       cache_dump_records(&b, r->record, array, NULL);
                        blobmsg_close_table(&b, c);
                }
                prev = r;
@@ -254,7 +271,7 @@ static const struct ubus_method umdns_methods[] = {
        UBUS_METHOD("fetch", umdns_query, query_policy),
        UBUS_METHOD("browse", umdns_browse, browse_policy),
        UBUS_METHOD_NOARG("update", umdns_update),
-       UBUS_METHOD_NOARG("hosts", umdns_hosts),
+       UBUS_METHOD("hosts", umdns_hosts, hosts_policy),
        UBUS_METHOD_NOARG("reload", umdns_reload),
 };
 
@@ -268,14 +285,87 @@ static struct ubus_object umdns_object = {
        .n_methods = ARRAY_SIZE(umdns_methods),
 };
 
+static struct blob_attr *
+find_attr(struct blob_attr *attr, const char *name, enum blobmsg_type type)
+{
+       struct blobmsg_policy policy = { name, type };
+       struct blob_attr *ret;
+
+       if (!attr)
+               return NULL;
+
+       blobmsg_parse_attr(&policy, 1, &ret, attr);
+
+       return ret;
+}
+
+static void
+umdns_udebug_config_cb(struct blob_attr *data)
+{
+       enum {
+               CFG_ATTR_ENABLED,
+               __CFG_ATTR_MAX
+       };
+       static const struct blobmsg_policy policy[__CFG_ATTR_MAX] = {
+               [CFG_ATTR_ENABLED] = { "enabled", BLOBMSG_TYPE_STRING },
+       };
+       struct blob_attr *tb[__CFG_ATTR_MAX];
+       bool en;
+
+       data = find_attr(data, "service", BLOBMSG_TYPE_TABLE);
+       data = find_attr(data, "umdns", BLOBMSG_TYPE_TABLE);
+       if (!data)
+               return;
+
+       blobmsg_parse_attr(policy, __CFG_ATTR_MAX, tb, data);
+       if (!tb[CFG_ATTR_ENABLED])
+               return;
+
+       en = !!atoi(blobmsg_get_string(tb[CFG_ATTR_ENABLED]));
+       umdns_udebug_set_enabled(en);
+}
+
+static int
+umdns_udebug_notify_cb(struct ubus_context *ctx, struct ubus_object *obj,
+                       struct ubus_request_data *req, const char *method,
+                       struct blob_attr *msg)
+{
+       umdns_udebug_config_cb(msg);
+
+       return 0;
+}
+
+static void
+umdns_udebug_req_cb(struct ubus_request *req, int type, struct blob_attr *msg)
+{
+       umdns_udebug_config_cb(msg);
+}
+
+static bool
+umdns_udebug_sub_cb(struct ubus_context *ctx, struct ubus_subscriber *sub,
+                    const char *path)
+{
+       return !strcmp(path, "udebug");
+}
+
+
 static void
 ubus_connect_handler(struct ubus_context *ctx)
 {
+       uint32_t id;
        int ret;
 
        ret = ubus_add_object(ctx, &umdns_object);
        if (ret)
                fprintf(stderr, "Failed to add object: %s\n", ubus_strerror(ret));
+
+       udebug_sub.cb = umdns_udebug_notify_cb;
+       udebug_sub.new_obj_cb = umdns_udebug_sub_cb;
+       ubus_register_subscriber(&conn.ctx, &udebug_sub);
+       if (ubus_lookup_id(&conn.ctx, "udebug", &id) == 0) {
+               ubus_subscribe(&conn.ctx, &udebug_sub, id);
+               ubus_invoke(&conn.ctx, id, "get_config", NULL, umdns_udebug_req_cb, NULL, 1000);
+       }
 }
 
 void