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

Sources/mdnsd/cache.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 #define _GNU_SOURCE
 15 #include <sys/types.h>
 16 #include <sys/stat.h>
 17 
 18 #include <fcntl.h>
 19 #include <time.h>
 20 #include <stdio.h>
 21 #include <string.h>
 22 #include <unistd.h>
 23 #include <sys/types.h>
 24 #include <sys/socket.h>
 25 #include <netinet/in.h>
 26 #include <arpa/inet.h>
 27 #include <arpa/nameser.h>
 28 #include <resolv.h>
 29 #include <time.h>
 30 
 31 #include <libubox/usock.h>
 32 #include <libubox/uloop.h>
 33 #include <libubox/avl-cmp.h>
 34 #include <libubox/blobmsg_json.h>
 35 #include <libubox/kvlist.h>
 36 #include <libubus.h>
 37 
 38 #include "cache.h"
 39 #include "util.h"
 40 #include "dns.h"
 41 #include "interface.h"
 42 
 43 static struct uloop_timeout cache_gc;
 44 struct avl_tree services;
 45 AVL_TREE(records, avl_strcmp, true, NULL);
 46 
 47 static void
 48 cache_record_free(struct cache_record *r)
 49 {
 50         DBG(2, "%s %s\n", dns_type_string(r->type), r->record);
 51         avl_delete(&records, &r->avl);
 52         free(r);
 53 }
 54 
 55 static void
 56 cache_service_free(struct cache_service *s)
 57 {
 58         DBG(2, "%s\n", s->entry);
 59         avl_delete(&services, &s->avl);
 60         free(s);
 61 }
 62 
 63 static int
 64 cache_is_expired(time_t t, uint32_t ttl, int frac)
 65 {
 66         if (monotonic_time() - t >= ttl * frac / 100)
 67                 return 1;
 68 
 69         return 0;
 70 }
 71 
 72 static void
 73 cache_gc_timer(struct uloop_timeout *timeout)
 74 {
 75         struct cache_record *r, *p;
 76         struct cache_service *s, *t;
 77 
 78         avl_for_each_element_safe(&records, r, avl, p) {
 79                 if (!cache_is_expired(r->time, r->ttl, r->refresh))
 80                         continue;
 81                 /* Records other than A(AAA) are handled as services */
 82                 if (r->type != TYPE_A && r->type != TYPE_AAAA) {
 83                         if (cache_is_expired(r->time, r->ttl, 100))
 84                                 cache_record_free(r);
 85                         continue;
 86                 }
 87                 if (r->refresh >= 100) {
 88                         cache_record_free(r);
 89                         continue;
 90                 }
 91                 r->refresh += 50;
 92                 dns_send_question(r->iface, (struct sockaddr *)&r->from, r->record, r->type, 0);
 93         }
 94 
 95         avl_for_each_element_safe(&services, s, avl, t) {
 96                 if (!s->host)
 97                         continue;
 98                 if (!cache_is_expired(s->time, s->ttl, s->refresh))
 99                         continue;
100                 if (s->refresh >= 100) {
101                         cache_service_free(s);
102                         continue;
103                 }
104                 s->refresh += 50;
105                 dns_send_question(s->iface, NULL, s->entry, TYPE_PTR, 0);
106         }
107 
108         uloop_timeout_set(timeout, 10000);
109 }
110 
111 int
112 cache_init(void)
113 {
114         avl_init(&services, avl_strcmp, true, NULL);
115 
116         cache_gc.cb = cache_gc_timer;
117         uloop_timeout_set(&cache_gc, 10000);
118 
119         return 0;
120 }
121 
122 void cache_cleanup(struct interface *iface)
123 {
124         struct cache_record *r, *p;
125         struct cache_service *s, *t;
126 
127         avl_for_each_element_safe(&services, s, avl, t)
128                 if (!iface || iface == s->iface)
129                         cache_service_free(s);
130 
131         avl_for_each_element_safe(&records, r, avl, p)
132                 if (!iface || iface == r->iface)
133                         cache_record_free(r);
134 }
135 
136 void
137 cache_update(void)
138 {
139         struct interface *iface;
140         struct cache_service *s;
141 
142         vlist_for_each_element(&interfaces, iface, node)
143                 avl_for_each_element(&services, s, avl)
144                         dns_send_question(iface, NULL, s->entry, TYPE_PTR, 0);
145 }
146 
147 static struct cache_service*
148 cache_service(struct interface *iface, char *entry, int hlen, int ttl)
149 {
150         struct cache_service *s, *t;
151         char *entry_buf;
152         char *host_buf;
153         char *type;
154 
155         avl_for_each_element_safe(&services, s, avl, t)
156                 if (!strcmp(s->entry, entry)) {
157                         s->refresh = 50;
158                         s->time = monotonic_time();
159                         s->ttl = ttl;
160                         return s;
161                 }
162 
163         s = calloc_a(sizeof(*s),
164                 &entry_buf, strlen(entry) + 1,
165                 &host_buf, hlen ? hlen + 1 : 0);
166 
167         s->avl.key = s->entry = strcpy(entry_buf, entry);
168         s->time = monotonic_time();
169         s->ttl = ttl;
170         s->iface = iface;
171         s->refresh = 50;
172 
173         if (hlen)
174                 s->host = strncpy(host_buf, s->entry, hlen);
175 
176         type = strstr(entry_buf, "._");
177         if (type)
178                 type++;
179         if (type)
180                 s->avl.key = type;
181         avl_insert(&services, &s->avl);
182 
183         if (!hlen)
184                 dns_send_question(iface, NULL, entry, TYPE_PTR, iface->multicast);
185 
186         return s;
187 }
188 
189 static struct cache_record*
190 cache_record_find(char *record, int type, int port, int rdlength, uint8_t *rdata)
191 {
192         struct cache_record *l = avl_find_element(&records, record, l, avl);
193 
194         if (!l)
195                 return NULL;
196 
197         while (l && l->record && !strcmp(l->record, record)) {
198                 struct cache_record *r = l;
199 
200                 l = avl_next_element(l, avl);
201                 if (r->type != type)
202                         continue;
203 
204                 if (r->type == TYPE_TXT || (r->type == TYPE_SRV))
205                         return r;
206 
207                 if (r->port != port)
208                         continue;
209 
210                 if (r->rdlength != rdlength)
211                         continue;
212 
213                 if (!!r->rdata != !!rdata)
214                         continue;
215 
216                 if (!r->rdata || !rdata || memcmp(r->rdata, rdata, rdlength))
217                         continue;
218 
219                 return r;
220         }
221 
222         return NULL;
223 }
224 
225 int
226 cache_host_is_known(char *record)
227 {
228         struct cache_record *l = avl_find_element(&records, record, l, avl);
229 
230         if (!l)
231                 return 0;
232 
233         while (l && !avl_is_last(&records, &l->avl) && !strcmp(l->record, record)) {
234                 struct cache_record *r = l;
235 
236                 l = avl_next_element(l, avl);
237                 if ((r->type != TYPE_A) && (r->type != TYPE_AAAA))
238                         continue;
239                 return 1;
240         }
241 
242         return 0;
243 }
244 
245 void cache_answer(struct interface *iface, struct sockaddr *from, uint8_t *base,
246                   int blen, char *name, struct dns_answer *a, uint8_t *rdata,
247                   int flush)
248 {
249         struct dns_srv_data *dsd = (struct dns_srv_data *) rdata;
250         struct cache_record *r;
251         int port = 0, dlen = 0, tlen = 0, nlen, rdlength;
252         char *p = NULL;
253         char *name_buf;
254         void *rdata_ptr, *txt_ptr;
255         int host_len = 0;
256         static char *rdata_buffer = (char *) mdns_buf;
257         time_t now = monotonic_time();
258 
259         nlen = strlen(name);
260 
261         switch (a->type) {
262         case TYPE_PTR:
263                 if (a->rdlength < 2)
264                         return;
265 
266                 if (dn_expand(base, base + blen, rdata, rdata_buffer, MAX_DATA_LEN) < 0) {
267                         perror("process_answer/dn_expand");
268                         return;
269                 }
270 
271                 DBG(1, "A -> %s %s %s ttl:%d\n", dns_type_string(a->type), name, rdata_buffer, a->ttl);
272 
273                 rdlength = strlen(rdata_buffer);
274 
275                 if (strcmp(C_DNS_SD, name) != 0 &&
276                     nlen + 1 < rdlength && !strcmp(rdata_buffer + rdlength - nlen, name))
277                         host_len = rdlength - nlen - 1;
278 
279                 if (name[0] == '_')
280                         cache_service(iface, rdata_buffer, host_len, a->ttl);
281 
282                 dlen = strlen(rdata_buffer) + 1;
283                 rdata = (uint8_t*)rdata_buffer;
284                 break;
285 
286         case TYPE_SRV:
287                 if (a->rdlength < 8)
288                         return;
289 
290                 port = be16_to_cpu(dsd->port);
291                 memcpy(rdata_buffer, dsd, sizeof(*dsd));
292                 if (dn_expand(base, base + blen, (const uint8_t*)&dsd[1],
293                                 &rdata_buffer[sizeof(*dsd)], MAX_DATA_LEN - sizeof(*dsd)) < 0) {
294                         perror("process_answer/dn_expand");
295                         return;
296                 }
297                 dlen = sizeof(*dsd) + strlen(&rdata_buffer[sizeof(*dsd)]) + 1;
298                 rdata = (uint8_t*)rdata_buffer;
299                 break;
300 
301         case TYPE_TXT:
302                 rdlength = a->rdlength;
303                 if (rdlength <= 2)
304                         return;
305 
306                 memcpy(rdata_buffer, &rdata[1], rdlength);
307                 rdata_buffer[rdlength] = rdata_buffer[rdlength + 1] = '\0';
308                 tlen = rdlength + 1;
309                 p = &rdata_buffer[*rdata];
310 
311                 do {
312                         uint8_t v = *p;
313 
314                         *p = '\0';
315                         if (v && p + v < &rdata_buffer[rdlength])
316                                 p += v + 1;
317                 } while (*p);
318                 break;
319 
320         case TYPE_A:
321                 if (a->rdlength != 4)
322                         return;
323                 dlen = 4;
324                 break;
325 
326         case TYPE_AAAA:
327                 if (a->rdlength != 16)
328                         return;
329                 dlen = 16;
330                 break;
331 
332         default:
333                 return;
334         }
335 
336         r = cache_record_find(name, a->type, port, dlen, rdata);
337         if (r) {
338                 if (!a->ttl) {
339                         DBG(1, "D -> %s %s ttl:%d\n", dns_type_string(r->type), r->record, r->ttl);
340                         r->time = now + 1 - r->ttl;
341                         r->refresh = 100;
342                 } else {
343                         r->ttl = a->ttl;
344                         r->time = now;
345                         r->refresh = 50;
346                         DBG(1, "A -> %s %s ttl:%d\n", dns_type_string(r->type), r->record, r->ttl);
347                 }
348                 return;
349         }
350 
351         if (!a->ttl)
352                 return;
353 
354         r = calloc_a(sizeof(*r),
355                 &name_buf, strlen(name) + 1,
356                 &txt_ptr, tlen,
357                 &rdata_ptr, dlen);
358 
359         r->avl.key = r->record = strcpy(name_buf, name);
360         r->type = a->type;
361         r->ttl = a->ttl;
362         r->port = port;
363         r->rdlength = dlen;
364         r->time = now;
365         r->iface = iface;
366         if (iface->v6)
367                 memcpy(&r->from, from, sizeof(struct sockaddr_in6));
368         else
369                 memcpy(&r->from, from, sizeof(struct sockaddr_in));
370         r->refresh = 50;
371 
372         if (tlen)
373                 r->txt = memcpy(txt_ptr, rdata_buffer, tlen);
374 
375         if (dlen)
376                 r->rdata = memcpy(rdata_ptr, rdata, dlen);
377 
378         if (avl_insert(&records, &r->avl))
379                 free(r);
380         else
381                 DBG(1, "A -> %s %s ttl:%d\n", dns_type_string(r->type), r->record, r->ttl);
382 }
383 
384 void
385 cache_dump_records(struct blob_buf *buf, const char *name)
386 {
387         struct cache_record *r, *last, *next;
388         const char *txt;
389         char buffer[INET6_ADDRSTRLEN];
390 
391         last = avl_last_element(&records, last, avl);
392         for (r = avl_find_element(&records, name, r, avl); r; r = next) {
393                 switch (r->type) {
394                 case TYPE_TXT:
395                         if (r->txt && strlen(r->txt)) {
396                                 txt = r->txt;
397                                 do {
398                                         blobmsg_add_string(buf, "txt", txt);
399                                         txt = &txt[strlen(txt) + 1];
400                                 } while (*txt);
401                         }
402                         break;
403 
404                 case TYPE_SRV:
405                         if (r->port)
406                                 blobmsg_add_u32(buf, "port", r->port);
407                         break;
408 
409                 case TYPE_A:
410                         if ((r->rdlength == 4) && inet_ntop(AF_INET, r->rdata, buffer, INET6_ADDRSTRLEN))
411                                 blobmsg_add_string(buf, "ipv4", buffer);
412                         break;
413 
414                 case TYPE_AAAA:
415                         if ((r->rdlength == 16) && inet_ntop(AF_INET6, r->rdata, buffer, INET6_ADDRSTRLEN))
416                                 blobmsg_add_string(buf, "ipv6", buffer);
417                         break;
418                 }
419 
420                 if (r == last)
421                         break;
422 
423                 next = avl_next_element(r, avl);
424                 if (strcmp(r->record, next->record) != 0)
425                         break;
426         }
427 }
428 
429 void
430 cache_dump_recursive(struct blob_buf *b, const char *name, uint16_t type, struct interface *iface)
431 {
432         time_t now = monotonic_time();
433         for (struct cache_record *r = avl_find_ge_element(&records, name, r, avl);
434                         r && !strcmp(r->record, name);
435                         r = !avl_is_last(&records, &r->avl) ? avl_next_element(r, avl) : NULL) {
436                 int32_t ttl = r->ttl - (now - r->time);
437                 if (ttl <= 0 || (iface && iface->ifindex != r->iface->ifindex) ||
438                                 (type != TYPE_ANY && type != r->type))
439                         continue;
440 
441                 const char *txt;
442                 char buf[INET6_ADDRSTRLEN];
443                 void *k = blobmsg_open_table(b, NULL), *l;
444                 const struct dns_srv_data *dsd = (const struct dns_srv_data*)r->rdata;
445 
446                 blobmsg_add_string(b, "name", r->record);
447                 blobmsg_add_string(b, "type", dns_type_string(r->type));
448                 blobmsg_add_u32(b, "ttl", ttl);
449 
450                 switch (r->type) {
451                 case TYPE_TXT:
452                         if ((txt = r->txt) && strlen(txt)) {
453                                 l = blobmsg_open_array(b, "data");
454                                 do {
455                                         blobmsg_add_string(b, NULL, txt);
456                                         txt = &txt[strlen(txt) + 1];
457                                 } while (*txt);
458                                 blobmsg_close_array(b, l);
459                         }
460                         break;
461 
462                 case TYPE_SRV:
463                         if (r->rdlength > sizeof(*dsd)) {
464                                 blobmsg_add_u32(b, "priority", be16_to_cpu(dsd->priority));
465                                 blobmsg_add_u32(b, "weight", be16_to_cpu(dsd->weight));
466                                 blobmsg_add_u32(b, "port", be16_to_cpu(dsd->port));
467                                 blobmsg_add_string(b, "target", (const char*)&dsd[1]);
468                         }
469                         break;
470 
471                 case TYPE_PTR:
472                         if (r->rdlength > 0)
473                                 blobmsg_add_string(b, "target", (const char*)r->rdata);
474                         break;
475 
476                 case TYPE_A:
477                         if ((r->rdlength == 4) && inet_ntop(AF_INET, r->rdata, buf, sizeof(buf)))
478                                 blobmsg_add_string(b, "target", buf);
479                         break;
480 
481                 case TYPE_AAAA:
482                         if ((r->rdlength == 16) && inet_ntop(AF_INET6, r->rdata, buf, sizeof(buf)))
483                                 blobmsg_add_string(b, "target", buf);
484                         break;
485                 }
486 
487                 blobmsg_close_table(b, k);
488 
489 
490                 if (r->type == TYPE_PTR) {
491                         cache_dump_recursive(b, (const char*)r->rdata, TYPE_SRV, iface);
492                         cache_dump_recursive(b, (const char*)r->rdata, TYPE_TXT, iface);
493                 }
494 
495                 if (r->type == TYPE_SRV) {
496                         cache_dump_recursive(b, (const char*)&dsd[1], TYPE_A, iface);
497                         cache_dump_recursive(b, (const char*)&dsd[1], TYPE_AAAA, iface);
498                 }
499         }
500 }
501 

This page was automatically generated by LXR 0.3.1.  •  OpenWrt