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

Sources/mdnsd/service.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/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