resolver.c 13.4 KB
Newer Older
pdw's avatar
pdw committed
1 2 3 4 5
/*
 * resolver.c:
 *
 */

pdw's avatar
pdw committed
6
#include <sys/types.h>
pdw's avatar
pdw committed
7
#include <sys/socket.h>
pdw's avatar
pdw committed
8
#include <netinet/in.h>
pdw's avatar
pdw committed
9 10 11 12 13 14 15
#include <arpa/inet.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <netdb.h>
#include <errno.h>
#include <string.h>
16
#include <unistd.h>
pdw's avatar
pdw committed
17 18

#include "ns_hash.h"
chris's avatar
chris committed
19
#include "iftop.h"
pdw's avatar
pdw committed
20

pdw's avatar
pdw committed
21 22
#include "threadprof.h"

23
#include "options.h"
pdw's avatar
pdw committed
24 25


pdw's avatar
pdw committed
26 27
#define RESOLVE_QUEUE_LENGTH 20

28 29 30 31 32 33 34 35 36 37 38 39
struct addr_storage {
    int af;                     /* AF_INET or AF_INET6 */
    int len;                    /* sizeof(struct in_addr or in6_addr) */
    union {
        struct in_addr  addr4;
        struct in6_addr addr6;
    } addr;
#define as_addr4 addr.addr4
#define as_addr6 addr.addr6
};

struct addr_storage resolve_queue[RESOLVE_QUEUE_LENGTH];
pdw's avatar
pdw committed
40 41 42 43 44 45 46 47 48

pthread_cond_t resolver_queue_cond;
pthread_mutex_t resolver_queue_mutex;

hash_type* ns_hash;

int head;
int tail;

49 50
extern options_t options;

pdw's avatar
pdw committed
51

chris's avatar
chris committed
52
/* 
chris's avatar
chris committed
53 54 55 56 57
 * We have a choice of resolver methods. Real computers have getnameinfo or
 * gethostbyaddr_r, which are reentrant and therefore thread safe. Other
 * machines don't, and so we can use non-reentrant gethostbyaddr and have only
 * one resolver thread.  Alternatively, we can use the MIT ares asynchronous
 * DNS library to do this.
chris's avatar
chris committed
58 59
 */

chris's avatar
chris committed
60 61 62 63 64 65 66 67 68
#if defined(USE_GETNAMEINFO)
/**
 * Implementation of do_resolve for platforms with getaddrinfo.
 *
 * This is a fairly sane function with a uniform interface which is even --
 * shock! -- standardised by POSIX and in RFC 2553. Unfortunately systems such
 * as NetBSD break the RFC and implement it in a non-thread-safe fashion, so
 * for the moment, the configure script won't try to use it.
 */
69
char *do_resolve(struct addr_storage *addr) {
70 71
    struct sockaddr_in sin;
    struct sockaddr_in6 sin6;
chris's avatar
chris committed
72
    char buf[NI_MAXHOST]; /* 1025 */
73
    int ret;
pdw's avatar
pdw committed
74

75
    switch (addr->af) {
76
        case AF_INET:
77
            sin.sin_family = addr->af;
78
            sin.sin_port = 0;
79
            memcpy(&sin.sin_addr, &addr->as_addr4, addr->len);
80

81 82
            ret = getnameinfo((struct sockaddr*)&sin, sizeof sin,
                              buf, sizeof buf, NULL, 0, NI_NAMEREQD);
83 84
            break;
        case AF_INET6:
85
            sin6.sin6_family = addr->af;
86
            sin6.sin6_port = 0;
87
            memcpy(&sin6.sin6_addr, &addr->as_addr6, addr->len);
88

89 90 91
            ret = getnameinfo((struct sockaddr*)&sin6, sizeof sin6,
                              buf, sizeof buf, NULL, 0, NI_NAMEREQD);
	    break;
92 93 94
        default:
            return NULL;
    }
95 96 97 98 99

    if (ret == 0)
        return xstrdup(buf);
    else
        return NULL;
chris's avatar
chris committed
100 101 102
}

