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/nameser.h> 16 #include <sys/socket.h> 17 18 #include <resolv.h> 19 #include <glob.h> 20 #include <stdio.h> 21 #include <time.h> 22 23 #include <libubus.h> 24 #include <libubox/vlist.h> 25 #include <libubox/uloop.h> 26 #include <libubox/avl-cmp.h> 27 #include <libubox/blobmsg_json.h> 28 29 #include "ubus.h" 30 #include "dns.h" 31 #include "service.h" 32 #include "util.h" 33 #include "interface.h" 34 #include "announce.h" 35 36 enum { 37 SERVICE_INSTANCE, 38 SERVICE_SERVICE, 39 SERVICE_PORT, 40 SERVICE_TXT, 41 __SERVICE_MAX, 42 }; 43 44 struct service { 45 struct vlist_node node; 46 47 time_t t; 48 49 const char *id; 50 const char *instance; 51 const char *service; 52 const uint8_t *txt; 53 int txt_len; 54 int port; 55 int active; 56 }; 57 58 static const struct blobmsg_policy service_policy[__SERVICE_MAX] = { 59 [SERVICE_INSTANCE] = { .name = "instance", .type = BLOBMSG_TYPE_STRING }, 60 [SERVICE_SERVICE] = { .name = "service", .type = BLOBMSG_TYPE_STRING }, 61 [SERVICE_PORT] = { .name = "port", .type = BLOBMSG_TYPE_INT32 }, 62 [SERVICE_TXT] = { .name = "txt", .type = BLOBMSG_TYPE_ARRAY }, 63 }; 64 65 static void 66 service_update(struct vlist_tree *tree, struct vlist_node *node_new, 67 struct vlist_node *node_old); 68 69 static struct blob_buf b; 70 static VLIST_TREE(services, avl_strcmp, service_update, false, false); 71 static int service_init_announce; 72 73 /** 74 * service_instance_name - construct Service Instance Name as in RFC 6763 75 * 76 * RFC 6763 specifies Service Instance Names in the following way: 77 * 78 * Service Instance Name = <Instance> . <Service> . <Domain> 79 * 80 * @s: service to generate service instance name for 81 */ 82 static const char * 83 service_instance_name(struct service *s) 84 { 85 static char buffer[256]; 86 87 snprintf(buffer, sizeof(buffer), "%s.%s", s->instance, s->service); 88 89 return buffer; 90 } 91 92 static void 93 service_add_ptr(const char *host, int ttl) 94 { 95 int len = dn_comp(host, mdns_buf, sizeof(mdns_buf), NULL, NULL); 96 97 if (len < 1) 98 return; 99 100 dns_add_answer(TYPE_PTR, mdns_buf, len, ttl); 101 } 102 103 static void 104 service_add_srv(struct service *s, int ttl) 105 { 106 struct dns_srv_data *sd = (struct dns_srv_data *) mdns_buf; 107 int len = sizeof(*sd); 108 109 len += dn_comp(mdns_hostname_local, mdns_buf + len, sizeof(mdns_buf) - len, NULL, NULL); 110 if (len <= sizeof(*sd)) 111 return; 112 113 sd->port = cpu_to_be16(s->port); 114 dns_add_answer(TYPE_SRV, mdns_buf, len, ttl); 115 } 116 117 #define TOUT_LOOKUP 60 118 119 static time_t 120 service_timeout(struct service *s) 121 { 122 time_t t = monotonic_time(); 123 124 if (t - s->t <= TOUT_LOOKUP) { 125 DBG(2, "t=%lu, s->t=%lu, t - s->t = %lu\n", t, s->t, t - s->t); 126 return 0; 127 } 128 129 return t; 130 } 131 132 static void 133 service_reply_single(struct interface *iface, struct sockaddr *to, struct service *s, int ttl, int force) 134 { 135 const char *host = service_instance_name(s); 136 char *service = strstr(host, "._"); 137 time_t t = service_timeout(s); 138 139 140 if (!force && (!s->active || !service || !t)) 141 return; 142 143 service++; 144 145 s->t = t; 146 147 dns_init_answer(); 148 service_add_ptr(service_instance_name(s), ttl); 149 dns_send_answer(iface, to, service); 150 151 dns_init_answer(); 152 service_add_srv(s, ttl); 153 if (s->txt && s->txt_len) 154 dns_add_answer(TYPE_TXT, (uint8_t *) s->txt, s->txt_len, ttl); 155 dns_send_answer(iface, to, host); 156 } 157 158 void 159 service_reply(struct interface *iface, struct sockaddr *to, const char *instance, const char *service_domain, int ttl) 160 { 161 struct service *s; 162 163 vlist_for_each_element(&services, s, node) { 164 if (instance && strcmp(s->instance, instance)) 165 continue; 166 if (service_domain && strcmp(s->service, service_domain)) 167 continue; 168 service_reply_single(iface, to, s, ttl, 0); 169 } 170 } 171 172 void 173 service_announce_services(struct interface *iface, struct sockaddr *to, int ttl) 174 { 175 struct service *s; 176 177 vlist_for_each_element(&services, s, node) { 178 s->t = 0; 179 if (ttl) { 180 dns_init_answer(); 181 service_add_ptr(s->service, ttl); 182 dns_send_answer(iface, to, C_DNS_SD); 183 } 184 service_reply_single(iface, to, s, ttl, 0); 185 } 186 } 187 188 static void 189 service_update(struct vlist_tree *tree, struct vlist_node *node_new, 190 struct vlist_node *node_old) 191 { 192 struct interface *iface; 193 struct service *s; 194 195 if (!node_old) { 196 s = container_of(node_new, struct service, node); 197 if (service_init_announce) 198 vlist_for_each_element(&interfaces, iface, node) { 199 s->t = 0; 200 service_reply_single(iface, NULL, s, announce_ttl, 1); 201 } 202 return; 203 } 204 205 s = container_of(node_old, struct service, node); 206 if (!node_new && service_init_announce) 207 vlist_for_each_element(&interfaces, iface, node) 208 service_reply_single(iface, NULL, s, 0, 1); 209 free(s); 210 } 211 212 static void 213 service_load_blob(struct blob_attr *b) 214 { 215 struct blob_attr *txt, *_tb[__SERVICE_MAX]; 216 struct service *s; 217 char *d_instance, *d_service, *d_id; 218 uint8_t *d_txt; 219 int rem2; 220 int txt_len = 0; 221 222 blobmsg_parse(service_policy, ARRAY_SIZE(service_policy), 223 _tb, blobmsg_data(b), blobmsg_data_len(b)); 224 if (!_tb[SERVICE_PORT] || !_tb[SERVICE_SERVICE]) 225 return; 226 227 if (_tb[SERVICE_TXT]) 228 blobmsg_for_each_attr(txt, _tb[SERVICE_TXT], rem2) 229 txt_len += 1 + strlen(blobmsg_get_string(txt)); 230 231 s = calloc_a(sizeof(*s), 232 &d_id, strlen(blobmsg_name(b)) + 1, 233 &d_instance, _tb[SERVICE_INSTANCE] ? strlen(blobmsg_get_string(_tb[SERVICE_INSTANCE])) + 1 : 0, 234 &d_service, strlen(blobmsg_get_string(_tb[SERVICE_SERVICE])) + 1, 235 &d_txt, txt_len); 236 if (!s) 237 return; 238 239 s->port = blobmsg_get_u32(_tb[SERVICE_PORT]); 240 s->id = strcpy(d_id, blobmsg_name(b)); 241 if (_tb[SERVICE_INSTANCE]) 242 s->instance = strcpy(d_instance, blobmsg_get_string(_tb[SERVICE_INSTANCE])); 243 else 244 s->instance = umdns_host_label; 245 s->service = strcpy(d_service, blobmsg_get_string(_tb[SERVICE_SERVICE])); 246 s->active = 1; 247 s->t = 0; 248 s->txt_len = txt_len; 249 s->txt = d_txt; 250 251 if (_tb[SERVICE_TXT]) 252 blobmsg_for_each_attr(txt, _tb[SERVICE_TXT], rem2) { 253 int len = strlen(blobmsg_get_string(txt)); 254 if (!len) 255 return; 256 if (len > 0xff) 257 len = 0xff; 258 *d_txt = len; 259 d_txt++; 260 memcpy(d_txt, blobmsg_get_string(txt), len); 261 d_txt += len; 262 } 263 264 vlist_add(&services, &s->node, s->id); 265 } 266 267 static void 268 service_load(char *path) 269 { 270 struct blob_attr *cur; 271 glob_t gl; 272 int i, rem; 273 274 if (glob(path, GLOB_NOESCAPE | GLOB_MARK, NULL, &gl)) 275 return; 276 277 for (i = 0; i < gl.gl_pathc; i++) { 278 blob_buf_init(&b, 0); 279 if (blobmsg_add_json_from_file(&b, gl.gl_pathv[i])) { 280 blob_for_each_attr(cur, b.head, rem) 281 service_load_blob(cur); 282 } else { 283 fprintf(stderr, "Error reading %s JSON\n", gl.gl_pathv[i]); 284 } 285 } 286 globfree(&gl); 287 } 288 289 static void 290 service_init_cb(struct ubus_request *req, int type, struct blob_attr *msg) 291 { 292 struct blob_attr *cur; 293 int rem; 294 295 get_hostname(); 296 297 vlist_update(&services); 298 service_load("/etc/umdns/*"); 299 300 blob_for_each_attr(cur, msg, rem) { 301 struct blob_attr *cur2; 302 int rem2; 303 304 blobmsg_for_each_attr(cur2, cur, rem2) { 305 struct blob_attr *cur3; 306 int rem3; 307 308 if (strcmp(blobmsg_name(cur2), "instances")) 309 continue; 310 311 blobmsg_for_each_attr(cur3, cur2, rem3) { 312 struct blob_attr *cur4; 313 int rem4; 314 int running = 0; 315 316 blobmsg_for_each_attr(cur4, cur3, rem4) { 317 const char *name = blobmsg_name(cur4); 318 319 if (!strcmp(name, "running")) { 320 running = blobmsg_get_bool(cur4); 321 } else if (running && !strcmp(name, "data")) { 322 struct blob_attr *cur5; 323 int rem5; 324 325 blobmsg_for_each_attr(cur5, cur4, rem5) { 326 struct blob_attr *cur6; 327 int rem6; 328 329 if (strcmp(blobmsg_name(cur5), "mdns")) 330 continue; 331 332 blobmsg_for_each_attr(cur6, cur5, rem6) 333 service_load_blob(cur6); 334 } 335 break; 336 } 337 } 338 } 339 } 340 } 341 vlist_flush(&services); 342 } 343 344 void 345 service_init(int announce) 346 { 347 get_hostname(); 348 349 service_init_announce = announce; 350 ubus_service_list(service_init_cb); 351 } 352 353 void 354 service_cleanup(void) 355 { 356 vlist_flush(&services); 357 blob_buf_free(&b); 358 } 359
This page was automatically generated by LXR 0.3.1. • OpenWrt