X-Git-Url: http://git.archive.openwrt.org/?p=project%2Fmdnsd.git;a=blobdiff_plain;f=cache.c;h=adfc8159599048fae46cf12101b92242b42f2833;hp=9c2f062590dbb4fa0a103b0d5be13aa931e76085;hb=4059fe10c18e7ea7309198741f18cf71c6afc911;hpb=be25ce4fe37ddc9c42df9558e2a13dae146dee79 diff --git a/cache.c b/cache.c index 9c2f062..adfc815 100644 --- a/cache.c +++ b/cache.c @@ -24,7 +24,6 @@ #include #include #include -#include #include #include #include @@ -39,25 +38,17 @@ #include "cache.h" #include "util.h" #include "dns.h" +#include "interface.h" static struct uloop_timeout cache_gc; -struct avl_tree records, entries, hosts; -static struct blob_buf b; - -static struct kvlist types; +struct avl_tree entries; +static AVL_TREE(records, avl_strcmp, true, NULL); static void -cache_record_free(struct cache_record *r, int rem) +cache_record_free(struct cache_record *r) { DBG(2, "%s %s\n", dns_type_string(r->type), r->record); - if (rem) - avl_delete(&records, &r->avl); - if (r->record) - free(r->record); - if (r->rdata) - free(r->rdata); - if (r->txt) - free(r->txt); + avl_delete(&records, &r->avl); free(r); } @@ -66,10 +57,6 @@ cache_entry_free(struct cache_entry *s) { DBG(2, "%s\n", s->entry); avl_delete(&entries, &s->avl); - if (s->host) - free(s->host); - if (s->entry) - free(s->entry); free(s); } @@ -90,7 +77,7 @@ cache_gc_timer(struct uloop_timeout *timeout) avl_for_each_element_safe(&records, r, avl, p) if (cache_is_expired(r->time, r->ttl)) - cache_record_free(r, 1); + cache_record_free(r); avl_for_each_element_safe(&entries, s, avl, t) { if (!s->host) @@ -102,37 +89,13 @@ cache_gc_timer(struct uloop_timeout *timeout) uloop_timeout_set(timeout, 10000); } -static void -cache_load_services(void) -{ - struct blob_attr *cur; - int rem; - - blob_buf_init(&b, 0); - - if (!blobmsg_add_json_from_file(&b, "/lib/mdns/service-types")) - return; - - blob_for_each_attr(cur, b.head, rem) - kvlist_set(&types, blobmsg_name(cur), blobmsg_get_string(cur)); -} - -char* -cache_lookup_name(const char *key) -{ - return kvlist_get(&types, key); -} - int cache_init(void) { - kvlist_init(&types, kvlist_strlen); avl_init(&entries, avl_strcmp, true, NULL); - avl_init(&records, avl_strcmp, true, NULL); cache_gc.cb = cache_gc_timer; uloop_timeout_set(&cache_gc, 10000); - cache_load_services(); return 0; } @@ -143,7 +106,7 @@ void cache_cleanup(void) struct cache_entry *s, *t; avl_for_each_element_safe(&records, r, avl, p) - cache_record_free(r, 1); + cache_record_free(r); avl_for_each_element_safe(&entries, s, avl, t) cache_entry_free(s); @@ -152,42 +115,38 @@ void cache_cleanup(void) void cache_scan(void) { + struct interface *iface; struct cache_entry *s; - avl_for_each_element(&entries, s, avl) - dns_send_question(&listener, s->entry, TYPE_PTR); -} - -static struct cache_entry* -cache_find_entry(char *entry) -{ - struct cache_entry *s; - - avl_for_each_element(&entries, s, avl) - if (!strcmp(s->entry, entry)) - return s; - return NULL; + vlist_for_each_element(&interfaces, iface, node) + avl_for_each_element(&entries, s, avl) + dns_send_question(iface, s->entry, TYPE_PTR); } static struct cache_entry* -cache_entry(struct uloop_fd *u, char *entry, int hlen, int ttl) +cache_entry(struct interface *iface, char *entry, int hlen, int ttl) { struct cache_entry *s; + char *entry_buf; + char *host_buf; char *type; - s = cache_find_entry(entry); + s = avl_find_element(&entries, entry, s, avl); if (s) return s; - s = malloc(sizeof(struct cache_entry)); - memset(s, 0, sizeof(struct cache_entry)); - s->avl.key = s->entry = strdup(entry); + s = calloc_a(sizeof(*s), + &entry_buf, strlen(entry) + 1, + &host_buf, hlen ? hlen + 1 : 0); + + s->avl.key = s->entry = strcpy(entry_buf, entry); s->time = time(NULL); s->ttl = ttl; if (hlen) - s->host = strndup(s->entry, hlen); - type = strstr(s->entry, "._"); + s->host = strncpy(host_buf, s->entry, hlen); + + type = strstr(entry_buf, "._"); if (type) type++; if (type) @@ -195,7 +154,7 @@ cache_entry(struct uloop_fd *u, char *entry, int hlen, int ttl) avl_insert(&entries, &s->avl); if (!hlen) - dns_send_question(u, entry, TYPE_PTR); + dns_send_question(iface, entry, TYPE_PTR); return s; } @@ -257,12 +216,16 @@ cache_host_is_known(char *record) } void -cache_answer(struct uloop_fd *u, uint8_t *base, int blen, char *name, struct dns_answer *a, uint8_t *rdata) +cache_answer(struct interface *iface, uint8_t *base, int blen, char *name, struct dns_answer *a, uint8_t *rdata) { struct dns_srv_data *dsd = (struct dns_srv_data *) rdata; struct cache_record *r; int port = 0, dlen = 0, tlen = 0, nlen, rdlength; char *p = NULL; + char *name_buf; + void *rdata_ptr, *txt_ptr; + int host_len = 0; + static char *rdata_buffer = (char *) mdns_buf; if (!(a->class & CLASS_IN)) return; @@ -283,15 +246,11 @@ cache_answer(struct uloop_fd *u, uint8_t *base, int blen, char *name, struct dns rdlength = strlen(rdata_buffer); - if (!strcmp(C_DNS_SD, name)) { - cache_entry(u, rdata_buffer, 0, a->ttl); - return; - } - - if ((rdlength < nlen) && (rdlength - nlen - 1 > 0)) - return; + if (strcmp(C_DNS_SD, name) != 0 && + nlen + 1 < rdlength && !strcmp(rdata_buffer + rdlength - nlen, name)) + host_len = rdlength - nlen - 1; - cache_entry(u, rdata_buffer, rdlength - nlen - 1, a->ttl); + cache_entry(iface, rdata_buffer, host_len, a->ttl); return; case TYPE_SRV: @@ -321,14 +280,14 @@ cache_answer(struct uloop_fd *u, uint8_t *base, int blen, char *name, struct dns break; case TYPE_A: - cache_entry(u, name, strlen(name), a->ttl); + cache_entry(iface, name, strlen(name), a->ttl); if (a->rdlength != 4) return; dlen = 4; break; case TYPE_AAAA: - cache_entry(u, name, strlen(name), a->ttl); + cache_entry(iface, name, strlen(name), a->ttl); if (a->rdlength != 16) return; dlen = 16; @@ -341,7 +300,7 @@ cache_answer(struct uloop_fd *u, uint8_t *base, int blen, char *name, struct dns r = cache_record_find(name, a->type, port, dlen, rdata); if (r) { if (!a->ttl) { - cache_record_free(r, 1); + cache_record_free(r); DBG(1, "D -> %s %s ttl:%d\n", dns_type_string(r->type), r->record, r->ttl); } else { r->ttl = a->ttl; @@ -353,32 +312,71 @@ cache_answer(struct uloop_fd *u, uint8_t *base, int blen, char *name, struct dns if (!a->ttl) return; - r = malloc(sizeof(struct cache_record)); - memset(r, 0, sizeof(struct cache_record)); - r->avl.key = r->record = strdup(name); + r = calloc_a(sizeof(*r), + &name_buf, strlen(name) + 1, + &txt_ptr, tlen, + &rdata_ptr, dlen); + + r->avl.key = r->record = strcpy(name_buf, name); r->type = a->type; r->ttl = a->ttl; r->port = port; r->rdlength = dlen; r->time = time(NULL); - if (tlen) { - r->txt = malloc(tlen); - if (r->txt) - memcpy(r->txt, rdata_buffer, tlen); - } + if (tlen) + r->txt = memcpy(txt_ptr, rdata_buffer, tlen); - if (dlen) { - r->rdata = malloc(dlen); - if (!r->rdata) { - cache_record_free(r, 0); - return; - } - memcpy(r->rdata, rdata, dlen); - } + if (dlen) + r->rdata = memcpy(rdata_ptr, rdata, dlen); if (avl_insert(&records, &r->avl)) - cache_record_free(r, 0); + free(r); else DBG(1, "A -> %s %s ttl:%d\n", dns_type_string(r->type), r->record, r->ttl); } + +void +cache_dump_records(struct blob_buf *buf, const char *name) +{ + struct cache_record *r, *last, *next; + const char *txt; + char buffer[INET6_ADDRSTRLEN]; + + last = avl_last_element(&records, last, avl); + for (r = avl_find_element(&records, name, r, avl); r; r = next) { + switch (r->type) { + case TYPE_TXT: + if (r->txt && strlen(r->txt)) { + txt = r->txt; + do { + blobmsg_add_string(buf, "txt", txt); + txt = &txt[strlen(txt) + 1]; + } while (*txt); + } + break; + + case TYPE_SRV: + if (r->port) + blobmsg_add_u32(buf, "port", r->port); + break; + + case TYPE_A: + if ((r->rdlength == 4) && inet_ntop(AF_INET, r->rdata, buffer, INET6_ADDRSTRLEN)) + blobmsg_add_string(buf, "ipv4", buffer); + break; + + case TYPE_AAAA: + if ((r->rdlength == 16) && inet_ntop(AF_INET6, r->rdata, buffer, INET6_ADDRSTRLEN)) + blobmsg_add_string(buf, "ipv6", buffer); + break; + } + + if (r == last) + break; + + next = avl_next_element(r, avl); + if (strcmp(r->record, next->record) != 0) + break; + } +}