#elif defined(USE_GETHOSTBYADDR_R)
pdw's avatar
pdw committed
103 104
/**
 * Implementation of do_resolve for platforms with working gethostbyaddr_r
pdw's avatar
pdw committed
105 106 107
 *
 * Some implementations of libc choose to implement gethostbyaddr_r as
 * a non thread-safe wrapper to gethostbyaddr.  An interesting choice...
pdw's avatar
pdw committed
108
 */
109
char* do_resolve(struct addr_storage *addr) {
pdw's avatar
pdw committed
110 111 112 113 114 115 116
    struct hostent hostbuf, *hp;
    size_t hstbuflen = 1024;
    char *tmphstbuf;
    int res;
    int herr;
    char * ret = NULL;

117
    /* Allocate buffer, remember to free it to avoid memory leakage. */
pdw's avatar
pdw committed
118 119
    tmphstbuf = xmalloc (hstbuflen);

chris's avatar
chris committed
120 121 122
    /* Some machines have gethostbyaddr_r returning an integer error code; on
     * others, it returns a struct hostent*. */
#ifdef GETHOSTBYADDR_R_RETURNS_INT
123
    while ((res = gethostbyaddr_r((char*)&addr->addr, addr->len, addr->af,
chris's avatar
chris committed
124 125 126 127
                                  &hostbuf, tmphstbuf, hstbuflen,
                                  &hp, &herr)) == ERANGE)
#else
    /* ... also assume one fewer argument.... */
128 129
    while ((hp = gethostbyaddr_r((char*)&addr->addr, addr->len, addr->af,
                                 &hostbuf, tmphstbuf, hstbuflen, &herr)) == NULL
chris's avatar
chris committed
130 131 132 133
            && errno == ERANGE)
#endif
            {
        
pdw's avatar
pdw committed
134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
        /* Enlarge the buffer.  */
        hstbuflen *= 2;
        tmphstbuf = realloc (tmphstbuf, hstbuflen);
      }

    /*  Check for errors.  */
    if (res || hp == NULL) {
        /* failed */
        /* Leave the unresolved IP in the hash */
    }
    else {
        ret = xstrdup(hp->h_name);

    }
    xfree(tmphstbuf);
    return ret;
}

chris's avatar
chris committed
152 153 154
#elif defined(USE_GETHOSTBYADDR)

/**
155
 * Implementation using gethostbyname. Since this is nonreentrant, we have to
chris's avatar
chris committed
156 157
 * wrap it in a mutex, losing all benefit of multithreaded resolution.
 */
158
char *do_resolve(struct addr_storage *addr) {
chris's avatar
chris committed
159 160 161 162
    static pthread_mutex_t ghba_mtx = PTHREAD_MUTEX_INITIALIZER;
    char *s = NULL;
    struct hostent *he;
    pthread_mutex_lock(&ghba_mtx);
163
    he = gethostbyaddr((char*)&addr->addr, addr->len, addr->af);
chris's avatar
chris committed
164 165 166 167 168 169
    if (he)
        s = xstrdup(he->h_name);
    pthread_mutex_unlock(&ghba_mtx);
    return s;
}

170

chris's avatar
chris committed
171 172 173 174
#elif defined(USE_LIBRESOLV)

#include <arpa/nameser.h>
#include <resolv.h>
pdw's avatar
pdw committed
175 176

/**
pdw's avatar
pdw committed
177 178
 * libresolv implementation 
 * resolver functions may not be thread safe
pdw's avatar
pdw committed
179
 */
