• source navigation  • diff markup  • identifier search  • freetext search  • 

Sources/mdnsd/ubus.c

  1 /*
  2  * Copyright (C) 2014 John Crispin <blogic@openwrt.org>
  3  *
  4  * This program is free software; you can redistribute it and/or modify
  5  * it under the terms of the GNU Lesser General Public License version 2.1
  6  * as published by the Free Software Foundation
  7  *
  8  * This program is distributed in the hope that it will be useful,
  9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 11  * GNU General Public License for more details.
 12  */
 13 
 14 #include <sys/types.h>
 15 #include <arpa/inet.h>
 16 
 17 #include <stdio.h>
 18 
 19 #include <libubus.h>
 20 #include <libubox/vlist.h>
 21 #include <libubox/uloop.h>
 22 
 23 #include "util.h"
 24 #include "ubus.h"
 25 #include "cache.h"
 26 #include "service.h"
 27 #include "interface.h"
 28 
 29 static struct ubus_auto_conn conn;
 30 static struct blob_buf b;
 31 
 32 static int
 33 umdns_reload(struct ubus_context *ctx, struct ubus_object *obj,
 34                 struct ubus_request_data *req, const char *method,
 35                 struct blob_attr *msg)
 36 {
 37         service_init(1);
 38         return 0;
 39 }
 40 
 41 static int
 42 umdns_update(struct ubus_context *ctx, struct ubus_object *obj,
 43                 struct ubus_request_data *req, const char *method,
 44                 struct blob_attr *msg)
 45 {
 46         cache_update();
 47         return 0;
 48 }
 49 
 50 static int
 51 umdns_browse(struct ubus_context *ctx, struct ubus_object *obj,
 52                 struct ubus_request_data *req, const char *method,
 53                 struct blob_attr *msg)
 54 {
 55         struct cache_service *s, *q;
 56         char *buffer = (char *) mdns_buf;
 57         void *c1 = NULL, *c2;
 58 
 59         blob_buf_init(&b, 0);
 60         avl_for_each_element(&services, s, avl) {
 61                 char *local;
 62 
 63                 snprintf(buffer, MAX_NAME_LEN, "%s", (const char *) s->avl.key);
 64                 local = strstr(buffer, ".local");
 65                 if (local)
 66                         *local = '\0';
 67                 if (!strcmp(buffer, "_tcp") || !strcmp(buffer, "_udp"))
 68                         continue;
 69 
 70                 if (!c1) {
 71                         c1 = blobmsg_open_table(&b, buffer);
 72                 }
 73                 snprintf(buffer, MAX_NAME_LEN, "%s", s->entry);
 74                 local = strstr(buffer, "._");
 75                 if (local)
 76                         *local = '\0';
 77                 c2 = blobmsg_open_table(&b, buffer);
 78                 strncat(buffer, ".local", MAX_NAME_LEN);
 79                 cache_dump_records(&b, buffer);
 80                 cache_dump_records(&b, s->entry);
 81                 blobmsg_close_table(&b, c2);
 82                 q = avl_next_element(s, avl);
 83                 if (!q || avl_is_last(&services, &s->avl) || strcmp(s->avl.key, q->avl.key)) {
 84                         blobmsg_close_table(&b, c1);
 85                         c1 = NULL;
 86                 }
 87         }
 88         ubus_send_reply(ctx, req, b.head);
 89 
 90         return UBUS_STATUS_OK;
 91 }
 92 
 93 static int
 94 umdns_hosts(struct ubus_context *ctx, struct ubus_object *obj,
 95                 struct ubus_request_data *req, const char *method,
 96                 struct blob_attr *msg)
 97 {
 98         struct cache_record *prev = NULL;
 99         struct cache_record *r;
100         void *c;
101 
102         blob_buf_init(&b, 0);
103         avl_for_each_element(&records, r, avl) {
104                 if (r->type != TYPE_A && r->type != TYPE_AAAA)
105                         continue;
106                 /* Query each domain just once */
107                 if (!prev || strcmp(r->record, prev->record)) {
108                         c = blobmsg_open_table(&b, r->record);
109                         cache_dump_records(&b, r->record);
110                         blobmsg_close_table(&b, c);
111                 }
112                 prev = r;
113         }
114         ubus_send_reply(ctx, req, b.head);
115 
116         return UBUS_STATUS_OK;
117 }
118 
119 enum {
120         CFG_INTERFACES,
121         CFG_KEEP,
122         CFG_MAX
123 };
124 
125 static const struct blobmsg_policy config_policy[] = {
126         [CFG_INTERFACES]        = { "interfaces", BLOBMSG_TYPE_ARRAY },
127         [CFG_KEEP]              = { "keep", BLOBMSG_TYPE_BOOL },
128 };
129 
130 static int
131 umdns_set_config(struct ubus_context *ctx, struct ubus_object *obj,
132                     struct ubus_request_data *req, const char *method,
133                     struct blob_attr *msg)
134 {
135         struct blob_attr *data[CFG_MAX], *cur;
136         int rem, keep = false;
137 
138         blobmsg_parse(config_policy, CFG_MAX, data, blob_data(msg), blob_len(msg));
139         if (!data[CFG_INTERFACES])
140                 return UBUS_STATUS_INVALID_ARGUMENT;
141 
142         if (!blobmsg_check_attr_list(data[CFG_INTERFACES], BLOBMSG_TYPE_STRING))
143                 return UBUS_STATUS_INVALID_ARGUMENT;
144 
145         keep = data[CFG_KEEP] && blobmsg_get_bool(data[CFG_KEEP]);
146         if (!keep) {
147                 vlist_update(&interfaces);
148                 ubus_notify(ctx, obj, "set_config", NULL, 1000);
149         }
150 
151         blobmsg_for_each_attr(cur, data[CFG_INTERFACES], rem)
152                 interface_add(blobmsg_data(cur));
153 
154         if (!keep)
155                 vlist_flush(&interfaces);
156 
157         return 0;
158 }
159 
160 enum query_attr {
161         QUERY_QUESTION,
162         QUERY_IFACE,
163         QUERY_TYPE,
164         QUERY_MAX
165 };
166 
167 static const struct blobmsg_policy query_policy[QUERY_MAX] = {
168         [QUERY_QUESTION]= { "question", BLOBMSG_TYPE_STRING },
169         [QUERY_IFACE]   = { "interface", BLOBMSG_TYPE_STRING },
170         [QUERY_TYPE]    = { "type", BLOBMSG_TYPE_INT32 },
171 };
172 
173 static int
174 umdns_query(struct ubus_context *ctx, struct ubus_object *obj,
175                     struct ubus_request_data *req, const char *method,
176                     struct blob_attr *msg)
177 {
178         struct blob_attr *tb[QUERY_MAX], *c;
179         const char *question = C_DNS_SD;
180         const char *ifname;
181         int type = TYPE_ANY;
182 
183         blobmsg_parse(query_policy, QUERY_MAX, tb, blob_data(msg), blob_len(msg));
184 
185         if (!(c = tb[QUERY_IFACE]))
186                 return UBUS_STATUS_INVALID_ARGUMENT;
187 
188         ifname = blobmsg_get_string(c);
189 
190         if ((c = tb[QUERY_QUESTION]))
191                 question = blobmsg_get_string(c);
192 
193         if ((c = tb[QUERY_TYPE]))
194                 type = blobmsg_get_u32(c);
195 
196         struct interface *iface_v4 = interface_get(ifname, 0, 1);
197         struct interface *iface_v6 = interface_get(ifname, 1, 1);
198 
199         if (!iface_v4 && !iface_v6)
200                 return UBUS_STATUS_NOT_FOUND;
201 
202         if (!strcmp(method, "query")) {
203                 if (iface_v4)
204                         dns_send_question(iface_v4, NULL, question, type, 1);
205 
206                 if (iface_v6)
207                         dns_send_question(iface_v6, NULL, question, type, 1);
208 
209                 return UBUS_STATUS_OK;
210         } else if (!strcmp(method, "fetch")) {
211                 blob_buf_init(&b, 0);
212                 void *k = blobmsg_open_array(&b, "records");
213                 cache_dump_recursive(&b, question, type, iface_v4 ? iface_v4 : iface_v6);
214                 blobmsg_close_array(&b, k);
215                 ubus_send_reply(ctx, req, b.head);
216                 return UBUS_STATUS_OK;
217         } else {
218                 return UBUS_STATUS_INVALID_ARGUMENT;
219         }
220 }
221 
222 
223 static const struct ubus_method umdns_methods[] = {
224         UBUS_METHOD("set_config", umdns_set_config, config_policy),
225         UBUS_METHOD("query", umdns_query, query_policy),
226         UBUS_METHOD("fetch", umdns_query, query_policy),
227         UBUS_METHOD_NOARG("update", umdns_update),
228         UBUS_METHOD_NOARG("browse", umdns_browse),
229         UBUS_METHOD_NOARG("hosts", umdns_hosts),
230         UBUS_METHOD_NOARG("reload", umdns_reload),
231 };
232 
233 static struct ubus_object_type umdns_object_type =
234         UBUS_OBJECT_TYPE("umdns", umdns_methods);
235 
236 static struct ubus_object umdns_object = {
237         .name = "umdns",
238         .type = &umdns_object_type,
239         .methods = umdns_methods,
240         .n_methods = ARRAY_SIZE(umdns_methods),
241 };
242 
243 static void
244 ubus_connect_handler(struct ubus_context *ctx)
245 {
246         int ret;
247 
248         ret = ubus_add_object(ctx, &umdns_object);
249         if (ret)
250                 fprintf(stderr, "Failed to add object: %s\n", ubus_strerror(ret));
251 }
252 
253 void
254 ubus_startup(void)
255 {
256         conn.cb = ubus_connect_handler;
257         ubus_auto_connect(&conn);
258 }
259 
260 int ubus_service_list(ubus_data_handler_t cb)
261 {
262         uint32_t id;
263         int ret;
264 
265         blob_buf_init(&b, 0);
266         ret = ubus_lookup_id(&conn.ctx, "service", &id);
267         if (ret)
268                 return ret;
269 
270         return ubus_invoke(&conn.ctx, id, "list", b.head, cb, NULL, 5 * 1000);
271 }
272 

This page was automatically generated by LXR 0.3.1.  •  OpenWrt