Annotation of embedaddon/dnsmasq/src/cache.c, revision 1.1
1.1 ! misho 1: /* dnsmasq is Copyright (c) 2000-2013 Simon Kelley
! 2:
! 3: This program is free software; you can redistribute it and/or modify
! 4: it under the terms of the GNU General Public License as published by
! 5: the Free Software Foundation; version 2 dated June, 1991, or
! 6: (at your option) version 3 dated 29 June, 2007.
! 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: You should have received a copy of the GNU General Public License
! 14: along with this program. If not, see <http://www.gnu.org/licenses/>.
! 15: */
! 16:
! 17: #include "dnsmasq.h"
! 18:
! 19: static struct crec *cache_head = NULL, *cache_tail = NULL, **hash_table = NULL;
! 20: #ifdef HAVE_DHCP
! 21: static struct crec *dhcp_spare = NULL;
! 22: #endif
! 23: static struct crec *new_chain = NULL;
! 24: static int cache_inserted = 0, cache_live_freed = 0, insert_error;
! 25: static union bigname *big_free = NULL;
! 26: static int bignames_left, hash_size;
! 27: static int uid = 0;
! 28: #ifdef HAVE_DNSSEC
! 29: static struct keydata *keyblock_free = NULL;
! 30: #endif
! 31:
! 32: /* type->string mapping: this is also used by the name-hash function as a mixing table. */
! 33: static const struct {
! 34: unsigned int type;
! 35: const char * const name;
! 36: } typestr[] = {
! 37: { 1, "A" },
! 38: { 2, "NS" },
! 39: { 5, "CNAME" },
! 40: { 6, "SOA" },
! 41: { 10, "NULL" },
! 42: { 11, "WKS" },
! 43: { 12, "PTR" },
! 44: { 13, "HINFO" },
! 45: { 15, "MX" },
! 46: { 16, "TXT" },
! 47: { 22, "NSAP" },
! 48: { 23, "NSAP_PTR" },
! 49: { 24, "SIG" },
! 50: { 25, "KEY" },
! 51: { 28, "AAAA" },
! 52: { 33, "SRV" },
! 53: { 35, "NAPTR" },
! 54: { 36, "KX" },
! 55: { 37, "CERT" },
! 56: { 38, "A6" },
! 57: { 39, "DNAME" },
! 58: { 41, "OPT" },
! 59: { 48, "DNSKEY" },
! 60: { 249, "TKEY" },
! 61: { 250, "TSIG" },
! 62: { 251, "IXFR" },
! 63: { 252, "AXFR" },
! 64: { 253, "MAILB" },
! 65: { 254, "MAILA" },
! 66: { 255, "ANY" }
! 67: };
! 68:
! 69: static void cache_free(struct crec *crecp);
! 70: static void cache_unlink(struct crec *crecp);
! 71: static void cache_link(struct crec *crecp);
! 72: static void rehash(int size);
! 73: static void cache_hash(struct crec *crecp);
! 74:
! 75: void cache_init(void)
! 76: {
! 77: struct crec *crecp;
! 78: int i;
! 79:
! 80: bignames_left = daemon->cachesize/10;
! 81:
! 82: if (daemon->cachesize > 0)
! 83: {
! 84: crecp = safe_malloc(daemon->cachesize*sizeof(struct crec));
! 85:
! 86: for (i=0; i < daemon->cachesize; i++, crecp++)
! 87: {
! 88: cache_link(crecp);
! 89: crecp->flags = 0;
! 90: crecp->uid = uid++;
! 91: }
! 92: }
! 93:
! 94: /* create initial hash table*/
! 95: rehash(daemon->cachesize);
! 96: }
! 97:
! 98: /* In most cases, we create the hash table once here by calling this with (hash_table == NULL)
! 99: but if the hosts file(s) are big (some people have 50000 ad-block entries), the table
! 100: will be much too small, so the hosts reading code calls rehash every 1000 addresses, to
! 101: expand the table. */
! 102: static void rehash(int size)
! 103: {
! 104: struct crec **new, **old, *p, *tmp;
! 105: int i, new_size, old_size;
! 106:
! 107: /* hash_size is a power of two. */
! 108: for (new_size = 64; new_size < size/10; new_size = new_size << 1);
! 109:
! 110: /* must succeed in getting first instance, failure later is non-fatal */
! 111: if (!hash_table)
! 112: new = safe_malloc(new_size * sizeof(struct crec *));
! 113: else if (new_size <= hash_size || !(new = whine_malloc(new_size * sizeof(struct crec *))))
! 114: return;
! 115:
! 116: for(i = 0; i < new_size; i++)
! 117: new[i] = NULL;
! 118:
! 119: old = hash_table;
! 120: old_size = hash_size;
! 121: hash_table = new;
! 122: hash_size = new_size;
! 123:
! 124: if (old)
! 125: {
! 126: for (i = 0; i < old_size; i++)
! 127: for (p = old[i]; p ; p = tmp)
! 128: {
! 129: tmp = p->hash_next;
! 130: cache_hash(p);
! 131: }
! 132: free(old);
! 133: }
! 134: }
! 135:
! 136: static struct crec **hash_bucket(char *name)
! 137: {
! 138: unsigned int c, val = 017465; /* Barker code - minimum self-correlation in cyclic shift */
! 139: const unsigned char *mix_tab = (const unsigned char*)typestr;
! 140:
! 141: while((c = (unsigned char) *name++))
! 142: {
! 143: /* don't use tolower and friends here - they may be messed up by LOCALE */
! 144: if (c >= 'A' && c <= 'Z')
! 145: c += 'a' - 'A';
! 146: val = ((val << 7) | (val >> (32 - 7))) + (mix_tab[(val + c) & 0x3F] ^ c);
! 147: }
! 148:
! 149: /* hash_size is a power of two */
! 150: return hash_table + ((val ^ (val >> 16)) & (hash_size - 1));
! 151: }
! 152:
! 153: static void cache_hash(struct crec *crecp)
! 154: {
! 155: /* maintain an invariant that all entries with F_REVERSE set
! 156: are at the start of the hash-chain and all non-reverse
! 157: immortal entries are at the end of the hash-chain.
! 158: This allows reverse searches and garbage collection to be optimised */
! 159:
! 160: struct crec **up = hash_bucket(cache_get_name(crecp));
! 161:
! 162: if (!(crecp->flags & F_REVERSE))
! 163: {
! 164: while (*up && ((*up)->flags & F_REVERSE))
! 165: up = &((*up)->hash_next);
! 166:
! 167: if (crecp->flags & F_IMMORTAL)
! 168: while (*up && !((*up)->flags & F_IMMORTAL))
! 169: up = &((*up)->hash_next);
! 170: }
! 171: crecp->hash_next = *up;
! 172: *up = crecp;
! 173: }
! 174:
! 175: static void cache_free(struct crec *crecp)
! 176: {
! 177: crecp->flags &= ~F_FORWARD;
! 178: crecp->flags &= ~F_REVERSE;
! 179: crecp->uid = uid++; /* invalidate CNAMES pointing to this. */
! 180:
! 181: if (cache_tail)
! 182: cache_tail->next = crecp;
! 183: else
! 184: cache_head = crecp;
! 185: crecp->prev = cache_tail;
! 186: crecp->next = NULL;
! 187: cache_tail = crecp;
! 188:
! 189: /* retrieve big name for further use. */
! 190: if (crecp->flags & F_BIGNAME)
! 191: {
! 192: crecp->name.bname->next = big_free;
! 193: big_free = crecp->name.bname;
! 194: crecp->flags &= ~F_BIGNAME;
! 195: }
! 196: #ifdef HAVE_DNSSEC
! 197: else if (crecp->flags & (F_DNSKEY | F_DS))
! 198: keydata_free(crecp->addr.key.keydata);
! 199: #endif
! 200: }
! 201:
! 202: /* insert a new cache entry at the head of the list (youngest entry) */
! 203: static void cache_link(struct crec *crecp)
! 204: {
! 205: if (cache_head) /* check needed for init code */
! 206: cache_head->prev = crecp;
! 207: crecp->next = cache_head;
! 208: crecp->prev = NULL;
! 209: cache_head = crecp;
! 210: if (!cache_tail)
! 211: cache_tail = crecp;
! 212: }
! 213:
! 214: /* remove an arbitrary cache entry for promotion */
! 215: static void cache_unlink (struct crec *crecp)
! 216: {
! 217: if (crecp->prev)
! 218: crecp->prev->next = crecp->next;
! 219: else
! 220: cache_head = crecp->next;
! 221:
! 222: if (crecp->next)
! 223: crecp->next->prev = crecp->prev;
! 224: else
! 225: cache_tail = crecp->prev;
! 226: }
! 227:
! 228: char *cache_get_name(struct crec *crecp)
! 229: {
! 230: if (crecp->flags & F_BIGNAME)
! 231: return crecp->name.bname->name;
! 232: else if (crecp->flags & F_NAMEP)
! 233: return crecp->name.namep;
! 234:
! 235: return crecp->name.sname;
! 236: }
! 237:
! 238: struct crec *cache_enumerate(int init)
! 239: {
! 240: static int bucket;
! 241: static struct crec *cache;
! 242:
! 243: if (init)
! 244: {
! 245: bucket = 0;
! 246: cache = NULL;
! 247: }
! 248: else if (cache && cache->hash_next)
! 249: cache = cache->hash_next;
! 250: else
! 251: {
! 252: cache = NULL;
! 253: while (bucket < hash_size)
! 254: if ((cache = hash_table[bucket++]))
! 255: break;
! 256: }
! 257:
! 258: return cache;
! 259: }
! 260:
! 261: static int is_outdated_cname_pointer(struct crec *crecp)
! 262: {
! 263: if (!(crecp->flags & F_CNAME))
! 264: return 0;
! 265:
! 266: /* NB. record may be reused as DS or DNSKEY, where uid is
! 267: overloaded for something completely different */
! 268: if (crecp->addr.cname.cache &&
! 269: (crecp->addr.cname.cache->flags & (F_IPV4 | F_IPV6 | F_CNAME)) &&
! 270: crecp->addr.cname.uid == crecp->addr.cname.cache->uid)
! 271: return 0;
! 272:
! 273: return 1;
! 274: }
! 275:
! 276: static int is_expired(time_t now, struct crec *crecp)
! 277: {
! 278: if (crecp->flags & F_IMMORTAL)
! 279: return 0;
! 280:
! 281: if (difftime(now, crecp->ttd) < 0)
! 282: return 0;
! 283:
! 284: return 1;
! 285: }
! 286:
! 287: static int cache_scan_free(char *name, struct all_addr *addr, time_t now, unsigned short flags)
! 288: {
! 289: /* Scan and remove old entries.
! 290: If (flags & F_FORWARD) then remove any forward entries for name and any expired
! 291: entries but only in the same hash bucket as name.
! 292: If (flags & F_REVERSE) then remove any reverse entries for addr and any expired
! 293: entries in the whole cache.
! 294: If (flags == 0) remove any expired entries in the whole cache.
! 295:
! 296: In the flags & F_FORWARD case, the return code is valid, and returns zero if the
! 297: name exists in the cache as a HOSTS or DHCP entry (these are never deleted)
! 298:
! 299: We take advantage of the fact that hash chains have stuff in the order <reverse>,<other>,<immortal>
! 300: so that when we hit an entry which isn't reverse and is immortal, we're done. */
! 301:
! 302: struct crec *crecp, **up;
! 303:
! 304: if (flags & F_FORWARD)
! 305: {
! 306: for (up = hash_bucket(name), crecp = *up; crecp; crecp = crecp->hash_next)
! 307: if (is_expired(now, crecp) || is_outdated_cname_pointer(crecp))
! 308: {
! 309: *up = crecp->hash_next;
! 310: if (!(crecp->flags & (F_HOSTS | F_DHCP)))
! 311: {
! 312: cache_unlink(crecp);
! 313: cache_free(crecp);
! 314: }
! 315: }
! 316: else if ((crecp->flags & F_FORWARD) &&
! 317: ((flags & crecp->flags & F_TYPE) || ((crecp->flags | flags) & F_CNAME)) &&
! 318: hostname_isequal(cache_get_name(crecp), name))
! 319: {
! 320: if (crecp->flags & (F_HOSTS | F_DHCP))
! 321: return 0;
! 322: *up = crecp->hash_next;
! 323: cache_unlink(crecp);
! 324: cache_free(crecp);
! 325: }
! 326: else
! 327: up = &crecp->hash_next;
! 328: }
! 329: else
! 330: {
! 331: int i;
! 332: #ifdef HAVE_IPV6
! 333: int addrlen = (flags & F_IPV6) ? IN6ADDRSZ : INADDRSZ;
! 334: #else
! 335: int addrlen = INADDRSZ;
! 336: #endif
! 337: for (i = 0; i < hash_size; i++)
! 338: for (crecp = hash_table[i], up = &hash_table[i];
! 339: crecp && ((crecp->flags & F_REVERSE) || !(crecp->flags & F_IMMORTAL));
! 340: crecp = crecp->hash_next)
! 341: if (is_expired(now, crecp))
! 342: {
! 343: *up = crecp->hash_next;
! 344: if (!(crecp->flags & (F_HOSTS | F_DHCP)))
! 345: {
! 346: cache_unlink(crecp);
! 347: cache_free(crecp);
! 348: }
! 349: }
! 350: else if (!(crecp->flags & (F_HOSTS | F_DHCP)) &&
! 351: (flags & crecp->flags & F_REVERSE) &&
! 352: (flags & crecp->flags & (F_IPV4 | F_IPV6)) &&
! 353: memcmp(&crecp->addr.addr, addr, addrlen) == 0)
! 354: {
! 355: *up = crecp->hash_next;
! 356: cache_unlink(crecp);
! 357: cache_free(crecp);
! 358: }
! 359: else
! 360: up = &crecp->hash_next;
! 361: }
! 362:
! 363: return 1;
! 364: }
! 365:
! 366: /* Note: The normal calling sequence is
! 367: cache_start_insert
! 368: cache_insert * n
! 369: cache_end_insert
! 370:
! 371: but an abort can cause the cache_end_insert to be missed
! 372: in which can the next cache_start_insert cleans things up. */
! 373:
! 374: void cache_start_insert(void)
! 375: {
! 376: /* Free any entries which didn't get committed during the last
! 377: insert due to error.
! 378: */
! 379: while (new_chain)
! 380: {
! 381: struct crec *tmp = new_chain->next;
! 382: cache_free(new_chain);
! 383: new_chain = tmp;
! 384: }
! 385: new_chain = NULL;
! 386: insert_error = 0;
! 387: }
! 388:
! 389: struct crec *cache_insert(char *name, struct all_addr *addr,
! 390: time_t now, unsigned long ttl, unsigned short flags)
! 391: {
! 392: struct crec *new;
! 393: union bigname *big_name = NULL;
! 394: int freed_all = flags & F_REVERSE;
! 395: int free_avail = 0;
! 396:
! 397: if (daemon->max_cache_ttl != 0 && daemon->max_cache_ttl < ttl)
! 398: ttl = daemon->max_cache_ttl;
! 399:
! 400: /* Don't log keys */
! 401: if (flags & (F_IPV4 | F_IPV6))
! 402: log_query(flags | F_UPSTREAM, name, addr, NULL);
! 403:
! 404: /* if previous insertion failed give up now. */
! 405: if (insert_error)
! 406: return NULL;
! 407:
! 408: /* First remove any expired entries and entries for the name/address we
! 409: are currently inserting. Fail is we attempt to delete a name from
! 410: /etc/hosts or DHCP. */
! 411: if (!cache_scan_free(name, addr, now, flags))
! 412: {
! 413: insert_error = 1;
! 414: return NULL;
! 415: }
! 416:
! 417: /* Now get a cache entry from the end of the LRU list */
! 418: while (1) {
! 419: if (!(new = cache_tail)) /* no entries left - cache is too small, bail */
! 420: {
! 421: insert_error = 1;
! 422: return NULL;
! 423: }
! 424:
! 425: /* End of LRU list is still in use: if we didn't scan all the hash
! 426: chains for expired entries do that now. If we already tried that
! 427: then it's time to start spilling things. */
! 428:
! 429: if (new->flags & (F_FORWARD | F_REVERSE))
! 430: {
! 431: /* If free_avail set, we believe that an entry has been freed.
! 432: Bugs have been known to make this not true, resulting in
! 433: a tight loop here. If that happens, abandon the
! 434: insert. Once in this state, all inserts will probably fail. */
! 435: if (free_avail)
! 436: {
! 437: insert_error = 1;
! 438: return NULL;
! 439: }
! 440:
! 441: if (freed_all)
! 442: {
! 443: free_avail = 1; /* Must be free space now. */
! 444: cache_scan_free(cache_get_name(new), &new->addr.addr, now, new->flags);
! 445: cache_live_freed++;
! 446: }
! 447: else
! 448: {
! 449: cache_scan_free(NULL, NULL, now, 0);
! 450: freed_all = 1;
! 451: }
! 452: continue;
! 453: }
! 454:
! 455: /* Check if we need to and can allocate extra memory for a long name.
! 456: If that fails, give up now. */
! 457: if (name && (strlen(name) > SMALLDNAME-1))
! 458: {
! 459: if (big_free)
! 460: {
! 461: big_name = big_free;
! 462: big_free = big_free->next;
! 463: }
! 464: else if (!bignames_left ||
! 465: !(big_name = (union bigname *)whine_malloc(sizeof(union bigname))))
! 466: {
! 467: insert_error = 1;
! 468: return NULL;
! 469: }
! 470: else
! 471: bignames_left--;
! 472:
! 473: }
! 474:
! 475: /* Got the rest: finally grab entry. */
! 476: cache_unlink(new);
! 477: break;
! 478: }
! 479:
! 480: new->flags = flags;
! 481: if (big_name)
! 482: {
! 483: new->name.bname = big_name;
! 484: new->flags |= F_BIGNAME;
! 485: }
! 486:
! 487: if (name)
! 488: strcpy(cache_get_name(new), name);
! 489: else
! 490: *cache_get_name(new) = 0;
! 491:
! 492: if (addr)
! 493: new->addr.addr = *addr;
! 494:
! 495: new->ttd = now + (time_t)ttl;
! 496: new->next = new_chain;
! 497: new_chain = new;
! 498:
! 499: return new;
! 500: }
! 501:
! 502: /* after end of insertion, commit the new entries */
! 503: void cache_end_insert(void)
! 504: {
! 505: if (insert_error)
! 506: return;
! 507:
! 508: while (new_chain)
! 509: {
! 510: struct crec *tmp = new_chain->next;
! 511: /* drop CNAMEs which didn't find a target. */
! 512: if (is_outdated_cname_pointer(new_chain))
! 513: cache_free(new_chain);
! 514: else
! 515: {
! 516: cache_hash(new_chain);
! 517: cache_link(new_chain);
! 518: cache_inserted++;
! 519: }
! 520: new_chain = tmp;
! 521: }
! 522: new_chain = NULL;
! 523: }
! 524:
! 525: struct crec *cache_find_by_name(struct crec *crecp, char *name, time_t now, unsigned short prot)
! 526: {
! 527: struct crec *ans;
! 528:
! 529: if (crecp) /* iterating */
! 530: ans = crecp->next;
! 531: else
! 532: {
! 533: /* first search, look for relevant entries and push to top of list
! 534: also free anything which has expired */
! 535: struct crec *next, **up, **insert = NULL, **chainp = &ans;
! 536: unsigned short ins_flags = 0;
! 537:
! 538: for (up = hash_bucket(name), crecp = *up; crecp; crecp = next)
! 539: {
! 540: next = crecp->hash_next;
! 541:
! 542: if (!is_expired(now, crecp) && !is_outdated_cname_pointer(crecp))
! 543: {
! 544: if ((crecp->flags & F_FORWARD) &&
! 545: (crecp->flags & prot) &&
! 546: hostname_isequal(cache_get_name(crecp), name))
! 547: {
! 548: if (crecp->flags & (F_HOSTS | F_DHCP))
! 549: {
! 550: *chainp = crecp;
! 551: chainp = &crecp->next;
! 552: }
! 553: else
! 554: {
! 555: cache_unlink(crecp);
! 556: cache_link(crecp);
! 557: }
! 558:
! 559: /* Move all but the first entry up the hash chain
! 560: this implements round-robin.
! 561: Make sure that re-ordering doesn't break the hash-chain
! 562: order invariants.
! 563: */
! 564: if (insert && (crecp->flags & (F_REVERSE | F_IMMORTAL)) == ins_flags)
! 565: {
! 566: *up = crecp->hash_next;
! 567: crecp->hash_next = *insert;
! 568: *insert = crecp;
! 569: insert = &crecp->hash_next;
! 570: }
! 571: else
! 572: {
! 573: if (!insert)
! 574: {
! 575: insert = up;
! 576: ins_flags = crecp->flags & (F_REVERSE | F_IMMORTAL);
! 577: }
! 578: up = &crecp->hash_next;
! 579: }
! 580: }
! 581: else
! 582: /* case : not expired, incorrect entry. */
! 583: up = &crecp->hash_next;
! 584: }
! 585: else
! 586: {
! 587: /* expired entry, free it */
! 588: *up = crecp->hash_next;
! 589: if (!(crecp->flags & (F_HOSTS | F_DHCP)))
! 590: {
! 591: cache_unlink(crecp);
! 592: cache_free(crecp);
! 593: }
! 594: }
! 595: }
! 596:
! 597: *chainp = cache_head;
! 598: }
! 599:
! 600: if (ans &&
! 601: (ans->flags & F_FORWARD) &&
! 602: (ans->flags & prot) &&
! 603: hostname_isequal(cache_get_name(ans), name))
! 604: return ans;
! 605:
! 606: return NULL;
! 607: }
! 608:
! 609: struct crec *cache_find_by_addr(struct crec *crecp, struct all_addr *addr,
! 610: time_t now, unsigned short prot)
! 611: {
! 612: struct crec *ans;
! 613: #ifdef HAVE_IPV6
! 614: int addrlen = (prot == F_IPV6) ? IN6ADDRSZ : INADDRSZ;
! 615: #else
! 616: int addrlen = INADDRSZ;
! 617: #endif
! 618:
! 619: if (crecp) /* iterating */
! 620: ans = crecp->next;
! 621: else
! 622: {
! 623: /* first search, look for relevant entries and push to top of list
! 624: also free anything which has expired. All the reverse entries are at the
! 625: start of the hash chain, so we can give up when we find the first
! 626: non-REVERSE one. */
! 627: int i;
! 628: struct crec **up, **chainp = &ans;
! 629:
! 630: for (i=0; i<hash_size; i++)
! 631: for (crecp = hash_table[i], up = &hash_table[i];
! 632: crecp && (crecp->flags & F_REVERSE);
! 633: crecp = crecp->hash_next)
! 634: if (!is_expired(now, crecp))
! 635: {
! 636: if ((crecp->flags & prot) &&
! 637: memcmp(&crecp->addr.addr, addr, addrlen) == 0)
! 638: {
! 639: if (crecp->flags & (F_HOSTS | F_DHCP))
! 640: {
! 641: *chainp = crecp;
! 642: chainp = &crecp->next;
! 643: }
! 644: else
! 645: {
! 646: cache_unlink(crecp);
! 647: cache_link(crecp);
! 648: }
! 649: }
! 650: up = &crecp->hash_next;
! 651: }
! 652: else
! 653: {
! 654: *up = crecp->hash_next;
! 655: if (!(crecp->flags & (F_HOSTS | F_DHCP)))
! 656: {
! 657: cache_unlink(crecp);
! 658: cache_free(crecp);
! 659: }
! 660: }
! 661:
! 662: *chainp = cache_head;
! 663: }
! 664:
! 665: if (ans &&
! 666: (ans->flags & F_REVERSE) &&
! 667: (ans->flags & prot) &&
! 668: memcmp(&ans->addr.addr, addr, addrlen) == 0)
! 669: return ans;
! 670:
! 671: return NULL;
! 672: }
! 673:
! 674: static void add_hosts_cname(struct crec *target)
! 675: {
! 676: struct crec *crec;
! 677: struct cname *a;
! 678:
! 679: for (a = daemon->cnames; a; a = a->next)
! 680: if (hostname_isequal(cache_get_name(target), a->target) &&
! 681: (crec = whine_malloc(sizeof(struct crec))))
! 682: {
! 683: crec->flags = F_FORWARD | F_IMMORTAL | F_NAMEP | F_HOSTS | F_CNAME;
! 684: crec->name.namep = a->alias;
! 685: crec->addr.cname.cache = target;
! 686: crec->addr.cname.uid = target->uid;
! 687: cache_hash(crec);
! 688: add_hosts_cname(crec); /* handle chains */
! 689: }
! 690: }
! 691:
! 692: static void add_hosts_entry(struct crec *cache, struct all_addr *addr, int addrlen,
! 693: int index, struct crec **rhash, int hashsz)
! 694: {
! 695: struct crec *lookup = cache_find_by_name(NULL, cache_get_name(cache), 0, cache->flags & (F_IPV4 | F_IPV6));
! 696: int i, nameexists = 0;
! 697: unsigned int j;
! 698:
! 699: /* Remove duplicates in hosts files. */
! 700: if (lookup && (lookup->flags & F_HOSTS))
! 701: {
! 702: nameexists = 1;
! 703: if (memcmp(&lookup->addr.addr, addr, addrlen) == 0)
! 704: {
! 705: free(cache);
! 706: return;
! 707: }
! 708: }
! 709:
! 710: /* Ensure there is only one address -> name mapping (first one trumps)
! 711: We do this by steam here, The entries are kept in hash chains, linked
! 712: by ->next (which is unused at this point) held in hash buckets in
! 713: the array rhash, hashed on address. Note that rhash and the values
! 714: in ->next are only valid whilst reading hosts files: the buckets are
! 715: then freed, and the ->next pointer used for other things.
! 716:
! 717: Only insert each unique address once into this hashing structure.
! 718:
! 719: This complexity avoids O(n^2) divergent CPU use whilst reading
! 720: large (10000 entry) hosts files. */
! 721:
! 722: /* hash address */
! 723: for (j = 0, i = 0; i < addrlen; i++)
! 724: j = (j*2 +((unsigned char *)addr)[i]) % hashsz;
! 725:
! 726: for (lookup = rhash[j]; lookup; lookup = lookup->next)
! 727: if ((lookup->flags & cache->flags & (F_IPV4 | F_IPV6)) &&
! 728: memcmp(&lookup->addr.addr, addr, addrlen) == 0)
! 729: {
! 730: cache->flags &= ~F_REVERSE;
! 731: break;
! 732: }
! 733:
! 734: /* maintain address hash chain, insert new unique address */
! 735: if (!lookup)
! 736: {
! 737: cache->next = rhash[j];
! 738: rhash[j] = cache;
! 739: }
! 740:
! 741: cache->uid = index;
! 742: memcpy(&cache->addr.addr, addr, addrlen);
! 743: cache_hash(cache);
! 744:
! 745: /* don't need to do alias stuff for second and subsequent addresses. */
! 746: if (!nameexists)
! 747: add_hosts_cname(cache);
! 748: }
! 749:
! 750: static int eatspace(FILE *f)
! 751: {
! 752: int c, nl = 0;
! 753:
! 754: while (1)
! 755: {
! 756: if ((c = getc(f)) == '#')
! 757: while (c != '\n' && c != EOF)
! 758: c = getc(f);
! 759:
! 760: if (c == EOF)
! 761: return 1;
! 762:
! 763: if (!isspace(c))
! 764: {
! 765: ungetc(c, f);
! 766: return nl;
! 767: }
! 768:
! 769: if (c == '\n')
! 770: nl = 1;
! 771: }
! 772: }
! 773:
! 774: static int gettok(FILE *f, char *token)
! 775: {
! 776: int c, count = 0;
! 777:
! 778: while (1)
! 779: {
! 780: if ((c = getc(f)) == EOF)
! 781: return (count == 0) ? EOF : 1;
! 782:
! 783: if (isspace(c) || c == '#')
! 784: {
! 785: ungetc(c, f);
! 786: return eatspace(f);
! 787: }
! 788:
! 789: if (count < (MAXDNAME - 1))
! 790: {
! 791: token[count++] = c;
! 792: token[count] = 0;
! 793: }
! 794: }
! 795: }
! 796:
! 797: static int read_hostsfile(char *filename, int index, int cache_size, struct crec **rhash, int hashsz)
! 798: {
! 799: FILE *f = fopen(filename, "r");
! 800: char *token = daemon->namebuff, *domain_suffix = NULL;
! 801: int addr_count = 0, name_count = cache_size, lineno = 0;
! 802: unsigned short flags = 0;
! 803: struct all_addr addr;
! 804: int atnl, addrlen = 0;
! 805:
! 806: if (!f)
! 807: {
! 808: my_syslog(LOG_ERR, _("failed to load names from %s: %s"), filename, strerror(errno));
! 809: return 0;
! 810: }
! 811:
! 812: eatspace(f);
! 813:
! 814: while ((atnl = gettok(f, token)) != EOF)
! 815: {
! 816: lineno++;
! 817:
! 818: if (inet_pton(AF_INET, token, &addr) > 0)
! 819: {
! 820: flags = F_HOSTS | F_IMMORTAL | F_FORWARD | F_REVERSE | F_IPV4;
! 821: addrlen = INADDRSZ;
! 822: domain_suffix = get_domain(addr.addr.addr4);
! 823: }
! 824: #ifdef HAVE_IPV6
! 825: else if (inet_pton(AF_INET6, token, &addr) > 0)
! 826: {
! 827: flags = F_HOSTS | F_IMMORTAL | F_FORWARD | F_REVERSE | F_IPV6;
! 828: addrlen = IN6ADDRSZ;
! 829: domain_suffix = get_domain6(&addr.addr.addr6);
! 830: }
! 831: #endif
! 832: else
! 833: {
! 834: my_syslog(LOG_ERR, _("bad address at %s line %d"), filename, lineno);
! 835: while (atnl == 0)
! 836: atnl = gettok(f, token);
! 837: continue;
! 838: }
! 839:
! 840: addr_count++;
! 841:
! 842: /* rehash every 1000 names. */
! 843: if ((name_count - cache_size) > 1000)
! 844: {
! 845: rehash(name_count);
! 846: cache_size = name_count;
! 847: }
! 848:
! 849: while (atnl == 0)
! 850: {
! 851: struct crec *cache;
! 852: int fqdn, nomem;
! 853: char *canon;
! 854:
! 855: if ((atnl = gettok(f, token)) == EOF)
! 856: break;
! 857:
! 858: fqdn = !!strchr(token, '.');
! 859:
! 860: if ((canon = canonicalise(token, &nomem)))
! 861: {
! 862: /* If set, add a version of the name with a default domain appended */
! 863: if (option_bool(OPT_EXPAND) && domain_suffix && !fqdn &&
! 864: (cache = whine_malloc(sizeof(struct crec) +
! 865: strlen(canon)+2+strlen(domain_suffix)-SMALLDNAME)))
! 866: {
! 867: strcpy(cache->name.sname, canon);
! 868: strcat(cache->name.sname, ".");
! 869: strcat(cache->name.sname, domain_suffix);
! 870: cache->flags = flags;
! 871: add_hosts_entry(cache, &addr, addrlen, index, rhash, hashsz);
! 872: name_count++;
! 873: }
! 874: if ((cache = whine_malloc(sizeof(struct crec) + strlen(canon)+1-SMALLDNAME)))
! 875: {
! 876: strcpy(cache->name.sname, canon);
! 877: cache->flags = flags;
! 878: add_hosts_entry(cache, &addr, addrlen, index, rhash, hashsz);
! 879: name_count++;
! 880: }
! 881: free(canon);
! 882:
! 883: }
! 884: else if (!nomem)
! 885: my_syslog(LOG_ERR, _("bad name at %s line %d"), filename, lineno);
! 886: }
! 887: }
! 888:
! 889: fclose(f);
! 890: rehash(name_count);
! 891:
! 892: my_syslog(LOG_INFO, _("read %s - %d addresses"), filename, addr_count);
! 893:
! 894: return name_count;
! 895: }
! 896:
! 897: void cache_reload(void)
! 898: {
! 899: struct crec *cache, **up, *tmp;
! 900: int revhashsz, i, total_size = daemon->cachesize;
! 901: struct hostsfile *ah;
! 902: struct host_record *hr;
! 903: struct name_list *nl;
! 904:
! 905: cache_inserted = cache_live_freed = 0;
! 906:
! 907: for (i=0; i<hash_size; i++)
! 908: for (cache = hash_table[i], up = &hash_table[i]; cache; cache = tmp)
! 909: {
! 910: tmp = cache->hash_next;
! 911: if (cache->flags & F_HOSTS)
! 912: {
! 913: *up = cache->hash_next;
! 914: free(cache);
! 915: }
! 916: else if (!(cache->flags & F_DHCP))
! 917: {
! 918: *up = cache->hash_next;
! 919: if (cache->flags & F_BIGNAME)
! 920: {
! 921: cache->name.bname->next = big_free;
! 922: big_free = cache->name.bname;
! 923: }
! 924: cache->flags = 0;
! 925: }
! 926: else
! 927: up = &cache->hash_next;
! 928: }
! 929:
! 930: /* borrow the packet buffer for a temporary by-address hash */
! 931: memset(daemon->packet, 0, daemon->packet_buff_sz);
! 932: revhashsz = daemon->packet_buff_sz / sizeof(struct crec *);
! 933: /* we overwrote the buffer... */
! 934: daemon->srv_save = NULL;
! 935:
! 936: /* Do host_records in config. */
! 937: for (hr = daemon->host_records; hr; hr = hr->next)
! 938: for (nl = hr->names; nl; nl = nl->next)
! 939: {
! 940: if (hr->addr.s_addr != 0 &&
! 941: (cache = whine_malloc(sizeof(struct crec))))
! 942: {
! 943: cache->name.namep = nl->name;
! 944: cache->flags = F_HOSTS | F_IMMORTAL | F_FORWARD | F_REVERSE | F_IPV4 | F_NAMEP | F_CONFIG;
! 945: add_hosts_entry(cache, (struct all_addr *)&hr->addr, INADDRSZ, 0, (struct crec **)daemon->packet, revhashsz);
! 946: }
! 947: #ifdef HAVE_IPV6
! 948: if (!IN6_IS_ADDR_UNSPECIFIED(&hr->addr6) &&
! 949: (cache = whine_malloc(sizeof(struct crec))))
! 950: {
! 951: cache->name.namep = nl->name;
! 952: cache->flags = F_HOSTS | F_IMMORTAL | F_FORWARD | F_REVERSE | F_IPV6 | F_NAMEP | F_CONFIG;
! 953: add_hosts_entry(cache, (struct all_addr *)&hr->addr6, IN6ADDRSZ, 0, (struct crec **)daemon->packet, revhashsz);
! 954: }
! 955: #endif
! 956: }
! 957:
! 958: if (option_bool(OPT_NO_HOSTS) && !daemon->addn_hosts)
! 959: {
! 960: if (daemon->cachesize > 0)
! 961: my_syslog(LOG_INFO, _("cleared cache"));
! 962: return;
! 963: }
! 964:
! 965: if (!option_bool(OPT_NO_HOSTS))
! 966: total_size = read_hostsfile(HOSTSFILE, 0, total_size, (struct crec **)daemon->packet, revhashsz);
! 967:
! 968: daemon->addn_hosts = expand_filelist(daemon->addn_hosts);
! 969: for (ah = daemon->addn_hosts; ah; ah = ah->next)
! 970: if (!(ah->flags & AH_INACTIVE))
! 971: total_size = read_hostsfile(ah->fname, ah->index, total_size, (struct crec **)daemon->packet, revhashsz);
! 972: }
! 973:
! 974: char *get_domain(struct in_addr addr)
! 975: {
! 976: struct cond_domain *c;
! 977:
! 978: for (c = daemon->cond_domain; c; c = c->next)
! 979: if (!c->is6 &&
! 980: ntohl(addr.s_addr) >= ntohl(c->start.s_addr) &&
! 981: ntohl(addr.s_addr) <= ntohl(c->end.s_addr))
! 982: return c->domain;
! 983:
! 984: return daemon->domain_suffix;
! 985: }
! 986:
! 987:
! 988: #ifdef HAVE_IPV6
! 989: char *get_domain6(struct in6_addr *addr)
! 990: {
! 991: struct cond_domain *c;
! 992:
! 993: u64 addrpart = addr6part(addr);
! 994:
! 995: for (c = daemon->cond_domain; c; c = c->next)
! 996: if (c->is6 &&
! 997: is_same_net6(addr, &c->start6, 64) &&
! 998: addrpart >= addr6part(&c->start6) &&
! 999: addrpart <= addr6part(&c->end6))
! 1000: return c->domain;
! 1001:
! 1002: return daemon->domain_suffix;
! 1003: }
! 1004: #endif
! 1005:
! 1006: #ifdef HAVE_DHCP
! 1007: struct in_addr a_record_from_hosts(char *name, time_t now)
! 1008: {
! 1009: struct crec *crecp = NULL;
! 1010: struct in_addr ret;
! 1011:
! 1012: while ((crecp = cache_find_by_name(crecp, name, now, F_IPV4)))
! 1013: if (crecp->flags & F_HOSTS)
! 1014: return *(struct in_addr *)&crecp->addr;
! 1015:
! 1016: my_syslog(MS_DHCP | LOG_WARNING, _("No IPv4 address found for %s"), name);
! 1017:
! 1018: ret.s_addr = 0;
! 1019: return ret;
! 1020: }
! 1021:
! 1022: void cache_unhash_dhcp(void)
! 1023: {
! 1024: struct crec *cache, **up;
! 1025: int i;
! 1026:
! 1027: for (i=0; i<hash_size; i++)
! 1028: for (cache = hash_table[i], up = &hash_table[i]; cache; cache = cache->hash_next)
! 1029: if (cache->flags & F_DHCP)
! 1030: {
! 1031: *up = cache->hash_next;
! 1032: cache->next = dhcp_spare;
! 1033: dhcp_spare = cache;
! 1034: }
! 1035: else
! 1036: up = &cache->hash_next;
! 1037: }
! 1038:
! 1039: static void add_dhcp_cname(struct crec *target, time_t ttd)
! 1040: {
! 1041: struct crec *aliasc;
! 1042: struct cname *a;
! 1043:
! 1044: for (a = daemon->cnames; a; a = a->next)
! 1045: if (hostname_isequal(cache_get_name(target), a->target))
! 1046: {
! 1047: if ((aliasc = dhcp_spare))
! 1048: dhcp_spare = dhcp_spare->next;
! 1049: else /* need new one */
! 1050: aliasc = whine_malloc(sizeof(struct crec));
! 1051:
! 1052: if (aliasc)
! 1053: {
! 1054: aliasc->flags = F_FORWARD | F_NAMEP | F_DHCP | F_CNAME;
! 1055: if (ttd == 0)
! 1056: aliasc->flags |= F_IMMORTAL;
! 1057: else
! 1058: aliasc->ttd = ttd;
! 1059: aliasc->name.namep = a->alias;
! 1060: aliasc->addr.cname.cache = target;
! 1061: aliasc->addr.cname.uid = target->uid;
! 1062: cache_hash(aliasc);
! 1063: add_dhcp_cname(aliasc, ttd);
! 1064: }
! 1065: }
! 1066: }
! 1067:
! 1068: void cache_add_dhcp_entry(char *host_name, int prot,
! 1069: struct all_addr *host_address, time_t ttd)
! 1070: {
! 1071: struct crec *crec = NULL, *fail_crec = NULL;
! 1072: unsigned short flags = F_IPV4;
! 1073: int in_hosts = 0;
! 1074: size_t addrlen = sizeof(struct in_addr);
! 1075:
! 1076: #ifdef HAVE_IPV6
! 1077: if (prot == AF_INET6)
! 1078: {
! 1079: flags = F_IPV6;
! 1080: addrlen = sizeof(struct in6_addr);
! 1081: }
! 1082: #endif
! 1083:
! 1084: inet_ntop(prot, host_address, daemon->addrbuff, ADDRSTRLEN);
! 1085:
! 1086: while ((crec = cache_find_by_name(crec, host_name, 0, flags | F_CNAME)))
! 1087: {
! 1088: /* check all addresses associated with name */
! 1089: if (crec->flags & F_HOSTS)
! 1090: {
! 1091: if (crec->flags & F_CNAME)
! 1092: my_syslog(MS_DHCP | LOG_WARNING,
! 1093: _("%s is a CNAME, not giving it to the DHCP lease of %s"),
! 1094: host_name, daemon->addrbuff);
! 1095: else if (memcmp(&crec->addr.addr, host_address, addrlen) == 0)
! 1096: in_hosts = 1;
! 1097: else
! 1098: fail_crec = crec;
! 1099: }
! 1100: else if (!(crec->flags & F_DHCP))
! 1101: {
! 1102: cache_scan_free(host_name, NULL, 0, crec->flags & (flags | F_CNAME | F_FORWARD));
! 1103: /* scan_free deletes all addresses associated with name */
! 1104: break;
! 1105: }
! 1106: }
! 1107:
! 1108: /* if in hosts, don't need DHCP record */
! 1109: if (in_hosts)
! 1110: return;
! 1111:
! 1112: /* Name in hosts, address doesn't match */
! 1113: if (fail_crec)
! 1114: {
! 1115: inet_ntop(prot, &fail_crec->addr.addr, daemon->namebuff, MAXDNAME);
! 1116: my_syslog(MS_DHCP | LOG_WARNING,
! 1117: _("not giving name %s to the DHCP lease of %s because "
! 1118: "the name exists in %s with address %s"),
! 1119: host_name, daemon->addrbuff,
! 1120: record_source(fail_crec->uid), daemon->namebuff);
! 1121: return;
! 1122: }
! 1123:
! 1124: if ((crec = cache_find_by_addr(NULL, (struct all_addr *)host_address, 0, flags)))
! 1125: {
! 1126: if (crec->flags & F_NEG)
! 1127: {
! 1128: flags |= F_REVERSE;
! 1129: cache_scan_free(NULL, (struct all_addr *)host_address, 0, flags);
! 1130: }
! 1131: }
! 1132: else
! 1133: flags |= F_REVERSE;
! 1134:
! 1135: if ((crec = dhcp_spare))
! 1136: dhcp_spare = dhcp_spare->next;
! 1137: else /* need new one */
! 1138: crec = whine_malloc(sizeof(struct crec));
! 1139:
! 1140: if (crec) /* malloc may fail */
! 1141: {
! 1142: crec->flags = flags | F_NAMEP | F_DHCP | F_FORWARD;
! 1143: if (ttd == 0)
! 1144: crec->flags |= F_IMMORTAL;
! 1145: else
! 1146: crec->ttd = ttd;
! 1147: crec->addr.addr = *host_address;
! 1148: crec->name.namep = host_name;
! 1149: crec->uid = uid++;
! 1150: cache_hash(crec);
! 1151:
! 1152: add_dhcp_cname(crec, ttd);
! 1153: }
! 1154: }
! 1155: #endif
! 1156:
! 1157:
! 1158: void dump_cache(time_t now)
! 1159: {
! 1160: struct server *serv, *serv1;
! 1161:
! 1162: my_syslog(LOG_INFO, _("time %lu"), (unsigned long)now);
! 1163: my_syslog(LOG_INFO, _("cache size %d, %d/%d cache insertions re-used unexpired cache entries."),
! 1164: daemon->cachesize, cache_live_freed, cache_inserted);
! 1165: my_syslog(LOG_INFO, _("queries forwarded %u, queries answered locally %u"),
! 1166: daemon->queries_forwarded, daemon->local_answer);
! 1167:
! 1168: /* sum counts from different records for same server */
! 1169: for (serv = daemon->servers; serv; serv = serv->next)
! 1170: serv->flags &= ~SERV_COUNTED;
! 1171:
! 1172: for (serv = daemon->servers; serv; serv = serv->next)
! 1173: if (!(serv->flags &
! 1174: (SERV_NO_ADDR | SERV_LITERAL_ADDRESS | SERV_COUNTED | SERV_USE_RESOLV | SERV_NO_REBIND)))
! 1175: {
! 1176: int port;
! 1177: unsigned int queries = 0, failed_queries = 0;
! 1178: for (serv1 = serv; serv1; serv1 = serv1->next)
! 1179: if (!(serv1->flags &
! 1180: (SERV_NO_ADDR | SERV_LITERAL_ADDRESS | SERV_COUNTED | SERV_USE_RESOLV | SERV_NO_REBIND)) &&
! 1181: sockaddr_isequal(&serv->addr, &serv1->addr))
! 1182: {
! 1183: serv1->flags |= SERV_COUNTED;
! 1184: queries += serv1->queries;
! 1185: failed_queries += serv1->failed_queries;
! 1186: }
! 1187: port = prettyprint_addr(&serv->addr, daemon->addrbuff);
! 1188: my_syslog(LOG_INFO, _("server %s#%d: queries sent %u, retried or failed %u"), daemon->addrbuff, port, queries, failed_queries);
! 1189: }
! 1190:
! 1191: if (option_bool(OPT_DEBUG) || option_bool(OPT_LOG))
! 1192: {
! 1193: struct crec *cache ;
! 1194: int i;
! 1195: my_syslog(LOG_INFO, "Host Address Flags Expires");
! 1196:
! 1197: for (i=0; i<hash_size; i++)
! 1198: for (cache = hash_table[i]; cache; cache = cache->hash_next)
! 1199: {
! 1200: char *a, *p = daemon->namebuff;
! 1201: p += sprintf(p, "%-40.40s ", cache_get_name(cache));
! 1202: if ((cache->flags & F_NEG) && (cache->flags & F_FORWARD))
! 1203: a = "";
! 1204: else if (cache->flags & F_CNAME)
! 1205: {
! 1206: a = "";
! 1207: if (!is_outdated_cname_pointer(cache))
! 1208: a = cache_get_name(cache->addr.cname.cache);
! 1209: }
! 1210: #ifdef HAVE_DNSSEC
! 1211: else if (cache->flags & F_DNSKEY)
! 1212: {
! 1213: a = daemon->addrbuff;
! 1214: sprintf(a, "%3u %u", cache->addr.key.algo, cache->uid);
! 1215: }
! 1216: else if (cache->flags & F_DS)
! 1217: {
! 1218: a = daemon->addrbuff;
! 1219: sprintf(a, "%5u %3u %3u %u", cache->addr.key.flags_or_keyid,
! 1220: cache->addr.key.algo, cache->addr.key.digest, cache->uid);
! 1221: }
! 1222: #endif
! 1223: else
! 1224: {
! 1225: a = daemon->addrbuff;
! 1226: if (cache->flags & F_IPV4)
! 1227: inet_ntop(AF_INET, &cache->addr.addr, a, ADDRSTRLEN);
! 1228: #ifdef HAVE_IPV6
! 1229: else if (cache->flags & F_IPV6)
! 1230: inet_ntop(AF_INET6, &cache->addr.addr, a, ADDRSTRLEN);
! 1231: #endif
! 1232: }
! 1233:
! 1234: p += sprintf(p, "%-30.30s %s%s%s%s%s%s%s%s%s%s%s%s%s ", a,
! 1235: cache->flags & F_IPV4 ? "4" : "",
! 1236: cache->flags & F_IPV6 ? "6" : "",
! 1237: cache->flags & F_DNSKEY ? "K" : "",
! 1238: cache->flags & F_DS ? "S" : "",
! 1239: cache->flags & F_CNAME ? "C" : "",
! 1240: cache->flags & F_FORWARD ? "F" : " ",
! 1241: cache->flags & F_REVERSE ? "R" : " ",
! 1242: cache->flags & F_IMMORTAL ? "I" : " ",
! 1243: cache->flags & F_DHCP ? "D" : " ",
! 1244: cache->flags & F_NEG ? "N" : " ",
! 1245: cache->flags & F_NXDOMAIN ? "X" : " ",
! 1246: cache->flags & F_HOSTS ? "H" : " ",
! 1247: cache->flags & F_DNSSECOK ? "V" : " ");
! 1248: #ifdef HAVE_BROKEN_RTC
! 1249: p += sprintf(p, "%lu", cache->flags & F_IMMORTAL ? 0: (unsigned long)(cache->ttd - now));
! 1250: #else
! 1251: p += sprintf(p, "%s", cache->flags & F_IMMORTAL ? "\n" : ctime(&(cache->ttd)));
! 1252: /* ctime includes trailing \n - eat it */
! 1253: *(p-1) = 0;
! 1254: #endif
! 1255: my_syslog(LOG_INFO, daemon->namebuff);
! 1256: }
! 1257: }
! 1258: }
! 1259:
! 1260: char *record_source(int index)
! 1261: {
! 1262: struct hostsfile *ah;
! 1263:
! 1264: if (index == 0)
! 1265: return HOSTSFILE;
! 1266:
! 1267: for (ah = daemon->addn_hosts; ah; ah = ah->next)
! 1268: if (ah->index == index)
! 1269: return ah->fname;
! 1270:
! 1271: return "<unknown>";
! 1272: }
! 1273:
! 1274: void querystr(char *desc, char *str, unsigned short type)
! 1275: {
! 1276: unsigned int i;
! 1277:
! 1278: sprintf(str, "%s[type=%d]", desc, type);
! 1279: for (i = 0; i < (sizeof(typestr)/sizeof(typestr[0])); i++)
! 1280: if (typestr[i].type == type)
! 1281: sprintf(str,"%s[%s]", desc, typestr[i].name);
! 1282: }
! 1283:
! 1284: void log_query(unsigned int flags, char *name, struct all_addr *addr, char *arg)
! 1285: {
! 1286: char *source, *dest = daemon->addrbuff;
! 1287: char *verb = "is";
! 1288:
! 1289: if (!option_bool(OPT_LOG))
! 1290: return;
! 1291:
! 1292: if (addr)
! 1293: {
! 1294: #ifdef HAVE_IPV6
! 1295: inet_ntop(flags & F_IPV4 ? AF_INET : AF_INET6,
! 1296: addr, daemon->addrbuff, ADDRSTRLEN);
! 1297: #else
! 1298: strncpy(daemon->addrbuff, inet_ntoa(addr->addr.addr4), ADDRSTRLEN);
! 1299: #endif
! 1300: }
! 1301:
! 1302: if (flags & F_REVERSE)
! 1303: {
! 1304: dest = name;
! 1305: name = daemon->addrbuff;
! 1306: }
! 1307:
! 1308: if (flags & F_NEG)
! 1309: {
! 1310: if (flags & F_NXDOMAIN)
! 1311: {
! 1312: if (flags & F_IPV4)
! 1313: dest = "NXDOMAIN-IPv4";
! 1314: else if (flags & F_IPV6)
! 1315: dest = "NXDOMAIN-IPv6";
! 1316: else
! 1317: dest = "NXDOMAIN";
! 1318: }
! 1319: else
! 1320: {
! 1321: if (flags & F_IPV4)
! 1322: dest = "NODATA-IPv4";
! 1323: else if (flags & F_IPV6)
! 1324: dest = "NODATA-IPv6";
! 1325: else
! 1326: dest = "NODATA";
! 1327: }
! 1328: }
! 1329: else if (flags & F_CNAME)
! 1330: dest = "<CNAME>";
! 1331: else if (flags & F_RRNAME)
! 1332: dest = arg;
! 1333:
! 1334: if (flags & F_CONFIG)
! 1335: source = "config";
! 1336: else if (flags & F_DHCP)
! 1337: source = "DHCP";
! 1338: else if (flags & F_HOSTS)
! 1339: source = arg;
! 1340: else if (flags & F_UPSTREAM)
! 1341: source = "reply";
! 1342: else if (flags & F_AUTH)
! 1343: source = "auth";
! 1344: else if (flags & F_SERVER)
! 1345: {
! 1346: source = "forwarded";
! 1347: verb = "to";
! 1348: }
! 1349: else if (flags & F_QUERY)
! 1350: {
! 1351: source = arg;
! 1352: verb = "from";
! 1353: }
! 1354: else
! 1355: source = "cached";
! 1356:
! 1357: if (strlen(name) == 0)
! 1358: name = ".";
! 1359:
! 1360: my_syslog(LOG_INFO, "%s %s %s %s", source, name, verb, dest);
! 1361: }
! 1362:
! 1363: #ifdef HAVE_DNSSEC
! 1364: struct keydata *keydata_alloc(char *data, size_t len)
! 1365: {
! 1366: struct keydata *block, *ret = NULL;
! 1367: struct keydata **prev = &ret;
! 1368: while (len > 0)
! 1369: {
! 1370: if (keyblock_free)
! 1371: {
! 1372: block = keyblock_free;
! 1373: keyblock_free = block->next;
! 1374: }
! 1375: else
! 1376: block = whine_malloc(sizeof(struct keydata));
! 1377:
! 1378: if (!block)
! 1379: {
! 1380: /* failed to alloc, free partial chain */
! 1381: keydata_free(ret);
! 1382: return NULL;
! 1383: }
! 1384:
! 1385: memcpy(block->key, data, len > KEYBLOCK_LEN ? KEYBLOCK_LEN : len);
! 1386: data += KEYBLOCK_LEN;
! 1387: len -= KEYBLOCK_LEN;
! 1388: *prev = block;
! 1389: prev = &block->next;
! 1390: block->next = NULL;
! 1391: }
! 1392:
! 1393: return ret;
! 1394: }
! 1395:
! 1396: void keydata_free(struct keydata *blocks)
! 1397: {
! 1398: struct keydata *tmp;
! 1399:
! 1400: if (blocks)
! 1401: {
! 1402: for (tmp = blocks; tmp->next; tmp = tmp->next);
! 1403: tmp->next = keyblock_free;
! 1404: keyblock_free = blocks;
! 1405: }
! 1406: }
! 1407: #endif
! 1408:
! 1409:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to cache.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / dnsmasq / src