180
char* do_resolve(struct addr_storage *addr) {
pdw's avatar
pdw committed
181 182 183 184 185 186
  char msg[PACKETSZ];
  char s[35];
  int l;
  unsigned char* a;
  char * ret = NULL;

187 188 189 190
  if (addr->af != AF_INET)
    return NULL;

  a = (unsigned char*)&addr->addr;
pdw's avatar
pdw committed
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214

  snprintf(s, 35, "%d.%d.%d.%d.in-addr.arpa.",a[3], a[2], a[1], a[0]);

  l = res_search(s, C_IN, T_PTR, msg, PACKETSZ);
  if(l != -1) {
    ns_msg nsmsg;
    ns_rr rr;
    if(ns_initparse(msg, l, &nsmsg) != -1) {
      int c;
      int i;
      c = ns_msg_count(nsmsg, ns_s_an);
      for(i = 0; i < c; i++) {
        if(ns_parserr(&nsmsg, ns_s_an, i, &rr) == 0){
          if(ns_rr_type(rr) == T_PTR) {
            char buf[256];
            ns_name_uncompress(msg, msg + l, ns_rr_rdata(rr), buf, 256);
            ret = xstrdup(buf);
          }
        }
      }
    }
  }
  return ret;
}
chris's avatar
chris committed
215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247

#elif defined(USE_ARES)

/**
 * ares implementation
 */

#include <sys/time.h>
#include <ares.h>
#include <arpa/nameser.h>

/* callback function for ares */
struct ares_callback_comm {
    struct in_addr *addr;
    int result;
    char *name;
};

static void do_resolve_ares_callback(void *arg, int status, unsigned char *abuf, int alen) {
    struct hostent *he;
    struct ares_callback_comm *C;
    C = (struct ares_callback_comm*)arg;

    if (status == ARES_SUCCESS) {
        C->result = 1;
        ares_parse_ptr_reply(abuf, alen, C->addr, sizeof *C->addr, AF_INET, &he);
        C->name = xstrdup(he->h_name);;
        ares_free_hostent(he);
    } else {
        C->result = -1;
    }
}

248
char *do_resolve(struct addr_storage * addr) {
chris's avatar
chris committed
249 250 251 252 253 254 255 256
    struct ares_callback_comm C;
    char s[35];
    unsigned char *a;
    ares_channel *chan;
    static pthread_mutex_t ares_init_mtx = PTHREAD_MUTEX_INITIALIZER;
    static pthread_key_t ares_key;
    static int gotkey;

257 258 259
    if (addr->af != AF_INET)
        return NULL;

chris's avatar
chris committed
260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275
    /* Make sure we have an ARES channel for this thread. */
    pthread_mutex_lock(&ares_init_mtx);
    if (!gotkey) {
        pthread_key_create(&ares_key, NULL);
        gotkey = 1;
        
    }
    pthread_mutex_unlock(&ares_init_mtx);
    
    chan = pthread_getspecific(ares_key);
    if (!chan) {
        chan = xmalloc(sizeof *chan);
        pthread_setspecific(ares_key, chan);
        if (ares_init(chan) != ARES_SUCCESS) return NULL;
    }
    
276
    a = (unsigned char*)&addr->as_addr4;
chris's avatar
chris committed
277 278 279
    sprintf(s, "%d.%d.%d.%d.in-addr.arpa.", a[3], a[2], a[1], a[0]);
    
    C.result = 0;
280
    C.addr = &addr->as_addr4;
chris's avatar
chris committed
281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304
    ares_query(*chan, s, C_IN, T_PTR, do_resolve_ares_callback, &C);
    while (C.result == 0) {
        int n;
        fd_set readfds, writefds;
        struct timeval tv;
        FD_ZERO(&readfds);
        FD_ZERO(&writefds);
        n = ares_fds(*chan, &readfds, &writefds);
        ares_timeout(*chan, NULL, &tv);
        select(n, &readfds, &writefds, NULL, &tv);
        ares_process(*chan, &readfds, &writefds);
    }

    /* At this stage, the query should be complete. */
    switch (C.result) {
        case -1:
        case 0:     /* shouldn't happen */
            return NULL;

        default:
            return C.name;
    }
}

pdw's avatar
pdw committed
305 306 307
#elif defined(USE_FORKING_RESOLVER)

/**
pdw's avatar
pdw committed
308
 * Resolver which forks a process, then uses gethostbyname.
pdw's avatar
pdw committed
309 310 311 312 313 314 315 316
 */

#include <signal.h>

#define NAMESIZE        64

