Annotation of embedaddon/iftop/resolver.c, revision 1.1.1.1
1.1 misho 1: /*
2: * resolver.c:
3: *
4: */
5:
6: #include <sys/types.h>
7: #include <sys/socket.h>
8: #include <netinet/in.h>
9: #include <arpa/inet.h>
10: #include <pthread.h>
11: #include <stdio.h>
12: #include <stdlib.h>
13: #include <netdb.h>
14: #include <errno.h>
15: #include <string.h>
16: #include <unistd.h>
17:
18: #include "ns_hash.h"
19: #include "iftop.h"
20:
21: #include "threadprof.h"
22:
23: #include "options.h"
24:
25:
26: #define RESOLVE_QUEUE_LENGTH 20
27:
28: struct in_addr resolve_queue[RESOLVE_QUEUE_LENGTH];
29:
30: pthread_cond_t resolver_queue_cond;
31: pthread_mutex_t resolver_queue_mutex;
32:
33: hash_type* ns_hash;
34:
35: int head;
36: int tail;
37:
38: extern options_t options;
39:
40:
41: /*
42: * We have a choice of resolver methods. Real computers have getnameinfo or
43: * gethostbyaddr_r, which are reentrant and therefore thread safe. Other
44: * machines don't, and so we can use non-reentrant gethostbyaddr and have only
45: * one resolver thread. Alternatively, we can use the MIT ares asynchronous
46: * DNS library to do this.
47: */
48:
49: #if defined(USE_GETNAMEINFO)
50: /**
51: * Implementation of do_resolve for platforms with getaddrinfo.
52: *
53: * This is a fairly sane function with a uniform interface which is even --
54: * shock! -- standardised by POSIX and in RFC 2553. Unfortunately systems such
55: * as NetBSD break the RFC and implement it in a non-thread-safe fashion, so
56: * for the moment, the configure script won't try to use it.
57: */
58: char *do_resolve(struct in_addr *addr) {
59: struct sockaddr_in sin = {0};
60: char buf[NI_MAXHOST]; /* 1025 */
61: int res;
62: sin.sin_family = AF_INET;
63: sin.sin_addr = *addr;
64: sin.sin_port = 0;
65:
66: if (getnameinfo((struct sockaddr*)&sin, sizeof sin, buf, sizeof buf, NULL, 0, NI_NAMEREQD) == 0)
67: return xstrdup(buf);
68: else
69: return NULL;
70: }
71:
72: #elif defined(USE_GETHOSTBYADDR_R)
73: /**
74: * Implementation of do_resolve for platforms with working gethostbyaddr_r
75: *
76: * Some implementations of libc choose to implement gethostbyaddr_r as
77: * a non thread-safe wrapper to gethostbyaddr. An interesting choice...
78: */
79: char* do_resolve(struct in_addr * addr) {
80: struct hostent hostbuf, *hp;
81: size_t hstbuflen = 1024;
82: char *tmphstbuf;
83: int res;
84: int herr;
85: char * ret = NULL;
86:
87: /* Allocate buffer, remember to free it to avoid memory leakage. */
88: tmphstbuf = xmalloc (hstbuflen);
89:
90: /* Some machines have gethostbyaddr_r returning an integer error code; on
91: * others, it returns a struct hostent*. */
92: #ifdef GETHOSTBYADDR_R_RETURNS_INT
93: while ((res = gethostbyaddr_r((char*)addr, sizeof(struct in_addr), AF_INET,
94: &hostbuf, tmphstbuf, hstbuflen,
95: &hp, &herr)) == ERANGE)
96: #else
97: /* ... also assume one fewer argument.... */
98: while ((hp = gethostbyaddr_r((char*)addr, sizeof(struct in_addr), AF_INET,
99: &hostbuf, tmphstbuf, hstbuflen, &herr)) == NULL
100: && errno == ERANGE)
101: #endif
102: {
103:
104: /* Enlarge the buffer. */
105: hstbuflen *= 2;
106: tmphstbuf = realloc (tmphstbuf, hstbuflen);
107: }
108:
109: /* Check for errors. */
110: if (res || hp == NULL) {
111: /* failed */
112: /* Leave the unresolved IP in the hash */
113: }
114: else {
115: ret = xstrdup(hp->h_name);
116:
117: }
118: xfree(tmphstbuf);
119: return ret;
120: }
121:
122: #elif defined(USE_GETHOSTBYADDR)
123:
124: /**
125: * Implementation using gethostbyname. Since this is nonreentrant, we have to
126: * wrap it in a mutex, losing all benefit of multithreaded resolution.
127: */
128: char *do_resolve(struct in_addr *addr) {
129: static pthread_mutex_t ghba_mtx = PTHREAD_MUTEX_INITIALIZER;
130: char *s = NULL;
131: struct hostent *he;
132: pthread_mutex_lock(&ghba_mtx);
133: he = gethostbyaddr((char*)addr, sizeof *addr, AF_INET);
134: if (he)
135: s = xstrdup(he->h_name);
136: pthread_mutex_unlock(&ghba_mtx);
137: return s;
138: }
139:
140:
141: #elif defined(USE_LIBRESOLV)
142:
143: #include <arpa/nameser.h>
144: #include <resolv.h>
145:
146: /**
147: * libresolv implementation
148: * resolver functions may not be thread safe
149: */
150: char* do_resolve(struct in_addr * addr) {
151: char msg[PACKETSZ];
152: char s[35];
153: int l;
154: unsigned char* a;
155: char * ret = NULL;
156:
157: a = (unsigned char*)addr;
158:
159: snprintf(s, 35, "%d.%d.%d.%d.in-addr.arpa.",a[3], a[2], a[1], a[0]);
160:
161: l = res_search(s, C_IN, T_PTR, msg, PACKETSZ);
162: if(l != -1) {
163: ns_msg nsmsg;
164: ns_rr rr;
165: if(ns_initparse(msg, l, &nsmsg) != -1) {
166: int c;
167: int i;
168: c = ns_msg_count(nsmsg, ns_s_an);
169: for(i = 0; i < c; i++) {
170: if(ns_parserr(&nsmsg, ns_s_an, i, &rr) == 0){
171: if(ns_rr_type(rr) == T_PTR) {
172: char buf[256];
173: ns_name_uncompress(msg, msg + l, ns_rr_rdata(rr), buf, 256);
174: ret = xstrdup(buf);
175: }
176: }
177: }
178: }
179: }
180: return ret;
181: }
182:
183: #elif defined(USE_ARES)
184:
185: /**
186: * ares implementation
187: */
188:
189: #include <sys/time.h>
190: #include <ares.h>
191: #include <arpa/nameser.h>
192:
193: /* callback function for ares */
194: struct ares_callback_comm {
195: struct in_addr *addr;
196: int result;
197: char *name;
198: };
199:
200: static void do_resolve_ares_callback(void *arg, int status, unsigned char *abuf, int alen) {
201: struct hostent *he;
202: struct ares_callback_comm *C;
203: C = (struct ares_callback_comm*)arg;
204:
205: if (status == ARES_SUCCESS) {
206: C->result = 1;
207: ares_parse_ptr_reply(abuf, alen, C->addr, sizeof *C->addr, AF_INET, &he);
208: C->name = xstrdup(he->h_name);;
209: ares_free_hostent(he);
210: } else {
211: C->result = -1;
212: }
213: }
214:
215: char *do_resolve(struct in_addr * addr) {
216: struct ares_callback_comm C;
217: char s[35];
218: unsigned char *a;
219: ares_channel *chan;
220: static pthread_mutex_t ares_init_mtx = PTHREAD_MUTEX_INITIALIZER;
221: static pthread_key_t ares_key;
222: static int gotkey;
223:
224: /* Make sure we have an ARES channel for this thread. */
225: pthread_mutex_lock(&ares_init_mtx);
226: if (!gotkey) {
227: pthread_key_create(&ares_key, NULL);
228: gotkey = 1;
229:
230: }
231: pthread_mutex_unlock(&ares_init_mtx);
232:
233: chan = pthread_getspecific(ares_key);
234: if (!chan) {
235: chan = xmalloc(sizeof *chan);
236: pthread_setspecific(ares_key, chan);
237: if (ares_init(chan) != ARES_SUCCESS) return NULL;
238: }
239:
240: a = (unsigned char*)addr;
241: sprintf(s, "%d.%d.%d.%d.in-addr.arpa.", a[3], a[2], a[1], a[0]);
242:
243: C.result = 0;
244: C.addr = addr;
245: ares_query(*chan, s, C_IN, T_PTR, do_resolve_ares_callback, &C);
246: while (C.result == 0) {
247: int n;
248: fd_set readfds, writefds;
249: struct timeval tv;
250: FD_ZERO(&readfds);
251: FD_ZERO(&writefds);
252: n = ares_fds(*chan, &readfds, &writefds);
253: ares_timeout(*chan, NULL, &tv);
254: select(n, &readfds, &writefds, NULL, &tv);
255: ares_process(*chan, &readfds, &writefds);
256: }
257:
258: /* At this stage, the query should be complete. */
259: switch (C.result) {
260: case -1:
261: case 0: /* shouldn't happen */
262: return NULL;
263:
264: default:
265: return C.name;
266: }
267: }
268:
269: #elif defined(USE_FORKING_RESOLVER)
270:
271: /**
272: * Resolver which forks a process, then uses gethostbyname.
273: */
274:
275: #include <signal.h>
276:
277: #define NAMESIZE 64
278:
279: int forking_resolver_worker(int fd) {
280: while (1) {
281: struct in_addr a;
282: struct hostent *he;
283: char buf[NAMESIZE] = {0};
284: if (read(fd, &a, sizeof a) != sizeof a)
285: return -1;
286:
287: he = gethostbyaddr((char*)&a, sizeof a, AF_INET);
288: if (he)
289: strncpy(buf, he->h_name, NAMESIZE - 1);
290:
291: if (write(fd, buf, NAMESIZE) != NAMESIZE)
292: return -1;
293: }
294: }
295:
296: char *do_resolve(struct in_addr *addr) {
297: struct {
298: int fd;
299: pid_t child;
300: } *workerinfo;
301: char name[NAMESIZE];
302: static pthread_mutex_t worker_init_mtx = PTHREAD_MUTEX_INITIALIZER;
303: static pthread_key_t worker_key;
304: static int gotkey;
305:
306: /* If no process exists, we need to spawn one. */
307: pthread_mutex_lock(&worker_init_mtx);
308: if (!gotkey) {
309: pthread_key_create(&worker_key, NULL);
310: gotkey = 1;
311: }
312: pthread_mutex_unlock(&worker_init_mtx);
313:
314: workerinfo = pthread_getspecific(worker_key);
315: if (!workerinfo) {
316: int p[2];
317:
318: if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, p) == -1)
319: return NULL;
320:
321: workerinfo = xmalloc(sizeof *workerinfo);
322: pthread_setspecific(worker_key, workerinfo);
323: workerinfo->fd = p[0];
324:
325: switch (workerinfo->child = fork()) {
326: case 0:
327: close(p[0]);
328: _exit(forking_resolver_worker(p[1]));
329:
330: case -1:
331: close(p[0]);
332: close(p[1]);
333: return NULL;
334:
335: default:
336: close(p[1]);
337: }
338: }
339:
340: /* Now have a worker to which we can write requests. */
341: if (write(workerinfo->fd, addr, sizeof *addr) != sizeof *addr
342: || read(workerinfo->fd, name, NAMESIZE) != NAMESIZE) {
343: /* Something went wrong. Just kill the child and get on with it. */
344: kill(workerinfo->child, SIGKILL);
345: wait(NULL);
346: close(workerinfo->fd);
347: xfree(workerinfo);
348: pthread_setspecific(worker_key, NULL);
349: *name = 0;
350: }
351: if (!*name)
352: return NULL;
353: else
354: return xstrdup(name);
355: }
356:
357: #else
358:
359: # warning No name resolution method specified; name resolution will not work
360:
361: char *do_resolve(struct in_addr *addr) {
362: return NULL;
363: }
364:
365: #endif
366:
367: void resolver_worker(void* ptr) {
368: /* int thread_number = *(int*)ptr;*/
369: pthread_mutex_lock(&resolver_queue_mutex);
370: sethostent(1);
371: while(1) {
372: /* Wait until we are told that an address has been added to the
373: * queue. */
374: pthread_cond_wait(&resolver_queue_cond, &resolver_queue_mutex);
375:
376: /* Keep resolving until the queue is empty */
377: while(head != tail) {
378: char * hostname;
379: struct in_addr addr = resolve_queue[tail];
380:
381: /* mutex always locked at this point */
382:
383: tail = (tail + 1) % RESOLVE_QUEUE_LENGTH;
384:
385: pthread_mutex_unlock(&resolver_queue_mutex);
386:
387: hostname = do_resolve(&addr);
388:
389: /*
390: * Store the result in ns_hash
391: */
392: pthread_mutex_lock(&resolver_queue_mutex);
393:
394: if(hostname != NULL) {
395: char* old;
396: union {
397: char **ch_pp;
398: void **void_pp;
399: } u_old = { &old };
400: if(hash_find(ns_hash, &addr, u_old.void_pp) == HASH_STATUS_OK) {
401: hash_delete(ns_hash, &addr);
402: xfree(old);
403: }
404: hash_insert(ns_hash, &addr, (void*)hostname);
405: }
406:
407: }
408: }
409: }
410:
411: void resolver_initialise() {
412: int* n;
413: int i;
414: pthread_t thread;
415: head = tail = 0;
416:
417: ns_hash = ns_hash_create();
418:
419: pthread_mutex_init(&resolver_queue_mutex, NULL);
420: pthread_cond_init(&resolver_queue_cond, NULL);
421:
422: for(i = 0; i < 2; i++) {
423: n = (int*)xmalloc(sizeof *n);
424: *n = i;
425: pthread_create(&thread, NULL, (void*)&resolver_worker, (void*)n);
426: }
427:
428: }
429:
430: void resolve(struct in_addr* addr, char* result, int buflen) {
431: char* hostname;
432: union {
433: char **ch_pp;
434: void **void_pp;
435: } u_hostname = { &hostname };
436: int added = 0;
437:
438: if(options.dnsresolution == 1) {
439:
440: pthread_mutex_lock(&resolver_queue_mutex);
441:
442: if(hash_find(ns_hash, addr, u_hostname.void_pp) == HASH_STATUS_OK) {
443: /* Found => already resolved, or on the queue */
444: }
445: else {
446: hostname = strdup(inet_ntoa(*addr));
447: hash_insert(ns_hash, addr, hostname);
448:
449: if(((head + 1) % RESOLVE_QUEUE_LENGTH) == tail) {
450: /* queue full */
451: }
452: else {
453: resolve_queue[head] = *addr;
454: head = (head + 1) % RESOLVE_QUEUE_LENGTH;
455: added = 1;
456: }
457: }
458: pthread_mutex_unlock(&resolver_queue_mutex);
459:
460: if(added == 1) {
461: pthread_cond_signal(&resolver_queue_cond);
462: }
463:
464: if(result != NULL && buflen > 1) {
465: strncpy(result, hostname, buflen - 1);
466: result[buflen - 1] = '\0';
467: }
468: }
469: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to resolver.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / iftop