src/resolv_wrapper.c

   1 /*
   2  * Copyright (c) 2014-2018 Andreas Schneider <asn@samba.org>
   3  * Copyright (c) 2014-2016 Jakub Hrozek <jakub.hrozek@posteo.se>
   4  *
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  *
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * 3. Neither the name of the author nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include "config.h"
  36
  37 #include <errno.h>
  38 #include <arpa/inet.h>
  39 #ifdef HAVE_ARPA_NAMESER_H
  40 #include <arpa/nameser.h>
  41 #endif /* HAVE_ARPA_NAMESER_H */
  42 #include <netinet/in.h>
  43 #include <sys/socket.h>
  44 #include <sys/types.h>
  45 #include <stdarg.h>
  46 #include <stdlib.h>
  47 #include <stdio.h>
  48 #include <stdbool.h>
  49 #include <string.h>
  50 #include <unistd.h>
  51 #include <ctype.h>
  52
  53 #include <resolv.h>
  54
  55 #if defined(HAVE_RES_STATE_U_EXT_NSADDRS) || defined(HAVE_RES_SOCKADDR_UNION_SIN6)
  56 #define HAVE_RESOLV_IPV6_NSADDRS 1
  57 #endif
  58
  59 /* GCC has printf type attribute check. */
  60 #ifdef HAVE_ATTRIBUTE_PRINTF_FORMAT
  61 #define PRINTF_ATTRIBUTE(a,b) __attribute__ ((__format__ (__printf__, a, b)))
  62 #else
  63 #define PRINTF_ATTRIBUTE(a,b)
  64 #endif /* HAVE_ATTRIBUTE_PRINTF_FORMAT */
  65
  66 #ifdef HAVE_DESTRUCTOR_ATTRIBUTE
  67 #define DESTRUCTOR_ATTRIBUTE __attribute__ ((destructor))
  68 #else
  69 #define DESTRUCTOR_ATTRIBUTE
  70 #endif /* HAVE_DESTRUCTOR_ATTRIBUTE */
  71
  72 #ifndef RWRAP_DEFAULT_FAKE_TTL
  73 #define RWRAP_DEFAULT_FAKE_TTL 600
  74 #endif  /* RWRAP_DEFAULT_FAKE_TTL */
  75
  76 #ifndef HAVE_NS_NAME_COMPRESS
  77 #define ns_name_compress dn_comp
  78 #endif
  79
  80 #define ns_t_uri 256
  81
  82 enum rwrap_dbglvl_e {
  83         RWRAP_LOG_ERROR = 0,
  84         RWRAP_LOG_WARN,
  85         RWRAP_LOG_NOTICE,
  86         RWRAP_LOG_DEBUG,
  87         RWRAP_LOG_TRACE
  88 };
  89
  90 #ifndef HAVE_GETPROGNAME
  91 static const char *getprogname(void)
  92 {
  93 #if defined(HAVE_PROGRAM_INVOCATION_SHORT_NAME)
  94         return program_invocation_short_name;
  95 #elif defined(HAVE_GETEXECNAME)
  96         return getexecname();
  97 #else
  98         return NULL;
  99 #endif /* HAVE_PROGRAM_INVOCATION_SHORT_NAME */
 100 }
 101 #endif /* HAVE_GETPROGNAME */
 102
 103 static void rwrap_log(enum rwrap_dbglvl_e dbglvl, const char *func, const char *format, ...) PRINTF_ATTRIBUTE(3, 4);
 104 # define RWRAP_LOG(dbglvl, ...) rwrap_log((dbglvl), __func__, __VA_ARGS__)
 105
 106 static void rwrap_log(enum rwrap_dbglvl_e dbglvl,
 107                       const char *func,
 108                       const char *format, ...)
 109 {
 110         char buffer[1024];
 111         va_list va;
 112         const char *d;
 113         unsigned int lvl = 0;
 114         const char *prefix = NULL;
 115         const char *progname = NULL;
 116
 117         d = getenv("RESOLV_WRAPPER_DEBUGLEVEL");
 118         if (d != NULL) {
 119                 lvl = atoi(d);
 120         }
 121
 122         if (lvl < dbglvl) {
 123                 return;
 124         }
 125
 126         va_start(va, format);
 127         vsnprintf(buffer, sizeof(buffer), format, va);
 128         va_end(va);
 129
 130         switch (dbglvl) {
 131                 case RWRAP_LOG_ERROR:
 132                         prefix = "RWRAP_ERROR";
 133                         break;
 134                 case RWRAP_LOG_WARN:
 135                         prefix = "RWRAP_WARN";
 136                         break;
 137                 case RWRAP_LOG_NOTICE:
 138                         prefix = "RWRAP_NOTICE";
 139                         break;
 140                 case RWRAP_LOG_DEBUG:
 141                         prefix = "RWRAP_DEBUG";
 142                         break;
 143                 case RWRAP_LOG_TRACE:
 144                         prefix = "RWRAP_TRACE";
 145                         break;
 146         }
 147
 148         progname = getprogname();
 149         if (progname == NULL) {
 150                 progname = "<unknown>";
 151         }
 152
 153         fprintf(stderr,
 154                 "%s[%s (%u)] - %s: %s\n",
 155                 prefix,
 156                 progname,
 157                 (unsigned int)getpid(),
 158                 func,
 159                 buffer);
 160 }
 161
 162 #ifndef SAFE_FREE
 163 #define SAFE_FREE(x) do { if ((x) != NULL) {free(x); (x)=NULL;} } while(0)
 164 #endif
 165
 166 #define NEXT_KEY(buf, key) do {                                 \
 167         (key) = (buf) ? strpbrk((buf), " \t") : NULL;           \
 168         if ((key) != NULL) {                                    \
 169                 (key)[0] = '\0';                                \
 170                 (key)++;                                        \
 171         }                                                       \
 172         while ((key) != NULL                                    \
 173                && (isblank((int)(key)[0]))) {                   \
 174                 (key)++;                                        \
 175         }                                                       \
 176 } while(0);
 177
 178 #define RWRAP_MAX_RECURSION 64
 179
 180 union rwrap_sockaddr {
 181         struct sockaddr sa;
 182         struct sockaddr_in in;
 183         struct sockaddr_in6 in6;
 184 };
 185
 186 /* Priority and weight can be omitted from the hosts file, but need to be part
 187  * of the output
 188  */
 189 #define DFL_SRV_PRIO    1
 190 #define DFL_SRV_WEIGHT  100
 191 #define DFL_URI_PRIO    1
 192 #define DFL_URI_WEIGHT  100
 193
 194 struct rwrap_srv_rrdata {
 195         uint16_t port;
 196         uint16_t prio;
 197         uint16_t weight;
 198         char hostname[MAXDNAME];
 199 };
 200
 201 struct rwrap_uri_rrdata {
 202         uint16_t prio;
 203         uint16_t weight;
 204         char uri[MAXDNAME];
 205 };
 206
 207 struct rwrap_soa_rrdata {
 208         uint32_t serial;
 209         uint32_t refresh;
 210         uint32_t retry;
 211         uint32_t expire;
 212         uint32_t minimum;
 213         char nameserver[MAXDNAME];
 214         char mailbox[MAXDNAME];
 215 };
 216
 217 struct rwrap_fake_rr {
 218         union fake_rrdata {
 219                 struct in_addr a_rec;
 220                 struct in6_addr aaaa_rec;
 221                 struct rwrap_srv_rrdata srv_rec;
 222                 struct rwrap_uri_rrdata uri_rec;
 223                 struct rwrap_soa_rrdata soa_rec;
 224                 char cname_rec[MAXDNAME];
 225                 char ptr_rec[MAXDNAME];
 226                 char txt_rec[MAXDNAME];
 227         } rrdata;
 228
 229         char key[MAXDNAME];
 230         int type; /* ns_t_* */
 231 };
 232
 233 static void rwrap_fake_rr_init(struct rwrap_fake_rr *rr, size_t len)
 234 {
 235         size_t i;
 236
 237         for (i = 0; i < len; i++) {
 238                 rr[i].type = ns_t_invalid;
 239         }
 240 }
 241
 242 static int rwrap_create_fake_a_rr(const char *key,
 243                                   const char *value,
 244                                   struct rwrap_fake_rr *rr)
 245 {
 246         int ok;
 247
 248         ok = inet_pton(AF_INET, value, &rr->rrdata.a_rec);
 249         if (!ok) {
 250                 RWRAP_LOG(RWRAP_LOG_ERROR,
 251                           "Failed to convert [%s] to binary\n", value);
 252                 return -1;
 253         }
 254
 255         memcpy(rr->key, key, strlen(key) + 1);
 256         rr->type = ns_t_a;
 257         return 0;
 258 }
 259
 260 static int rwrap_create_fake_aaaa_rr(const char *key,
 261                                      const char *value,
 262                                      struct rwrap_fake_rr *rr)
 263 {
 264         int ok;
 265
 266         ok = inet_pton(AF_INET6, value, &rr->rrdata.aaaa_rec);
 267         if (!ok) {
 268                 RWRAP_LOG(RWRAP_LOG_ERROR,
 269                           "Failed to convert [%s] to binary\n", value);
 270                 return -1;
 271         }
 272
 273         memcpy(rr->key, key, strlen(key) + 1);
 274         rr->type = ns_t_aaaa;
 275         return 0;
 276 }
 277 static int rwrap_create_fake_ns_rr(const char *key,
 278                                    const char *value,
 279                                    struct rwrap_fake_rr *rr)
 280 {
 281         memcpy(rr->rrdata.srv_rec.hostname, value, strlen(value) + 1);
 282         memcpy(rr->key, key, strlen(key) + 1);
 283         rr->type = ns_t_ns;
 284         return 0;
 285 }
 286
 287 static int rwrap_create_fake_srv_rr(const char *key,
 288                                     const char *value,
 289                                     struct rwrap_fake_rr *rr)
 290 {
 291         char *str_prio;
 292         char *str_weight;
 293         char *str_port;
 294         const char *hostname;
 295
 296         /* parse the value into priority, weight, port and hostname
 297          * and check the validity */
 298         hostname = value;
 299         NEXT_KEY(hostname, str_port);
 300         NEXT_KEY(str_port, str_prio);
 301         NEXT_KEY(str_prio, str_weight);
 302         if (str_port == NULL || hostname == NULL) {
 303                 RWRAP_LOG(RWRAP_LOG_ERROR,
 304                           "Malformed SRV entry [%s]\n", value);
 305                 return -1;
 306         }
 307
 308         if (str_prio) {
 309                 rr->rrdata.srv_rec.prio = atoi(str_prio);
 310         } else {
 311                 rr->rrdata.srv_rec.prio = DFL_SRV_PRIO;
 312         }
 313         if (str_weight) {
 314                 rr->rrdata.srv_rec.weight = atoi(str_weight);
 315         } else {
 316                 rr->rrdata.srv_rec.weight = DFL_SRV_WEIGHT;
 317         }
 318         rr->rrdata.srv_rec.port = atoi(str_port);
 319         memcpy(rr->rrdata.srv_rec.hostname , hostname, strlen(hostname) + 1);
 320
 321         memcpy(rr->key, key, strlen(key) + 1);
 322         rr->type = ns_t_srv;
 323         return 0;
 324 }
 325
 326 static int rwrap_create_fake_uri_rr(const char *key,
 327                                     const char *value,
 328                                     struct rwrap_fake_rr *rr)
 329 {
 330         char *str_prio;
 331         char *str_weight;
 332         const char *uri;
 333
 334         /* parse the value into priority, weight, and uri
 335          * and check the validity */
 336         uri = value;
 337         NEXT_KEY(uri, str_prio);
 338         NEXT_KEY(str_prio, str_weight);
 339         if (uri == NULL) {
 340                 RWRAP_LOG(RWRAP_LOG_ERROR,
 341                           "Malformed URI entry [<null>]\n");
 342                 return -1;
 343         }
 344
 345         if (str_prio) {
 346                 rr->rrdata.uri_rec.prio = atoi(str_prio);
 347         } else {
 348                 rr->rrdata.uri_rec.prio = DFL_URI_PRIO;
 349         }
 350         if (str_weight) {
 351                 rr->rrdata.uri_rec.weight = atoi(str_weight);
 352         } else {
 353                 rr->rrdata.uri_rec.weight = DFL_URI_WEIGHT;
 354         }
 355         memcpy(rr->rrdata.uri_rec.uri, uri, strlen(uri) + 1);
 356
 357         memcpy(rr->key, key, strlen(key) + 1);
 358         rr->type = ns_t_uri;
 359         return 0;
 360 }
 361
 362 static int rwrap_create_fake_txt_rr(const char *key,
 363                                     const char *value,
 364                                     struct rwrap_fake_rr *rr)
 365 {
 366         memcpy(rr->rrdata.txt_rec, value, strlen(value) + 1);
 367
 368         memcpy(rr->key, key, strlen(key) + 1);
 369         rr->type = ns_t_txt;
 370         return 0;
 371 }
 372
 373 static int rwrap_create_fake_soa_rr(const char *key,
 374                                     const char *value,
 375                                     struct rwrap_fake_rr *rr)
 376 {
 377         const char *nameserver;
 378         char *mailbox;
 379         char *str_serial;
 380         char *str_refresh;
 381         char *str_retry;
 382         char *str_expire;
 383         char *str_minimum;
 384
 385         /* parse the value into nameserver, mailbox, serial, refresh,
 386          * retry, expire, minimum and check the validity
 387          */
 388         nameserver = value;
 389         NEXT_KEY(nameserver, mailbox);
 390         NEXT_KEY(mailbox, str_serial);
 391         NEXT_KEY(str_serial, str_refresh);
 392         NEXT_KEY(str_refresh, str_retry);
 393         NEXT_KEY(str_retry, str_expire);
 394         NEXT_KEY(str_expire, str_minimum);
 395         if (nameserver == NULL || mailbox == NULL || str_serial == NULL ||
 396             str_refresh == NULL || str_retry == NULL || str_expire == NULL ||
 397             str_minimum == NULL) {
 398                 RWRAP_LOG(RWRAP_LOG_ERROR,
 399                           "Malformed SOA entry [%s]\n", value);
 400                 return -1;
 401         }
 402
 403         memcpy(rr->rrdata.soa_rec.nameserver, nameserver, strlen(nameserver)+1);
 404         memcpy(rr->rrdata.soa_rec.mailbox, mailbox, strlen(mailbox)+1);
 405
 406         rr->rrdata.soa_rec.serial = atoi(str_serial);
 407         rr->rrdata.soa_rec.refresh = atoi(str_refresh);
 408         rr->rrdata.soa_rec.retry = atoi(str_retry);
 409         rr->rrdata.soa_rec.expire = atoi(str_expire);
 410         rr->rrdata.soa_rec.minimum = atoi(str_minimum);
 411
 412         memcpy(rr->key, key, strlen(key) + 1);
 413         rr->type = ns_t_soa;
 414         return 0;
 415 }
 416
 417 static int rwrap_create_fake_cname_rr(const char *key,
 418                                       const char *value,
 419                                       struct rwrap_fake_rr *rr)
 420 {
 421         memcpy(rr->rrdata.cname_rec , value, strlen(value) + 1);
 422         memcpy(rr->key, key, strlen(key) + 1);
 423         rr->type = ns_t_cname;
 424         return 0;
 425 }
 426
 427 static int rwrap_create_fake_ptr_rr(const char *key,
 428                                     const char *value,
 429                                     struct rwrap_fake_rr *rr)
 430 {
 431         memcpy(rr->rrdata.ptr_rec , value, strlen(value) + 1);
 432         memcpy(rr->key, key, strlen(key) + 1);
 433         rr->type = ns_t_ptr;
 434         return 0;
 435 }
 436
 437 #define rwrap_randomid() 0xffff & getpid()
 438
 439 /* Prepares a fake header with a single response. Advances header_blob */
 440 static ssize_t rwrap_fake_header(uint8_t **header_blob, size_t remaining,
 441                                  size_t ancount, size_t arcount)
 442 {
 443         union {
 444                 uint8_t *blob;
 445                 HEADER *header;
 446         } h;
 447
 448         if (remaining < NS_HFIXEDSZ) {
 449                 RWRAP_LOG(RWRAP_LOG_ERROR, "Buffer too small!\n");
 450                 return -1;
 451         }
 452
 453         h.blob = *header_blob;
 454         memset(h.blob, 0, NS_HFIXEDSZ);
 455
 456         h.header->id = rwrap_randomid();        /* random query ID */
 457         h.header->qr = 1;                       /* response flag */
 458         h.header->rd = 1;                       /* recursion desired */
 459         h.header->ra = 1;                       /* recursion available */
 460
 461         h.header->qdcount = htons(1);           /* no. of questions */
 462         h.header->ancount = htons(ancount);     /* no. of answers */
 463         h.header->arcount = htons(arcount);     /* no. of add'tl records */
 464
 465         /* move past the header */
 466         *header_blob = h.blob += NS_HFIXEDSZ;
 467
 468         return NS_HFIXEDSZ;
 469 }
 470
 471 static ssize_t rwrap_fake_question(const char *question,
 472                                    uint16_t type,
 473                                    uint8_t **question_ptr,
 474                                    size_t remaining)
 475 {
 476         uint8_t *qb = *question_ptr;
 477         int n;
 478
 479         n = ns_name_compress(question, qb, remaining, NULL, NULL);
 480         if (n < 0) {
 481                 RWRAP_LOG(RWRAP_LOG_ERROR,
 482                           "Failed to compress [%s]\n", question);
 483                 return -1;
 484         }
 485
 486         qb += n;
 487         remaining -= n;
 488
 489         if (remaining < 2 * sizeof(uint16_t)) {
 490                 RWRAP_LOG(RWRAP_LOG_ERROR, "Buffer too small!\n");
 491                 return -1;
 492         }
 493
 494         NS_PUT16(type, qb);
 495         NS_PUT16(ns_c_in, qb);
 496
 497         *question_ptr = qb;
 498         return n + 2 * sizeof(uint16_t);
 499 }
 500
 501 static ssize_t rwrap_fake_rdata_common(uint16_t type,
 502                                        size_t rdata_size,
 503                                        const char *key,
 504                                        size_t remaining,
 505                                        uint8_t **rdata_ptr)
 506 {
 507         uint8_t *rd = *rdata_ptr;
 508         ssize_t written = 0;
 509
 510         written = ns_name_compress(key, rd, remaining, NULL, NULL);
 511         if (written < 0) {
 512                 RWRAP_LOG(RWRAP_LOG_ERROR,
 513                           "Failed to compress [%s]\n", key);
 514                 return -1;
 515         }
 516         rd += written;
 517         remaining -= written;
 518
 519         if (remaining < 3 * sizeof(uint16_t) + sizeof(uint32_t)) {
 520                 RWRAP_LOG(RWRAP_LOG_ERROR, "Buffer too small\n");
 521                 return -1;
 522         }
 523
 524         NS_PUT16(type, rd);
 525         NS_PUT16(ns_c_in, rd);
 526         NS_PUT32(RWRAP_DEFAULT_FAKE_TTL, rd);
 527         NS_PUT16(rdata_size, rd);
 528
 529         if (remaining < rdata_size) {
 530                 RWRAP_LOG(RWRAP_LOG_ERROR, "Buffer too small\n");
 531                 return -1;
 532         }
 533
 534         *rdata_ptr = rd;
 535         return written + 3 * sizeof(uint16_t) + sizeof(uint32_t) + rdata_size;
 536 }
 537
 538 static ssize_t rwrap_fake_a(struct rwrap_fake_rr *rr,
 539                             uint8_t *answer_ptr,
 540                             size_t anslen)
 541 {
 542         uint8_t *a = answer_ptr;
 543         ssize_t resp_size;
 544
 545         if (rr->type != ns_t_a) {
 546                 RWRAP_LOG(RWRAP_LOG_ERROR, "Wrong type!\n");
 547                 return -1;
 548         }
 549         RWRAP_LOG(RWRAP_LOG_TRACE, "Adding A RR");
 550
 551         resp_size = rwrap_fake_rdata_common(ns_t_a, sizeof(struct in_addr), rr->key,
 552                                             anslen, &a);
 553         if (resp_size < 0) {
 554                 return -1;
 555         }
 556
 557         memcpy(a, &rr->rrdata.a_rec, sizeof(struct in_addr));
 558
 559         return resp_size;
 560 }
 561
 562 static ssize_t rwrap_fake_aaaa(struct rwrap_fake_rr *rr,
 563                                uint8_t *answer,
 564                                size_t anslen)
 565 {
 566         uint8_t *a = answer;
 567         ssize_t resp_size;
 568
 569         if (rr->type != ns_t_aaaa) {
 570                 RWRAP_LOG(RWRAP_LOG_ERROR, "Wrong type!\n");
 571                 return -1;
 572         }
 573         RWRAP_LOG(RWRAP_LOG_TRACE, "Adding AAAA RR");
 574
 575         resp_size = rwrap_fake_rdata_common(ns_t_aaaa, sizeof(struct in6_addr),
 576                                             rr->key, anslen, &a);
 577         if (resp_size < 0) {
 578                 return -1;
 579         }
 580
 581         memcpy(a, &rr->rrdata.aaaa_rec, sizeof(struct in6_addr));
 582
 583         return resp_size;
 584 }
 585
 586 static ssize_t rwrap_fake_ns(struct rwrap_fake_rr *rr,
 587                              uint8_t *answer,
 588                             size_t anslen)
 589 {
 590         uint8_t *a = answer;
 591         ssize_t resp_size = 0;
 592         size_t rdata_size;
 593         unsigned char hostname_compressed[MAXDNAME];
 594         ssize_t compressed_len;
 595
 596         if (rr->type != ns_t_ns) {
 597                 RWRAP_LOG(RWRAP_LOG_ERROR, "Wrong type!\n");
 598                 return -1;
 599         }
 600         RWRAP_LOG(RWRAP_LOG_TRACE, "Adding NS RR");
 601
 602         /* Prepare the data to write */
 603         compressed_len = ns_name_compress(rr->rrdata.srv_rec.hostname,
 604                                           hostname_compressed,
 605                                           MAXDNAME,
 606                                           NULL,
 607                                           NULL);
 608         if (compressed_len < 0) {
 609                 return -1;
 610         }
 611
 612         /* Is this enough? */
 613         rdata_size = compressed_len;
 614
 615         resp_size = rwrap_fake_rdata_common(ns_t_ns, rdata_size,
 616                                             rr->key, anslen, &a);
 617         if (resp_size < 0) {
 618                 return -1;
 619         }
 620
 621         memcpy(a, hostname_compressed, compressed_len);
 622
 623         return resp_size;
 624 }
 625
 626 static ssize_t rwrap_fake_srv(struct rwrap_fake_rr *rr,
 627                               uint8_t *answer,
 628                               size_t anslen)
 629 {
 630         uint8_t *a = answer;
 631         ssize_t resp_size;
 632         size_t rdata_size;
 633         unsigned char hostname_compressed[MAXDNAME];
 634         ssize_t compressed_len;
 635
 636         if (rr->type != ns_t_srv) {
 637                 RWRAP_LOG(RWRAP_LOG_ERROR, "Wrong type!\n");
 638                 return -1;
 639         }
 640         RWRAP_LOG(RWRAP_LOG_TRACE, "Adding SRV RR");
 641         rdata_size = 3 * sizeof(uint16_t);
 642
 643         /* Prepare the data to write */
 644         compressed_len = ns_name_compress(rr->rrdata.srv_rec.hostname,
 645                                           hostname_compressed, MAXDNAME,
 646                                           NULL, NULL);
 647         if (compressed_len < 0) {
 648                 return -1;
 649         }
 650         rdata_size += compressed_len;
 651
 652         resp_size = rwrap_fake_rdata_common(ns_t_srv, rdata_size,
 653                                             rr->key, anslen, &a);
 654         if (resp_size < 0) {
 655                 return -1;
 656         }
 657
 658         NS_PUT16(rr->rrdata.srv_rec.prio, a);
 659         NS_PUT16(rr->rrdata.srv_rec.weight, a);
 660         NS_PUT16(rr->rrdata.srv_rec.port, a);
 661         memcpy(a, hostname_compressed, compressed_len);
 662
 663         return resp_size;
 664 }
 665
 666 static ssize_t rwrap_fake_uri(struct rwrap_fake_rr *rr,
 667                               uint8_t *answer,
 668                               size_t anslen)
 669 {
 670         uint8_t *a = answer;
 671         ssize_t resp_size;
 672         size_t rdata_size;
 673         size_t uri_len;
 674
 675         if (rr->type != ns_t_uri) {
 676                 RWRAP_LOG(RWRAP_LOG_ERROR, "Wrong type!\n");
 677                 return -1;
 678         }
 679         RWRAP_LOG(RWRAP_LOG_TRACE, "Adding URI RR");
 680         rdata_size = 3 * sizeof(uint16_t);
 681         uri_len = strlen(rr->rrdata.uri_rec.uri) + 1;
 682         rdata_size += uri_len;
 683
 684         resp_size = rwrap_fake_rdata_common(ns_t_uri, rdata_size,
 685                                             rr->key, anslen, &a);
 686         if (resp_size < 0) {
 687                 return -1;
 688         }
 689
 690         NS_PUT16(rr->rrdata.uri_rec.prio, a);
 691         NS_PUT16(rr->rrdata.uri_rec.weight, a);
 692         memcpy(a, rr->rrdata.uri_rec.uri, uri_len);
 693
 694         return resp_size;
 695 }
 696
 697 static ssize_t rwrap_fake_txt(struct rwrap_fake_rr *rr,
 698                               uint8_t *answer,
 699                               size_t anslen)
 700 {
 701         uint8_t *a = answer;
 702         ssize_t resp_size;
 703         size_t rdata_size;
 704         size_t txt_len;
 705
 706         if (rr->type != ns_t_txt) {
 707                 RWRAP_LOG(RWRAP_LOG_ERROR, "Wrong type!\n");
 708                 return -1;
 709         }
 710         RWRAP_LOG(RWRAP_LOG_TRACE, "Adding TXT RR");
 711         txt_len = strlen(rr->rrdata.txt_rec) + 1;
 712         rdata_size = txt_len;
 713
 714         resp_size = rwrap_fake_rdata_common(ns_t_txt, rdata_size,
 715                                             rr->key, anslen, &a);
 716         if (resp_size < 0) {
 717                 return -1;
 718         }
 719
 720         memcpy(a, rr->rrdata.txt_rec, txt_len);
 721
 722         return resp_size;
 723 }
 724
 725 static ssize_t rwrap_fake_soa(struct rwrap_fake_rr *rr,
 726                               uint8_t *answer,
 727                               size_t anslen)
 728 {
 729         uint8_t *a = answer;
 730         ssize_t resp_size;
 731         size_t rdata_size;
 732         unsigned char nameser_compressed[MAXDNAME];
 733         ssize_t compressed_ns_len;
 734         unsigned char mailbox_compressed[MAXDNAME];
 735         ssize_t compressed_mb_len;
 736
 737         if (rr->type != ns_t_soa) {
 738                 RWRAP_LOG(RWRAP_LOG_ERROR, "Wrong type!\n");
 739                 return -1;
 740         }
 741         RWRAP_LOG(RWRAP_LOG_TRACE, "Adding SOA RR");
 742         rdata_size = 5 * sizeof(uint16_t);
 743
 744         compressed_ns_len = ns_name_compress(rr->rrdata.soa_rec.nameserver,
 745                                              nameser_compressed,
 746                                              MAXDNAME, NULL, NULL);
 747         if (compressed_ns_len < 0) {
 748                 return -1;
 749         }
 750         rdata_size += compressed_ns_len;
 751
 752         compressed_mb_len = ns_name_compress(rr->rrdata.soa_rec.mailbox,
 753                                              mailbox_compressed,
 754                                              MAXDNAME, NULL, NULL);
 755         if (compressed_mb_len < 0) {
 756                 return -1;
 757         }
 758         rdata_size += compressed_mb_len;
 759
 760         resp_size = rwrap_fake_rdata_common(ns_t_soa, rdata_size,
 761                                             rr->key, anslen, &a);
 762         if (resp_size < 0) {
 763                 return -1;
 764         }
 765
 766         memcpy(a, nameser_compressed, compressed_ns_len);
 767         a += compressed_ns_len;
 768         memcpy(a, mailbox_compressed, compressed_mb_len);
 769         a += compressed_mb_len;
 770         NS_PUT32(rr->rrdata.soa_rec.serial, a);
 771         NS_PUT32(rr->rrdata.soa_rec.refresh, a);
 772         NS_PUT32(rr->rrdata.soa_rec.retry, a);
 773         NS_PUT32(rr->rrdata.soa_rec.expire, a);
 774         NS_PUT32(rr->rrdata.soa_rec.minimum, a);
 775
 776         return resp_size;
 777 }
 778
 779 static ssize_t rwrap_fake_cname(struct rwrap_fake_rr *rr,
 780                                 uint8_t *answer,
 781                                 size_t anslen)
 782 {
 783         uint8_t *a = answer;
 784         ssize_t resp_size;
 785         unsigned char hostname_compressed[MAXDNAME];
 786         ssize_t rdata_size;
 787
 788         if (rr->type != ns_t_cname) {
 789                 RWRAP_LOG(RWRAP_LOG_ERROR, "Wrong type!\n");
 790                 return -1;
 791         }
 792         RWRAP_LOG(RWRAP_LOG_TRACE, "Adding CNAME RR");
 793
 794         /* Prepare the data to write */
 795         rdata_size = ns_name_compress(rr->rrdata.cname_rec,
 796                                       hostname_compressed, MAXDNAME,
 797                                       NULL, NULL);
 798         if (rdata_size < 0) {
 799                 return -1;
 800         }
 801
 802         resp_size = rwrap_fake_rdata_common(ns_t_cname, rdata_size,
 803                                             rr->key, anslen, &a);
 804         if (resp_size < 0) {
 805                 return -1;
 806         }
 807
 808         memcpy(a, hostname_compressed, rdata_size);
 809
 810         return resp_size;
 811 }
 812
 813 static ssize_t rwrap_fake_ptr(struct rwrap_fake_rr *rr,
 814                               uint8_t *answer,
 815                               size_t anslen)
 816 {
 817         uint8_t *a = answer;
 818         ssize_t rdata_size;
 819         ssize_t resp_size;
 820         unsigned char hostname_compressed[MAXDNAME];
 821
 822         if (rr->type != ns_t_ptr) {
 823                 RWRAP_LOG(RWRAP_LOG_ERROR, "Wrong type!\n");
 824                 return -1;
 825         }
 826         RWRAP_LOG(RWRAP_LOG_TRACE, "Adding PTR RR");
 827
 828         /* Prepare the data to write */
 829         rdata_size = ns_name_compress(rr->rrdata.ptr_rec,
 830                                       hostname_compressed, MAXDNAME,
 831                                       NULL, NULL);
 832         if (rdata_size < 0) {
 833                 return -1;
 834         }
 835
 836         resp_size = rwrap_fake_rdata_common(ns_t_ptr, rdata_size,
 837                                             rr->key, anslen, &a);
 838         if (resp_size < 0) {
 839                 return -1;
 840         }
 841
 842         memcpy(a, hostname_compressed, rdata_size);
 843
 844         return resp_size;
 845 }
 846
 847 #define RESOLV_MATCH(line, name) \
 848         (strncmp(line, name, sizeof(name) - 1) == 0 && \
 849         (line[sizeof(name) - 1] == ' ' || \
 850          line[sizeof(name) - 1] == '\t'))
 851
 852 #define TYPE_MATCH(type, ns_type, rec_type, str_type, key, query) \
 853         ((type) == (ns_type) && \
 854          (strncmp((rec_type), (str_type), sizeof(str_type)) == 0) && \
 855          (strcasecmp(key, query)) == 0)
 856
 857
 858 static int rwrap_get_record(const char *hostfile, unsigned recursion,
 859                             const char *query, int type,
 860                             struct rwrap_fake_rr *rr);
 861
 862 static int rwrap_uri_recurse(const char *hostfile, unsigned recursion,
 863                              const char *query, struct rwrap_fake_rr *rr)
 864 {
 865         int rc;
 866
 867         rc = rwrap_get_record(hostfile, recursion, query, ns_t_uri, rr);
 868         if (rc == ENOENT) {
 869                 rc = 0;
 870         }
 871
 872         return rc;
 873 }
 874
 875 static int rwrap_srv_recurse(const char *hostfile, unsigned recursion,
 876                              const char *query, struct rwrap_fake_rr *rr)
 877 {
 878         int rc;
 879
 880         rc = rwrap_get_record(hostfile, recursion, query, ns_t_a, rr);
 881         if (rc == 0) return 0;
 882
 883         rc = rwrap_get_record(hostfile, recursion, query, ns_t_aaaa, rr);
 884         if (rc == ENOENT) rc = 0;
 885
 886         return rc;
 887 }
 888
 889 static int rwrap_cname_recurse(const char *hostfile, unsigned recursion,
 890                                const char *query, struct rwrap_fake_rr *rr)
 891 {
 892         int rc;
 893
 894         rc = rwrap_get_record(hostfile, recursion, query, ns_t_a, rr);
 895         if (rc == 0) return 0;
 896
 897         rc = rwrap_get_record(hostfile, recursion, query, ns_t_aaaa, rr);
 898         if (rc == 0) return 0;
 899
 900         rc = rwrap_get_record(hostfile, recursion, query, ns_t_cname, rr);
 901         if (rc == ENOENT) rc = 0;
 902
 903         return rc;
 904 }
 905
 906 static int rwrap_get_record(const char *hostfile, unsigned recursion,
 907                             const char *query, int type,
 908                             struct rwrap_fake_rr *rr)
 909 {
 910         FILE *fp = NULL;
 911         char buf[BUFSIZ];
 912         char *key = NULL;
 913         char *value = NULL;
 914         int rc = ENOENT;
 915         unsigned num_uris = 0;
 916
 917         if (recursion >= RWRAP_MAX_RECURSION) {
 918                 RWRAP_LOG(RWRAP_LOG_ERROR, "Recursed too deep!\n");
 919                 return -1;
 920         }
 921
 922         RWRAP_LOG(RWRAP_LOG_TRACE,
 923                   "Searching in fake hosts file %s for %s:%d\n", hostfile,
 924                   query, type);
 925
 926         fp = fopen(hostfile, "r");
 927         if (fp == NULL) {
 928                 RWRAP_LOG(RWRAP_LOG_WARN,
 929                           "Opening %s failed: %s",
 930                           hostfile, strerror(errno));
 931                 return -1;
 932         }
 933
 934         while (fgets(buf, sizeof(buf), fp) != NULL) {
 935                 char *rec_type;
 936                 char *q;
 937
 938                 rec_type = buf;
 939                 key = value = NULL;
 940
 941                 NEXT_KEY(rec_type, key);
 942                 NEXT_KEY(key, value);
 943
 944                 if (key == NULL || value == NULL) {
 945                         RWRAP_LOG(RWRAP_LOG_WARN,
 946                                 "Malformed line: not enough parts, use \"rec_type key data\n"
 947                                 "For example \"A cwrap.org 10.10.10.10\"");
 948                         continue;
 949                 }
 950
 951                 q = value;
 952                 while(q[0] != '\n' && q[0] != '\0') {
 953                         q++;
 954                 }
 955                 q[0] = '\0';
 956
 957                 if (type == ns_t_uri && recursion > 0) {
 958                         /* Skip non-URI records. */
 959                         if (!TYPE_MATCH(type, ns_t_uri, rec_type, "URI", key, query)) {
 960                                 continue;
 961                         }
 962                         /* Skip previous records based on the recurse depth. */
 963                         num_uris++;
 964                         if (num_uris <= recursion) {
 965                                 continue;
 966                         }
 967                 }
 968
 969                 if (TYPE_MATCH(type, ns_t_a, rec_type, "A", key, query)) {
 970                         rc = rwrap_create_fake_a_rr(key, value, rr);
 971                         break;
 972                 } else if (TYPE_MATCH(type, ns_t_aaaa,
 973                                       rec_type, "AAAA", key, query)) {
 974                         rc = rwrap_create_fake_aaaa_rr(key, value, rr);
 975                         break;
 976                 } else if (TYPE_MATCH(type, ns_t_ns,
 977                                       rec_type, "NS", key, query)) {
 978                         rc = rwrap_create_fake_ns_rr(key, value, rr);
 979                         break;
 980                 } else if (TYPE_MATCH(type, ns_t_srv,
 981                                       rec_type, "SRV", key, query)) {
 982                         rc = rwrap_create_fake_srv_rr(key, value, rr);
 983                         if (rc == 0) {
 984                                 rc = rwrap_srv_recurse(hostfile, recursion+1,
 985                                                 rr->rrdata.srv_rec.hostname,
 986                                                 rr + 1);
 987                         }
 988                         break;
 989                 } else if (TYPE_MATCH(type, ns_t_uri,
 990                                       rec_type, "URI", key, query)) {
 991                         rc = rwrap_create_fake_uri_rr(key, value, rr);
 992                         if (rc == 0) {
 993                                 /* Recurse to collect multiple URI answers under a single key. */
 994                                 rc = rwrap_uri_recurse(hostfile, recursion + 1, key, rr + 1);
 995                         }
 996                         break;
 997                 } else if (TYPE_MATCH(type, ns_t_soa,
 998                                       rec_type, "SOA", key, query)) {
 999                         rc = rwrap_create_fake_soa_rr(key, value, rr);
1000                         break;
1001                 } else if (TYPE_MATCH(type, ns_t_cname,
1002                                       rec_type, "CNAME", key, query)) {
1003                         rc = rwrap_create_fake_cname_rr(key, value, rr);
1004                         if (rc == 0) {
1005                                 rc = rwrap_cname_recurse(hostfile, recursion+1,
1006                                                          value, rr + 1);
1007                         }
1008                         break;
1009                 } else if (TYPE_MATCH(type, ns_t_a, rec_type, "CNAME", key, query)) {
1010                         rc = rwrap_create_fake_cname_rr(key, value, rr);
1011                         if (rc == 0) {
1012                                 rc = rwrap_cname_recurse(hostfile, recursion+1,
1013                                                          value, rr + 1);
1014                         }
1015                         break;
1016                 } else if (TYPE_MATCH(type, ns_t_ptr,
1017                                       rec_type, "PTR", key, query)) {
1018                         rc = rwrap_create_fake_ptr_rr(key, value, rr);
1019                         break;
1020                 }
1021                 else if (TYPE_MATCH(type, ns_t_txt,
1022                                       rec_type, "TXT", key, query)) {
1023                         rc = rwrap_create_fake_txt_rr(key, value, rr);
1024                         break;
1025                 }
1026         }
1027
1028         if (rc == ENOENT && recursion == 0 && key != NULL) {
1029                 RWRAP_LOG(RWRAP_LOG_TRACE, "Record for [%s] not found\n", query);
1030                 memcpy(rr->key, key, strlen(key) + 1);
1031         }
1032
1033         fclose(fp);
1034         return rc;
1035 }
1036
1037 static ssize_t rwrap_fake_empty(int type,
1038                                 const char *question,
1039                                 uint8_t *answer,
1040                                 size_t anslen)
1041 {
1042         ssize_t resp_data;
1043         size_t remaining = anslen;
1044
1045         resp_data = rwrap_fake_header(&answer, remaining, 0, 0);
1046         if (resp_data < 0) {
1047                 return -1;
1048         }
1049         remaining -= resp_data;
1050
1051         resp_data += rwrap_fake_question(question, type, &answer, remaining);
1052         if (resp_data < 0) {
1053                 return -1;
1054         }
1055         remaining -= resp_data;
1056
1057         resp_data += rwrap_fake_rdata_common(type, 0, question,
1058                                             remaining, &answer);
1059         if (resp_data < 0) {
1060                 return -1;
1061         }
1062
1063         return resp_data;
1064 }
1065
1066 static inline bool rwrap_known_type(int type)
1067 {
1068         switch (type) {
1069         case ns_t_a:
1070         case ns_t_aaaa:
1071         case ns_t_ns:
1072         case ns_t_srv:
1073         case ns_t_uri:
1074         case ns_t_soa:
1075         case ns_t_cname:
1076         case ns_t_ptr:
1077         case ns_t_txt:
1078                 return true;
1079         }
1080
1081         return false;
1082 }
1083
1084 static int rwrap_ancount(struct rwrap_fake_rr *rrs, int qtype)
1085 {
1086         int i;
1087         int ancount = 0;
1088
1089         /* For URI return the number of URIs. */
1090         if (qtype == ns_t_uri) {
1091                 for (i = 0; i < RWRAP_MAX_RECURSION; i++) {
1092                         if (rwrap_known_type(rrs[i].type) &&
1093                             rrs[i].type == qtype) {
1094                                 ancount++;
1095                         }
1096                 }
1097                 return ancount;
1098         }
1099
1100         /* Include all RRs in the stack until the sought type
1101          * in the answer section. This is the case i.e. when looking
1102          * up an A record but the name points to a CNAME
1103          */
1104         for (i = 0; i < RWRAP_MAX_RECURSION; i++) {
1105                 ancount++;
1106
1107                 if (rwrap_known_type(rrs[i].type) &&
1108                     rrs[i].type == qtype) {
1109                         break;
1110                 }
1111         }
1112
1113         /* Return 0 records if the sought type wasn't in the stack */
1114         return i < RWRAP_MAX_RECURSION ? ancount : 0;
1115 }
1116
1117 static int rwrap_arcount(struct rwrap_fake_rr *rrs, int ancount)
1118 {
1119         int i;
1120         int arcount = 0;
1121
1122         /* start from index ancount */
1123         for (i = ancount; i < RWRAP_MAX_RECURSION; i++) {
1124                 if (rwrap_known_type(rrs[i].type)) {
1125                         arcount++;
1126                 }
1127         }
1128
1129         return arcount;
1130 }
1131
1132 static ssize_t rwrap_add_rr(struct rwrap_fake_rr *rr,
1133                             uint8_t *answer,
1134                             size_t anslen)
1135 {
1136         ssize_t resp_data;
1137
1138         if (rr == NULL) {
1139                 RWRAP_LOG(RWRAP_LOG_ERROR, "Internal error!\n");
1140                 return -1;
1141         }
1142
1143         switch (rr->type) {
1144         case ns_t_a:
1145                 resp_data = rwrap_fake_a(rr, answer, anslen);
1146                 break;
1147         case ns_t_aaaa:
1148                 resp_data = rwrap_fake_aaaa(rr, answer, anslen);
1149                 break;
1150         case ns_t_ns:
1151                 resp_data = rwrap_fake_ns(rr, answer, anslen);
1152                 break;
1153         case ns_t_srv:
1154                 resp_data = rwrap_fake_srv(rr, answer, anslen);
1155                 break;
1156         case ns_t_uri:
1157                 resp_data = rwrap_fake_uri(rr, answer, anslen);
1158                 break;
1159         case ns_t_soa:
1160                 resp_data = rwrap_fake_soa(rr, answer, anslen);
1161                 break;
1162         case ns_t_cname:
1163                 resp_data = rwrap_fake_cname(rr, answer, anslen);
1164                 break;
1165         case ns_t_ptr:
1166                 resp_data = rwrap_fake_ptr(rr, answer, anslen);
1167                 break;
1168         case ns_t_txt:
1169                 resp_data = rwrap_fake_txt(rr, answer, anslen);
1170                 break;
1171         default:
1172                 return -1;
1173         }
1174
1175         return resp_data;
1176 }
1177
1178 static ssize_t rwrap_fake_answer(struct rwrap_fake_rr *rrs,
1179                                  int type,
1180                                  uint8_t *answer,
1181                                  size_t anslen)
1182
1183 {
1184         ssize_t resp_data;
1185         ssize_t rrlen;
1186         size_t remaining = anslen;
1187         int ancount;
1188         int arcount;
1189         int i;
1190
1191         ancount = rwrap_ancount(rrs, type);
1192         arcount = rwrap_arcount(rrs, ancount);
1193         RWRAP_LOG(RWRAP_LOG_TRACE,
1194                   "Got %d answers and %d additional records\n", ancount, arcount);
1195
1196         resp_data = rwrap_fake_header(&answer, remaining, ancount, arcount);
1197         if (resp_data < 0) {
1198                 return -1;
1199         }
1200         remaining -= resp_data;
1201
1202         resp_data += rwrap_fake_question(rrs->key, rrs->type, &answer, remaining);
1203         if (resp_data < 0) {
1204                 return -1;
1205         }
1206         remaining -= resp_data;
1207
1208         /* answer */
1209         for (i = 0; i < ancount; i++) {
1210                 rrlen = rwrap_add_rr(&rrs[i], answer, remaining);
1211                 if (rrlen < 0) {
1212                         return -1;
1213                 }
1214                 remaining -= rrlen;
1215                 answer += rrlen;
1216                 resp_data += rrlen;
1217         }
1218
1219         /* add authoritative NS here? */
1220
1221         /* additional records */
1222         for (i = ancount; i < ancount + arcount; i++) {
1223                 rrlen = rwrap_add_rr(&rrs[i], answer, remaining);
1224                 if (rrlen < 0) {
1225                         return -1;
1226                 }
1227                 remaining -= rrlen;
1228                 answer += rrlen;
1229                 resp_data += rrlen;
1230         }
1231
1232         return resp_data;
1233 }
1234
1235 /* Reads in a file in the following format:
1236  * TYPE RDATA
1237  *
1238  * Malformed entries are silently skipped.
1239  * Allocates answer buffer of size anslen that has to be freed after use.
1240  */
1241 static int rwrap_res_fake_hosts(const char *hostfile,
1242                                 const char *query,
1243                                 int type,
1244                                 unsigned char *answer,
1245                                 size_t anslen)
1246 {
1247         int rc = ENOENT;
1248         char *query_name = NULL;
1249         size_t qlen = strlen(query);
1250         struct rwrap_fake_rr rrs[RWRAP_MAX_RECURSION];
1251         ssize_t resp_size;
1252
1253         RWRAP_LOG(RWRAP_LOG_TRACE,
1254                   "Searching in fake hosts file %s\n", hostfile);
1255
1256         if (qlen > 0 && query[qlen-1] == '.') {
1257                 qlen--;
1258         }
1259
1260         query_name = strndup(query, qlen);
1261         if (query_name == NULL) {
1262                 return -1;
1263         }
1264
1265         rwrap_fake_rr_init(rrs, RWRAP_MAX_RECURSION);
1266
1267         rc = rwrap_get_record(hostfile, 0, query_name, type, rrs);
1268         switch (rc) {
1269         case 0:
1270                 RWRAP_LOG(RWRAP_LOG_TRACE,
1271                                 "Found record for [%s]\n", query_name);
1272                 resp_size = rwrap_fake_answer(rrs, type, answer, anslen);
1273                 break;
1274         case ENOENT:
1275                 RWRAP_LOG(RWRAP_LOG_TRACE,
1276                                 "No record for [%s]\n", query_name);
1277                 resp_size = rwrap_fake_empty(type, rrs->key, answer, anslen);
1278                 break;
1279         default:
1280                 RWRAP_LOG(RWRAP_LOG_NOTICE,
1281                           "Searching for [%s] did not return any results\n",
1282                           query_name);
1283                 free(query_name);
1284                 return -1;
1285         }
1286
1287         switch (resp_size) {
1288         case -1:
1289                 RWRAP_LOG(RWRAP_LOG_ERROR,
1290                                 "Error faking answer for [%s]\n", query_name);
1291                 break;
1292         default:
1293                 RWRAP_LOG(RWRAP_LOG_TRACE,
1294                                 "Successfully faked answer for [%s]\n",
1295                                 query_name);
1296                 break;
1297         }
1298
1299         free(query_name);
1300         return resp_size;
1301 }
1302
1303 /*********************************************************
1304  * RWRAP LOADING LIBC FUNCTIONS
1305  *********************************************************/
1306
1307 #include <dlfcn.h>
1308
1309 typedef int (*__libc_res_ninit)(struct __res_state *state);
1310 typedef int (*__libc___res_ninit)(struct __res_state *state);
1311 typedef void (*__libc_res_nclose)(struct __res_state *state);
1312 typedef void (*__libc___res_nclose)(struct __res_state *state);
1313 typedef int (*__libc_res_nquery)(struct __res_state *state,
1314                                  const char *dname,
1315                                  int class,
1316                                  int type,
1317                                  unsigned char *answer,
1318                                  int anslen);
1319 typedef int (*__libc___res_nquery)(struct __res_state *state,
1320                                    const char *dname,
1321                                    int class,
1322                                    int type,
1323                                    unsigned char *answer,
1324                                    int anslen);
1325 typedef int (*__libc_res_nsearch)(struct __res_state *state,
1326                                   const char *dname,
1327                                   int class,
1328                                   int type,
1329                                   unsigned char *answer,
1330                                   int anslen);
1331 typedef int (*__libc___res_nsearch)(struct __res_state *state,
1332                                     const char *dname,
1333                                     int class,
1334                                     int type,
1335                                     unsigned char *answer,
1336                                     int anslen);
1337
1338 #define RWRAP_SYMBOL_ENTRY(i) \
1339         union { \
1340                 __libc_##i f; \
1341                 void *obj; \
1342         } _libc_##i
1343
1344 struct rwrap_libc_symbols {
1345         RWRAP_SYMBOL_ENTRY(res_ninit);
1346         RWRAP_SYMBOL_ENTRY(__res_ninit);
1347         RWRAP_SYMBOL_ENTRY(res_nclose);
1348         RWRAP_SYMBOL_ENTRY(__res_nclose);
1349         RWRAP_SYMBOL_ENTRY(res_nquery);
1350         RWRAP_SYMBOL_ENTRY(__res_nquery);
1351         RWRAP_SYMBOL_ENTRY(res_nsearch);
1352         RWRAP_SYMBOL_ENTRY(__res_nsearch);
1353 };
1354 #undef RWRAP_SYMBOL_ENTRY
1355
1356 struct rwrap {
1357         struct {
1358                 void *handle;
1359                 struct rwrap_libc_symbols symbols;
1360         } libc;
1361
1362         struct {
1363                 void *handle;
1364                 struct rwrap_libc_symbols symbols;
1365         } libresolv;
1366
1367         bool initialised;
1368         bool enabled;
1369
1370         char *socket_dir;
1371 };
1372
1373 static struct rwrap rwrap;
1374
1375 enum rwrap_lib {
1376     RWRAP_LIBC,
1377     RWRAP_LIBRESOLV
1378 };
1379
1380 static const char *rwrap_str_lib(enum rwrap_lib lib)
1381 {
1382         switch (lib) {
1383         case RWRAP_LIBC:
1384                 return "libc";
1385         case RWRAP_LIBRESOLV:
1386                 return "libresolv";
1387         }
1388
1389         /* Compiler would warn us about unhandled enum value if we get here */
1390         return "unknown";
1391 }
1392
1393 static void *rwrap_load_lib_handle(enum rwrap_lib lib)
1394 {
1395         int flags = RTLD_LAZY;
1396         void *handle = NULL;
1397         int i;
1398
1399 #ifdef RTLD_DEEPBIND
1400         const char *env_preload = getenv("LD_PRELOAD");
1401         const char *env_deepbind = getenv("RESOLV_WRAPPER_DISABLE_DEEPBIND");
1402         bool enable_deepbind = true;
1403
1404         /* Don't do a deepbind if we run with libasan */
1405         if (env_preload != NULL && strlen(env_preload) < 1024) {
1406                 const char *p = strstr(env_preload, "libasan.so");
1407                 if (p != NULL) {
1408                         enable_deepbind = false;
1409                 }
1410         }
1411
1412         if (env_deepbind != NULL && strlen(env_deepbind) >= 1) {
1413                 enable_deepbind = false;
1414         }
1415
1416         if (enable_deepbind) {
1417                 flags |= RTLD_DEEPBIND;
1418         }
1419 #endif
1420
1421         switch (lib) {
1422         case RWRAP_LIBRESOLV:
1423 #ifdef HAVE_LIBRESOLV
1424                 handle = rwrap.libresolv.handle;
1425                 if (handle == NULL) {
1426                         for (i = 10; i >= 0; i--) {
1427                                 char soname[256] = {0};
1428
1429                                 snprintf(soname, sizeof(soname), "libresolv.so.%d", i);
1430                                 handle = dlopen(soname, flags);
1431                                 if (handle != NULL) {
1432                                         break;
1433                                 }
1434                         }
1435
1436                         rwrap.libresolv.handle = handle;
1437                 }
1438                 break;
1439 #endif
1440                 /* FALL TROUGH */
1441         case RWRAP_LIBC:
1442                 handle = rwrap.libc.handle;
1443 #ifdef LIBC_SO
1444                 if (handle == NULL) {
1445                         handle = dlopen(LIBC_SO, flags);
1446
1447                         rwrap.libc.handle = handle;
1448                 }
1449 #endif
1450                 if (handle == NULL) {
1451                         for (i = 10; i >= 0; i--) {
1452                                 char soname[256] = {0};
1453
1454                                 snprintf(soname, sizeof(soname), "libc.so.%d", i);
1455                                 handle = dlopen(soname, flags);
1456                                 if (handle != NULL) {
1457                                         break;
1458                                 }
1459                         }
1460
1461                         rwrap.libc.handle = handle;
1462                 }
1463                 break;
1464         }
1465
1466         if (handle == NULL) {
1467 #ifdef RTLD_NEXT
1468                 handle = rwrap.libc.handle = rwrap.libresolv.handle = RTLD_NEXT;
1469 #else
1470                 RWRAP_LOG(RWRAP_LOG_ERROR,
1471                           "Failed to dlopen library: %s\n",
1472                           dlerror());
1473                 exit(-1);
1474 #endif
1475         }
1476
1477         return handle;
1478 }
1479
1480 static void *_rwrap_bind_symbol(enum rwrap_lib lib, const char *fn_name)
1481 {
1482         void *handle;
1483         void *func;
1484
1485         handle = rwrap_load_lib_handle(lib);
1486
1487         func = dlsym(handle, fn_name);
1488         if (func == NULL) {
1489                 RWRAP_LOG(RWRAP_LOG_ERROR,
1490                                 "Failed to find %s: %s\n",
1491                                 fn_name, dlerror());
1492                 exit(-1);
1493         }
1494
1495         RWRAP_LOG(RWRAP_LOG_TRACE,
1496                         "Loaded %s from %s",
1497                         fn_name, rwrap_str_lib(lib));
1498         return func;
1499 }
1500
1501 #define rwrap_bind_symbol_libc(sym_name) \
1502         if (rwrap.libc.symbols._libc_##sym_name.obj == NULL) { \
1503                 rwrap.libc.symbols._libc_##sym_name.obj = \
1504                         _rwrap_bind_symbol(RWRAP_LIBC, #sym_name); \
1505         }
1506
1507 #define rwrap_bind_symbol_libresolv(sym_name) \
1508         if (rwrap.libresolv.symbols._libc_##sym_name.obj == NULL) { \
1509                 rwrap.libresolv.symbols._libc_##sym_name.obj = \
1510                         _rwrap_bind_symbol(RWRAP_LIBRESOLV, #sym_name); \
1511         }
1512
1513 /*
1514  * IMPORTANT
1515  *
1516  * Functions especially from libc need to be loaded individually, you can't load
1517  * all at once or gdb will segfault at startup. The same applies to valgrind and
1518  * has probably something todo with with the linker.
1519  * So we need load each function at the point it is called the first time.
1520  */
1521
1522 static int libc_res_ninit(struct __res_state *state)
1523 {
1524 #if !defined(res_ninit) && defined(HAVE_RES_NINIT)
1525         rwrap_bind_symbol_libresolv(res_ninit);
1526
1527         return rwrap.libresolv.symbols._libc_res_ninit.f(state);
1528 #elif defined(HAVE___RES_NINIT)
1529         rwrap_bind_symbol_libresolv(__res_ninit);
1530
1531         return rwrap.libresolv.symbols._libc___res_ninit.f(state);
1532 #else
1533 #error "No res_ninit function"
1534 #endif
1535 }
1536
1537 static void libc_res_nclose(struct __res_state *state)
1538 {
1539 #if !defined(res_close) && defined(HAVE_RES_NCLOSE)
1540         rwrap_bind_symbol_libresolv(res_nclose);
1541
1542         rwrap.libresolv.symbols._libc_res_nclose.f(state);
1543         return;
1544 #elif defined(HAVE___RES_NCLOSE)
1545         rwrap_bind_symbol_libresolv(__res_nclose);
1546
1547         rwrap.libresolv.symbols._libc___res_nclose.f(state);
1548 #else
1549 #error "No res_nclose function"
1550 #endif
1551 }
1552
1553 static int libc_res_nquery(struct __res_state *state,
1554                            const char *dname,
1555                            int class,
1556                            int type,
1557                            unsigned char *answer,
1558                            int anslen)
1559 {
1560 #if !defined(res_nquery) && defined(HAVE_RES_NQUERY)
1561         rwrap_bind_symbol_libresolv(res_nquery);
1562
1563         return rwrap.libresolv.symbols._libc_res_nquery.f(state,
1564                                                           dname,
1565                                                           class,
1566                                                           type,
1567                                                           answer,
1568                                                           anslen);
1569 #elif defined(HAVE___RES_NQUERY)
1570         rwrap_bind_symbol_libresolv(__res_nquery);
1571
1572         return rwrap.libresolv.symbols._libc___res_nquery.f(state,
1573                                                             dname,
1574                                                             class,
1575                                                             type,
1576                                                             answer,
1577                                                             anslen);
1578 #else
1579 #error "No res_nquery function"
1580 #endif
1581 }
1582
1583 static int libc_res_nsearch(struct __res_state *state,
1584                             const char *dname,
1585                             int class,
1586                             int type,
1587                             unsigned char *answer,
1588                             int anslen)
1589 {
1590 #if !defined(res_nsearch) && defined(HAVE_RES_NSEARCH)
1591         rwrap_bind_symbol_libresolv(res_nsearch);
1592
1593         return rwrap.libresolv.symbols._libc_res_nsearch.f(state,
1594                                                            dname,
1595                                                            class,
1596                                                            type,
1597                                                            answer,
1598                                                            anslen);
1599 #elif defined(HAVE___RES_NSEARCH)
1600         rwrap_bind_symbol_libresolv(__res_nsearch);
1601
1602         return rwrap.libresolv.symbols._libc___res_nsearch.f(state,
1603                                                              dname,
1604                                                              class,
1605                                                              type,
1606                                                              answer,
1607                                                              anslen);
1608 #else
1609 #error "No res_nsearch function"
1610 #endif
1611 }
1612
1613 /****************************************************************************
1614  *   RES_HELPER
1615  ***************************************************************************/
1616
1617 static size_t rwrap_get_nameservers(struct __res_state *state,
1618                                     size_t nserv,
1619                                     union rwrap_sockaddr *nsaddrs)
1620 {
1621 #ifdef HAVE_RES_SOCKADDR_UNION_SIN
1622         union res_sockaddr_union set[MAXNS];
1623         size_t i;
1624         int rc;
1625
1626         memset(set, 0, sizeof(set));
1627         memset(nsaddrs, 0, sizeof(*nsaddrs) * nserv);
1628
1629         if (nserv > MAXNS) {
1630                 nserv = MAXNS;
1631         }
1632
1633         rc = res_getservers(state, set, nserv);
1634         if (rc <= 0) {
1635                 return 0;
1636         }
1637         if (rc < nserv) {
1638                 nserv = rc;
1639         }
1640
1641         for (i = 0; i < nserv; i++) {
1642                 switch (set[i].sin.sin_family) {
1643                 case AF_INET:
1644                         nsaddrs[i] = (union rwrap_sockaddr) {
1645                                 .in = set[i].sin,
1646                         };
1647                         break;
1648 #ifdef HAVE_RES_SOCKADDR_UNION_SIN6
1649                 case AF_INET6:
1650                         nsaddrs[i] = (union rwrap_sockaddr) {
1651                                 .in6 = set[i].sin6,
1652                         };
1653                         break;
1654 #endif
1655                 }
1656         }
1657
1658         return nserv;
1659 #else /* ! HAVE_RES_SOCKADDR_UNION_SIN */
1660         size_t i;
1661
1662         memset(nsaddrs, 0, sizeof(*nsaddrs) * nserv);
1663
1664         if (nserv > (size_t)state->nscount) {
1665                 nserv = (size_t)state->nscount;
1666         }
1667
1668         for (i = 0; i < nserv; i++) {
1669 #ifdef HAVE_RES_STATE_U_EXT_NSADDRS
1670                 if (state->_u._ext.nsaddrs[i] != NULL) {
1671                         nsaddrs[i] = (union rwrap_sockaddr) {
1672                                 .in6 = *state->_u._ext.nsaddrs[i],
1673                         };
1674                 } else
1675 #endif /* HAVE_RES_STATE_U_EXT_NSADDRS */
1676                 {
1677                         nsaddrs[i] = (union rwrap_sockaddr) {
1678                                 .in = state->nsaddr_list[i],
1679                         };
1680                 }
1681         }
1682
1683         return nserv;
1684 #endif /* ! HAVE_RES_SOCKADDR_UNION_SIN */
1685 }
1686
1687 static void rwrap_log_nameservers(enum rwrap_dbglvl_e dbglvl,
1688                                   const char *func,
1689                                   struct __res_state *state)
1690 {
1691         union rwrap_sockaddr nsaddrs[MAXNS];
1692         size_t nserv = MAXNS;
1693         size_t i;
1694
1695         memset(nsaddrs, 0, sizeof(nsaddrs));
1696         nserv = rwrap_get_nameservers(state, nserv, nsaddrs);
1697         for (i = 0; i < nserv; i++) {
1698                 char ip[INET6_ADDRSTRLEN];
1699
1700                 switch (nsaddrs[i].sa.sa_family) {
1701                 case AF_INET:
1702                         inet_ntop(AF_INET, &(nsaddrs[i].in.sin_addr),
1703                                   ip, sizeof(ip));
1704                         break;
1705                 case AF_INET6:
1706                         inet_ntop(AF_INET6, &(nsaddrs[i].in6.sin6_addr),
1707                                   ip, sizeof(ip));
1708                         break;
1709                 default:
1710                         snprintf(ip, sizeof(ip), "<unknown sa_family=%d",
1711                                  nsaddrs[i].sa.sa_family);
1712                         break;
1713                 }
1714
1715                 rwrap_log(dbglvl, func,
1716                           "        nameserver: %s",
1717                           ip);
1718         }
1719 }
1720
1721 static void rwrap_reset_nameservers(struct __res_state *state)
1722 {
1723 #ifdef HAVE_RES_SOCKADDR_UNION_SIN
1724         res_setservers(state, NULL, 0);
1725 #else /* ! HAVE_RES_SOCKADDR_UNION_SIN */
1726 #ifdef HAVE_RES_STATE_U_EXT_NSADDRS
1727         size_t i;
1728
1729         for (i = 0; i < (size_t)state->nscount; i++) {
1730                 if (state->_u._ext.nssocks[i] != -1) {
1731                         close(state->_u._ext.nssocks[i]);
1732                         state->_u._ext.nssocks[i] = -1;
1733                 }
1734                 SAFE_FREE(state->_u._ext.nsaddrs[i]);
1735         }
1736         memset(&state->_u._ext, 0, sizeof(state->_u._ext));
1737         for (i = 0; i < MAXNS; i++) {
1738                 state->_u._ext.nssocks[i] = -1;
1739                 state->_u._ext.nsmap[i] = MAXNS + 1;
1740         }
1741         state->ipv6_unavail = false;
1742 #endif
1743         memset(state->nsaddr_list, 0, sizeof(state->nsaddr_list));
1744         state->nscount = 0;
1745 #endif /* ! HAVE_RES_SOCKADDR_UNION_SIN */
1746 }
1747
1748 static int rwrap_set_nameservers(struct __res_state *state,
1749                                  size_t nserv,
1750                                  const union rwrap_sockaddr *nsaddrs)
1751 {
1752 #ifdef HAVE_RES_SOCKADDR_UNION_SIN
1753         union res_sockaddr_union set[MAXNS];
1754         size_t i;
1755
1756         memset(set, 0, sizeof(set));
1757
1758         if (nserv > MAXNS) {
1759                 nserv = MAXNS;
1760         }
1761
1762         rwrap_reset_nameservers(state);
1763
1764         for (i = 0; i < nserv; i++) {
1765                 switch (nsaddrs[i].sa.sa_family) {
1766                 case AF_INET:
1767                         set[i] = (union res_sockaddr_union) {
1768                                 .sin = nsaddrs[i].in,
1769                         };
1770                         break;
1771 #ifdef HAVE_RES_SOCKADDR_UNION_SIN6
1772                 case AF_INET6:
1773                         set[i] = (union res_sockaddr_union) {
1774                                 .sin6 = nsaddrs[i].in6,
1775                         };
1776                         break;
1777 #endif
1778                 default:
1779                         RWRAP_LOG(RWRAP_LOG_ERROR,
1780                                   "Internal error unhandled sa_family=%d",
1781                                   nsaddrs[i].sa.sa_family);
1782                         errno = ENOSYS;
1783                         return -1;
1784                 }
1785         }
1786
1787         res_setservers(state, set, nserv);
1788         return 0;
1789 #else /* ! HAVE_RES_SOCKADDR_UNION_SIN */
1790         size_t i;
1791
1792         if (nserv > MAXNS) {
1793                 nserv = MAXNS;
1794         }
1795         rwrap_reset_nameservers(state);
1796
1797         for (i = 0; i < nserv; i++) {
1798                 switch (nsaddrs[i].sa.sa_family) {
1799                 case AF_INET:
1800                         state->nsaddr_list[i] = nsaddrs[i].in;
1801                         break;
1802 #ifdef HAVE_RES_STATE_U_EXT_NSADDRS
1803                 case AF_INET6:
1804                         state->_u._ext.nsaddrs[i] = malloc(sizeof(nsaddrs[i].in6));
1805                         if (state->_u._ext.nsaddrs[i] == NULL) {
1806                                 rwrap_reset_nameservers(state);
1807                                 errno = ENOMEM;
1808                                 return -1;
1809                         }
1810                         *state->_u._ext.nsaddrs[i] = nsaddrs[i].in6;
1811                         state->_u._ext.nssocks[i] = -1;
1812                         state->_u._ext.nsmap[i] = MAXNS + 1;
1813                         state->_u._ext.nscount6++;
1814                         break;
1815 #endif
1816                 default:
1817                         RWRAP_LOG(RWRAP_LOG_ERROR,
1818                                   "Internal error unhandled sa_family=%d",
1819                                   nsaddrs[i].sa.sa_family);
1820                         rwrap_reset_nameservers(state);
1821                         errno = ENOSYS;
1822                         return -1;
1823                 }
1824         }
1825
1826         /*
1827          * note that state->_u._ext.nscount is left as 0,
1828          * this matches glibc and allows resolv wrapper
1829          * to work with most (maybe all) glibc versions.
1830          */
1831         state->nscount = i;
1832
1833         return 0;
1834 #endif /* ! HAVE_RES_SOCKADDR_UNION_SIN */
1835 }
1836
1837 static int rwrap_parse_resolv_conf(struct __res_state *state,
1838                                    const char *resolv_conf)
1839 {
1840         FILE *fp;
1841         char buf[BUFSIZ];
1842         size_t nserv = 0;
1843         union rwrap_sockaddr nsaddrs[MAXNS];
1844
1845         memset(nsaddrs, 0, sizeof(nsaddrs));
1846
1847         fp = fopen(resolv_conf, "r");
1848         if (fp == NULL) {
1849                 RWRAP_LOG(RWRAP_LOG_WARN,
1850                           "Opening %s failed: %s",
1851                           resolv_conf, strerror(errno));
1852                 return -1;
1853         }
1854
1855         while(fgets(buf, sizeof(buf), fp) != NULL) {
1856                 char *p;
1857
1858                 /* Ignore comments */
1859                 if (buf[0] == '#' || buf[0] == ';') {
1860                         continue;
1861                 }
1862
1863                 if (RESOLV_MATCH(buf, "nameserver") && nserv < MAXNS) {
1864                         struct in_addr a;
1865                         struct in6_addr a6;
1866                         char *q;
1867                         int ok;
1868
1869                         p = buf + strlen("nameserver");
1870
1871                         /* Skip spaces and tabs */
1872                         while(isblank((int)p[0])) {
1873                                 p++;
1874                         }
1875
1876                         q = p;
1877                         while(q[0] != '\n' && q[0] != '\0') {
1878                                 q++;
1879                         }
1880                         q[0] = '\0';
1881
1882                         ok = inet_pton(AF_INET, p, &a);
1883                         if (ok) {
1884                                 nsaddrs[nserv] = (union rwrap_sockaddr) {
1885                                         .in = {
1886                                                 .sin_family = AF_INET,
1887                                                 .sin_addr = a,
1888                                                 .sin_port = htons(53),
1889                                                 .sin_zero = { 0 },
1890                                         },
1891                                 };
1892
1893                                 nserv++;
1894                                 continue;
1895                         }
1896
1897                         ok = inet_pton(AF_INET6, p, &a6);
1898                         if (ok) {
1899 #ifdef HAVE_RESOLV_IPV6_NSADDRS
1900                                 nsaddrs[nserv] = (union rwrap_sockaddr) {
1901                                         .in6 = {
1902
1903                                                 .sin6_family = AF_INET6,
1904                                                 .sin6_port = htons(53),
1905                                                 .sin6_flowinfo = 0,
1906                                                 .sin6_addr = a6,
1907                                         },
1908                                 };
1909                                 nserv++;
1910                                 continue;
1911 #else /* !HAVE_RESOLV_IPV6_NSADDRS */
1912                                 RWRAP_LOG(RWRAP_LOG_WARN,
1913                                           "resolve_wrapper does not support "
1914                                           "IPv6 on this platform");
1915                                 continue;
1916 #endif
1917                         }
1918
1919                         RWRAP_LOG(RWRAP_LOG_ERROR, "Malformed DNS server[%s]", p);
1920                         continue;
1921                 } /* TODO: match other keywords */
1922         }
1923
1924         if (ferror(fp)) {
1925                 RWRAP_LOG(RWRAP_LOG_ERROR,
1926                           "Reading from %s failed",
1927                           resolv_conf);
1928                 fclose(fp);
1929                 return -1;
1930         }
1931
1932         fclose(fp);
1933
1934         if (nserv == 0) {
1935                 RWRAP_LOG(RWRAP_LOG_WARN,
1936                           "No usable nameservers found in %s",
1937                           resolv_conf);
1938                 errno = ESRCH;
1939                 return -1;
1940         }
1941
1942         return rwrap_set_nameservers(state, nserv, nsaddrs);
1943 }
1944
1945 /****************************************************************************
1946  *   RES_NINIT
1947  ***************************************************************************/
1948
1949 static int rwrap_res_ninit(struct __res_state *state)
1950 {
1951         int rc;
1952
1953         rc = libc_res_ninit(state);
1954         if (rc == 0) {
1955                 const char *resolv_conf = getenv("RESOLV_WRAPPER_CONF");
1956
1957                 if (resolv_conf != NULL) {
1958                         rc = rwrap_parse_resolv_conf(state, resolv_conf);
1959                 }
1960         }
1961
1962         return rc;
1963 }
1964
1965 #if !defined(res_ninit) && defined(HAVE_RES_NINIT)
1966 int res_ninit(struct __res_state *state)
1967 #elif defined(HAVE___RES_NINIT)
1968 int __res_ninit(struct __res_state *state)
1969 #endif
1970 {
1971         return rwrap_res_ninit(state);
1972 }
1973
1974 /****************************************************************************
1975  *   RES_INIT
1976  ***************************************************************************/
1977
1978 static struct __res_state rwrap_res_state;
1979
1980 static int rwrap_res_init(void)
1981 {
1982         int rc;
1983
1984         rc = rwrap_res_ninit(&rwrap_res_state);
1985
1986         return rc;
1987 }
1988
1989 #if !defined(res_ninit) && defined(HAVE_RES_INIT)
1990 int res_init(void)
1991 #elif defined(HAVE___RES_INIT)
1992 int __res_init(void)
1993 #endif
1994 {
1995         return rwrap_res_init();
1996 }
1997
1998 /****************************************************************************
1999  *   RES_NCLOSE
2000  ***************************************************************************/
2001
2002 static void rwrap_res_nclose(struct __res_state *state)
2003 {
2004         rwrap_reset_nameservers(state);
2005         libc_res_nclose(state);
2006 }
2007
2008 #if !defined(res_nclose) && defined(HAVE_RES_NCLOSE)
2009 void res_nclose(struct __res_state *state)
2010 #elif defined(HAVE___RES_NCLOSE)
2011 void __res_nclose(struct __res_state *state)
2012 #endif
2013 {
2014         rwrap_res_nclose(state);
2015 }
2016
2017 /****************************************************************************
2018  *   RES_CLOSE
2019  ***************************************************************************/
2020
2021 static void rwrap_res_close(void)
2022 {
2023         rwrap_res_nclose(&rwrap_res_state);
2024 }
2025
2026 #if defined(HAVE_RES_CLOSE)
2027 void res_close(void)
2028 #elif defined(HAVE___RES_CLOSE)
2029 void __res_close(void)
2030 #endif
2031 {
2032         rwrap_res_close();
2033 }
2034
2035 /****************************************************************************
2036  *   RES_NQUERY
2037  ***************************************************************************/
2038
2039 static int rwrap_res_nquery(struct __res_state *state,
2040                             const char *dname,
2041                             int class,
2042                             int type,
2043                             unsigned char *answer,
2044                             int anslen)
2045 {
2046         int rc;
2047         const char *fake_hosts;
2048
2049         RWRAP_LOG(RWRAP_LOG_TRACE,
2050                   "Resolve the domain name [%s] - class=%d, type=%d",
2051                   dname, class, type);
2052         rwrap_log_nameservers(RWRAP_LOG_TRACE, __func__, state);
2053
2054         fake_hosts = getenv("RESOLV_WRAPPER_HOSTS");
2055         if (fake_hosts != NULL) {
2056                 rc = rwrap_res_fake_hosts(fake_hosts, dname, type, answer, anslen);
2057         } else {
2058                 rc = libc_res_nquery(state, dname, class, type, answer, anslen);
2059         }
2060
2061
2062         RWRAP_LOG(RWRAP_LOG_TRACE,
2063                   "The returned response length is: %d",
2064                   rc);
2065
2066         return rc;
2067 }
2068
2069 #if !defined(res_nquery) && defined(HAVE_RES_NQUERY)
2070 int res_nquery(struct __res_state *state,
2071                const char *dname,
2072                int class,
2073                int type,
2074                unsigned char *answer,
2075                int anslen)
2076 #elif defined(HAVE___RES_NQUERY)
2077 int __res_nquery(struct __res_state *state,
2078                  const char *dname,
2079                  int class,
2080                  int type,
2081                  unsigned char *answer,
2082                  int anslen)
2083 #endif
2084 {
2085         return rwrap_res_nquery(state, dname, class, type, answer, anslen);
2086 }
2087
2088 /****************************************************************************
2089  *   RES_QUERY
2090  ***************************************************************************/
2091
2092 static int rwrap_res_query(const char *dname,
2093                            int class,
2094                            int type,
2095                            unsigned char *answer,
2096                            int anslen)
2097 {
2098         int rc;
2099
2100         rc = rwrap_res_ninit(&rwrap_res_state);
2101         if (rc != 0) {
2102                 return rc;
2103         }
2104
2105         rc = rwrap_res_nquery(&rwrap_res_state,
2106                               dname,
2107                               class,
2108                               type,
2109                               answer,
2110                               anslen);
2111
2112         return rc;
2113 }
2114
2115 #if !defined(res_query) && defined(HAVE_RES_QUERY)
2116 int res_query(const char *dname,
2117               int class,
2118               int type,
2119               unsigned char *answer,
2120               int anslen)
2121 #elif defined(HAVE___RES_QUERY)
2122 int __res_query(const char *dname,
2123                 int class,
2124                 int type,
2125                 unsigned char *answer,
2126                 int anslen)
2127 #endif
2128 {
2129         return rwrap_res_query(dname, class, type, answer, anslen);
2130 }
2131
2132 /****************************************************************************
2133  *   RES_NSEARCH
2134  ***************************************************************************/
2135
2136 static int rwrap_res_nsearch(struct __res_state *state,
2137                              const char *dname,
2138                              int class,
2139                              int type,
2140                              unsigned char *answer,
2141                              int anslen)
2142 {
2143         int rc;
2144         const char *fake_hosts;
2145
2146         RWRAP_LOG(RWRAP_LOG_TRACE,
2147                   "Resolve the domain name [%s] - class=%d, type=%d",
2148                   dname, class, type);
2149         rwrap_log_nameservers(RWRAP_LOG_TRACE, __func__, state);
2150
2151         fake_hosts = getenv("RESOLV_WRAPPER_HOSTS");
2152         if (fake_hosts != NULL) {
2153                 rc = rwrap_res_fake_hosts(fake_hosts, dname, type, answer, anslen);
2154         } else {
2155                 rc = libc_res_nsearch(state, dname, class, type, answer, anslen);
2156         }
2157
2158         RWRAP_LOG(RWRAP_LOG_TRACE,
2159                   "The returned response length is: %d",
2160                   rc);
2161
2162         return rc;
2163 }
2164
2165 #if !defined(res_nsearch) && defined(HAVE_RES_NSEARCH)
2166 int res_nsearch(struct __res_state *state,
2167                 const char *dname,
2168                 int class,
2169                 int type,
2170                 unsigned char *answer,
2171                 int anslen)
2172 #elif defined(HAVE___RES_NSEARCH)
2173 int __res_nsearch(struct __res_state *state,
2174                   const char *dname,
2175                   int class,
2176                   int type,
2177                   unsigned char *answer,
2178                   int anslen)
2179 #endif
2180 {
2181         return rwrap_res_nsearch(state, dname, class, type, answer, anslen);
2182 }
2183
2184 /****************************************************************************
2185  *   RES_SEARCH
2186  ***************************************************************************/
2187
2188 static int rwrap_res_search(const char *dname,
2189                             int class,
2190                             int type,
2191                             unsigned char *answer,
2192                             int anslen)
2193 {
2194         int rc;
2195
2196         rc = rwrap_res_ninit(&rwrap_res_state);
2197         if (rc != 0) {
2198                 return rc;
2199         }
2200
2201         rc = rwrap_res_nsearch(&rwrap_res_state,
2202                                dname,
2203                                class,
2204                                type,
2205                                answer,
2206                                anslen);
2207
2208         return rc;
2209 }
2210
2211 #if !defined(res_search) && defined(HAVE_RES_SEARCH)
2212 int res_search(const char *dname,
2213                int class,
2214                int type,
2215                unsigned char *answer,
2216                int anslen)
2217 #elif defined(HAVE___RES_SEARCH)
2218 int __res_search(const char *dname,
2219                  int class,
2220                  int type,
2221                  unsigned char *answer,
2222                  int anslen)
2223 #endif
2224 {
2225         return rwrap_res_search(dname, class, type, answer, anslen);
2226 }