int forking_resolver_worker(int fd) {
    while (1) {
317
        struct addr_storage a;
pdw's avatar
pdw committed
318 319 320 321 322
        struct hostent *he;
        char buf[NAMESIZE] = {0};
        if (read(fd, &a, sizeof a) != sizeof a)
            return -1;

323
        he = gethostbyaddr((char*)&a.addr, a.len, a.af);
pdw's avatar
pdw committed
324 325 326 327 328 329 330 331
        if (he)
            strncpy(buf, he->h_name, NAMESIZE - 1);

        if (write(fd, buf, NAMESIZE) != NAMESIZE)
            return -1;
    }
}

332
char *do_resolve(struct in6_addr *addr) {
pdw's avatar
pdw committed
333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353
    struct {
        int fd;
        pid_t child;
    } *workerinfo;
    char name[NAMESIZE];
    static pthread_mutex_t worker_init_mtx = PTHREAD_MUTEX_INITIALIZER;
    static pthread_key_t worker_key;
    static int gotkey;

    /* If no process exists, we need to spawn one. */
    pthread_mutex_lock(&worker_init_mtx);
    if (!gotkey) {
        pthread_key_create(&worker_key, NULL);
        gotkey = 1;
    }
    pthread_mutex_unlock(&worker_init_mtx);
    
    workerinfo = pthread_getspecific(worker_key);
    if (!workerinfo) {
        int p[2];

chris's avatar
chris committed
354
        if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, p) == -1)
pdw's avatar
pdw committed
355 356 357 358 359
            return NULL;

        workerinfo = xmalloc(sizeof *workerinfo);
        pthread_setspecific(worker_key, workerinfo);
        workerinfo->fd = p[0];
chris's avatar
chris committed
360
        
pdw's avatar
pdw committed
361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380
        switch (workerinfo->child = fork()) {
            case 0:
                close(p[0]);
                _exit(forking_resolver_worker(p[1]));

            case -1:
                close(p[0]);
                close(p[1]);
                return NULL;

            default:
                close(p[1]);
        }
    }

    /* Now have a worker to which we can write requests. */
    if (write(workerinfo->fd, addr, sizeof *addr) != sizeof *addr
        || read(workerinfo->fd, name, NAMESIZE) != NAMESIZE) {
        /* Something went wrong. Just kill the child and get on with it. */
        kill(workerinfo->child, SIGKILL);
chris's avatar
chris committed
381
        wait(NULL);
pdw's avatar
pdw committed
382 383 384
        close(workerinfo->fd);
        xfree(workerinfo);
        pthread_setspecific(worker_key, NULL);
chris's avatar
chris committed
385
        *name = 0;
pdw's avatar
pdw committed
386 387 388 389 390 391 392
    }
    if (!*name)
        return NULL;
    else
        return xstrdup(name);
}

chris's avatar
chris committed
393 394 395 396
#else

#   warning No name resolution method specified; name resolution will not work

397
char *do_resolve(struct addr_storage *addr) {
chris's avatar
chris committed
398 399 400
    return NULL;
}

pdw's avatar
pdw committed
401 402
#endif

pdw's avatar
pdw committed
403
void resolver_worker(void* ptr) {
chris's avatar
chris committed
404
/*    int thread_number = *(int*)ptr;*/
405
    pthread_mutex_lock(&resolver_queue_mutex);
chris's avatar
chris committed
406
    sethostent(1);
pdw's avatar
pdw committed
407 408
    while(1) {
        /* Wait until we are told that an address has been added to the 
chris's avatar
chris committed
409
         * queue. */
pdw's avatar
pdw committed
410 411 412 413
        pthread_cond_wait(&resolver_queue_cond, &resolver_queue_mutex);

        /* Keep resolving until the queue is empty */
        while(head != tail) {
pdw's avatar
pdw committed
414
            char * hostname;
415
            struct addr_storage addr = resolve_queue[tail];
pdw's avatar
pdw committed
416 417 418 419 420

            /* mutex always locked at this point */

            tail = (tail + 1) % RESOLVE_QUEUE_LENGTH;

421 422
            pthread_mutex_unlock(&resolver_queue_mutex);

pdw's avatar
pdw committed
423
            hostname = do_resolve(&addr);
pdw's avatar
pdw committed
424 425 426 427

            /*
             * Store the result in ns_hash
             */
428
            pthread_mutex_lock(&resolver_queue_mutex);
pdw's avatar
pdw committed
429

pdw's avatar
pdw committed
430 431
            if(hostname != NULL) {
                char* old;
432 433 434 435 436
		union {
		    char **ch_pp;
		    void **void_pp;
		} u_old = { &old };
                if(hash_find(ns_hash, &addr, u_old.void_pp) == HASH_STATUS_OK) {
pdw's avatar
pdw committed
437
                    hash_delete(ns_hash, &addr);
pdw's avatar
pdw committed
438
                    xfree(old);
pdw's avatar
pdw committed
439 440 441
                }
                hash_insert(ns_hash, &addr, (void*)hostname);
            }
pdw's avatar
pdw committed
442

pdw's avatar
pdw committed
443 444 445 446 447
        }
    }
}

