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 && !avl_is_last(&records, &l->avl) && !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-1); 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