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