void resolver_initialise() {
448 449
    int* n;
    int i;
pdw's avatar
pdw committed
450 451 452 453 454 455 456 457
    pthread_t thread;
    head = tail = 0;

    ns_hash = ns_hash_create();
    
    pthread_mutex_init(&resolver_queue_mutex, NULL);
    pthread_cond_init(&resolver_queue_cond, NULL);

458
    for(i = 0; i < 2; i++) {
chris's avatar
chris committed
459
        n = (int*)xmalloc(sizeof *n);
460 461 462
        *n = i;
        pthread_create(&thread, NULL, (void*)&resolver_worker, (void*)n);
    }
pdw's avatar
pdw committed
463 464 465

}

466
void resolve(int af, void* addr, char* result, int buflen) {
pdw's avatar
pdw committed
467
    char* hostname;
468 469 470 471
    union {
	char **ch_pp;
	void **void_pp;
    } u_hostname = { &hostname };
472
    int added = 0;
473 474 475 476 477 478 479 480
    struct addr_storage *raddr;

    raddr = malloc(sizeof *raddr);
    memset(raddr, 0, sizeof *raddr);
    raddr->af = af;
    raddr->len = (af == AF_INET ? sizeof(struct in_addr)
                  : sizeof(struct in6_addr));
    memcpy(&raddr->addr, addr, raddr->len);
pdw's avatar
pdw committed
481

482
    if(options.dnsresolution == 1) {
pdw's avatar
pdw committed
483

484
        pthread_mutex_lock(&resolver_queue_mutex);
pdw's avatar
pdw committed
485

486 487 488 489
        if(hash_find(ns_hash, raddr, u_hostname.void_pp) == HASH_STATUS_OK) {
            /* Found => already resolved, or on the queue, no need to keep
	     * it around */
            free(raddr);
pdw's avatar
pdw committed
490 491
        }
        else {
492
            hostname = xmalloc(INET6_ADDRSTRLEN);
493 494 495
            inet_ntop(af, &raddr->addr, hostname, INET6_ADDRSTRLEN);

            hash_insert(ns_hash, raddr, hostname);
496 497 498 499

            if(((head + 1) % RESOLVE_QUEUE_LENGTH) == tail) {
                /* queue full */
            }
500 501 502
            else if ((af == AF_INET6)
                     && (IN6_IS_ADDR_LINKLOCAL(&raddr->as_addr6)
                         || IN6_IS_ADDR_SITELOCAL(&raddr->as_addr6))) {
503 504
                /* Link-local and site-local stay numerical. */
            }
505
            else {
506
                resolve_queue[head] = *raddr;
507 508 509
                head = (head + 1) % RESOLVE_QUEUE_LENGTH;
                added = 1;
            }
pdw's avatar
pdw committed
510
        }
511
        pthread_mutex_unlock(&resolver_queue_mutex);
512

513 514 515
        if(added == 1) {
            pthread_cond_signal(&resolver_queue_cond);
        }
pdw's avatar
pdw committed
516

517 518 519 520
        if(result != NULL && buflen > 1) {
            strncpy(result, hostname, buflen - 1);
            result[buflen - 1] = '\0';
        }
pdw's avatar
pdw committed
521 522
    }
}