EmuProxyZA / tivodns.c

From TivoZA

Back to emuProxyZA.
Download source (You will need to rename it to: tivodns.c)

To update the below source file, select Upload file and upload your new tivodns.c file (there is no need to upload it as a .txt). If you do upload a new version, please add a brief description to the change log at the bottom of this page indicating what changes you made and why.

[edit]

Source

  1. /*
  3. tivodns.c - tivodns library declarations
  4. Copyright (C) 2003 Christopher R. Wingert
  6. firedns.c - firedns library
  7. Copyright (C) 2002 Ian Gulliver
  9. This program is free software; you can redistribute it and/or modify
  10. it under the terms of version 2 of the GNU General Public License as
  11. published by the Free Software Foundation.
  13. This program is distributed in the hope that it will be useful,
  14. but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. GNU General Public License for more details.
  18. You should have received a copy of the GNU General Public License
  19. along with this program; if not, write to the Free Software
  20. Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21. */
  22.  
  23. #include <stdlib.h>
  24. #include <time.h>
  25. #include <sys/types.h>
  26. #include <sys/socket.h>
  27. #include <sys/time.h>
  28. #include <string.h>
  29. #include <unistd.h>
  30. #include <stdio.h>
  31. #include <errno.h>
  32. #include <fcntl.h>
  33. #include "tivodns.h"
  34.  
  35. #ifdef TIVO
  36. int snprintf(char *str, size_t size, const char *format, ...);
  37. #endif
  38.  
  39. static const char tagstring[] = "$Id: tivodns.c,v 1.60 2004/01/03 23:30:49 ian Exp $";
  40.  
  41. #define tivodns_TRIES 3
  42. #define RESULTSIZE 1024
  43. #define min(a,b) (a < b ? a : b)
  44.  
  45. static struct in_addr servers4[FDNS_MAX]; /* up to FDNS_MAX nameservers; populated by tivodns_init() */
  46. static int i4; /* actual count of nameservers; set by tivodns_init() */
  47. #ifdef tivodns_USE_IPV6
  48. static int i6;
  49. static struct in6_addr servers6[FDNS_MAX];
  50. #endif
  51.  
  52. static int initdone = 0; /* to ensure tivodns_init() only runs once (on the first call) */
  53. static int wantclose = 0;
  54. static int lastcreate = -1;
  55.  
  56. struct s_connection { /* open DNS query */
  57. 	struct s_connection *next; /* next in list */
  58. 	unsigned char id[2]; /* unique ID (random number), matches header ID; both set by tivodns_add_query() */
  59. 	unsigned short class;
  60. 	unsigned short type;
  61. 	int want_list;
  62. 	int fd; /* file descriptor returned from sockets */
  63. #ifdef tivodns_USE_IPV6
  64. 	int v6;
  65. #endif
  66. };
  67.  
  68. static char resolv_conf[ 255 ] = FDNS_CONFIG_PREF;
  69.  
  70. struct s_rr_middle {
  71. 	unsigned short type;
  72. 	unsigned short class;
  73. 	unsigned long ttl;
  74. 	unsigned short rdlength;
  75. };
  76.  
  77. #define tivodns_POINTER_VALUE 0xc000
  78.  
  79. #define MY_PTHREAD_MUTEX_INITIALIZER  ( -1 )
  80. typedef int my_pthread_mutex_t;
  81.  
  82. static my_pthread_mutex_t connlist_lock = MY_PTHREAD_MUTEX_INITIALIZER;
  83. static struct s_connection *connection_head = NULL; /* linked list of open DNS queries; populated by tivodns_add_query(), decimated by tivodns_getresult_s() */
  84.  
  85. struct s_header { /* DNS query header */
  86. 	unsigned char id[2];
  87. 	unsigned char flags1;
  88. #define FLAGS1_MASK_QR 0x80
  89. #define FLAGS1_MASK_OPCODE 0x78 /* bitshift right 3 */
  90. #define FLAGS1_MASK_AA 0x04
  91. #define FLAGS1_MASK_TC 0x02
  92. #define FLAGS1_MASK_RD 0x01
  93. 	unsigned char flags2;
  94. #define FLAGS2_MASK_RA 0x80
  95. #define FLAGS2_MASK_Z  0x70
  96. #define FLAGS2_MASK_RCODE 0x0f
  97. 	unsigned short qdcount;
  98. 	unsigned short ancount;
  99. 	unsigned short nscount;
  100. 	unsigned short arcount;
  101. 	unsigned char payload[512]; /* DNS question, populated by tivodns_build_query_payload() */
  102. };
  103.  
  104. static inline void tivodns_close(int fd) { /* close query */
  105. 	if (fd == lastcreate) {
  106. 		wantclose = 1;
  107. 		return;
  108. 	}
  109. 	close(fd);
  110. 	return;
  111. }
  112.  
  113. void my_pthread_mutex_lock( my_pthread_mutex_t *m )
  114. {
  115.    if ( *m == MY_PTHREAD_MUTEX_INITIALIZER ) *m = 0;
  116.    while ( *m != 0 ) sleep( 1 );
  117.    ( *m ) ++;
  118. }
  119.  
  120. void my_pthread_mutex_unlock( my_pthread_mutex_t *m )
  121. {
  122.    if ( *m == MY_PTHREAD_MUTEX_INITIALIZER ) *m = 0;
  123.    if ( *m > 0 ) ( *m )--;
  124. }
  125.  
  126. #if 0
  127. static int hextoi( char *str )
  128. {
  129.    int  val;
  130.    char *ptr;
  131.  
  132.    ptr = str;
  133.    if ( strncmp( str, "0x", 2 ) == 0 ) ptr +=2;
  134.  
  135.    sscanf( ptr, "%x", &val );
  136.  
  137.    return( val );
  138. }
  139. #endif
  140.  
  141. void tivodns_init( char *resolv ) { /* on first call only: populates servers4 (or -6) struct with up to FDNS_MAX nameserver IP addresses from /etc/tivodns.conf (or /etc/resolv.conf) */
  142. 	FILE *f;
  143. 	int i;
  144. 	struct in_addr addr4;
  145. 	char buf[1024];
  146.  
  147.    if ( strlen( resolv ) > 0 ) strcpy( resolv_conf, resolv );
  148.  
  149. #ifdef tivodns_USE_IPV6
  150. 	struct in6_addr addr6;
  151. #endif
  152. 	if (initdone == 1)
  153. 		return;
  154. #ifdef tivodns_USE_IPV6
  155. 	i6 = 0;
  156. #endif
  157. 	i4 = 0;
  158.  
  159. 	initdone = 1;
  160. 	srand((unsigned int) time(NULL));
  161. 	memset(servers4,'\0',sizeof(struct in_addr) * FDNS_MAX);
  162. #ifdef tivodns_USE_IPV6
  163. 	memset(servers6,'\0',sizeof(struct in6_addr) * FDNS_MAX);
  164. #endif
  165. 	/* read /etc/tivodns.conf if we've got it, otherwise parse /etc/resolv.conf */
  166.    f = fopen(FDNS_CONFIG_PREF,"r");
  167. 	if (f == NULL) {
  168. 	   f = fopen(resolv_conf,"r");
  169.       if ( f == NULL )
  170.       {
  171.          printf( "Opening backup resolv.conf\n" );
  172.   		   f = fopen(FDNS_CONFIG_FBCK,"r");
  173.       }
  174. 		if (f == NULL)
  175. 			return;
  176. 		while (fgets(buf,1024,f) != NULL) {
  177. 			if (strncmp(buf,"nameserver",10) == 0) {
  178. 				i = 10;
  179. 				while (buf[i] == ' ' || buf[i] == '\t')
  180. 					i++;
  181. #ifdef tivodns_USE_IPV6
  182. 				/* glibc /etc/resolv.conf seems to allow ipv6 server names */
  183. 				if (i6 < FDNS_MAX) {
  184. 					if (tivodns_aton6_s(&buf[i],&addr6) != NULL) {
  185. 						memcpy(&servers6[i6++],&addr6,sizeof(struct in6_addr));
  186. 						continue;
  187. 					}
  188. 				}
  189. #endif
  190. 				if (i4 < FDNS_MAX) {
  191. 					if (tivodns_aton4_s(&buf[i],&addr4) != NULL)
  192. 						memcpy(&servers4[i4++],&addr4,sizeof(struct in_addr));
  193. 				}
  194. 			}
  195. 		}
  196. 	} else {
  197. 		while (fgets(buf,1024,f) != NULL) {
  198. #ifdef tivodns_USE_IPV6
  199. 			if (i6 < FDNS_MAX) {
  200. 				if (tivodns_aton6_s(buf,&addr6) != NULL) {
  201. 					memcpy(&servers6[i6++],&addr6,sizeof(struct in6_addr));
  202. 					continue;
  203. 				}
  204. 			}
  205. #endif
  206. 			if (i4 < FDNS_MAX) {
  207. 				if (tivodns_aton4_s(buf,&addr4) != NULL)
  208. 					memcpy(&servers4[i4++],&addr4,sizeof(struct in_addr));
  209. 			}
  210. 		}
  211. 	}
  212. 	fclose(f);
  213.  
  214. }
  215.  
  216. static int tivodns_send_requests(const struct s_header *h, const struct s_connection *s, const int l) { /* send DNS query */
  217. 	int i;
  218. 	struct sockaddr_in addr4;
  219.  
  220. #ifdef tivodns_USE_IPV6
  221. 	struct sockaddr_in6 addr6;
  222. 	/* if we've got ipv6 support, an ip v6 socket, and ipv6 servers, send to them */
  223. 	if (i6 > 0 && s->v6 == 1) {
  224. 		for (i = 0; i < i6; i++) {
  225. 			memset(&addr6,0,sizeof(addr6));
  226. 			memcpy(&addr6.sin6_addr,&servers6[i],sizeof(addr6.sin6_addr));
  227. 			addr6.sin6_family = AF_INET6;
  228. 			addr6.sin6_port = htons(FDNS_PORT);
  229. 			sendto(s->fd, h, l + 12, 0, (struct sockaddr *) &addr6, sizeof(addr6));
  230. 		}
  231. 	}
  232. #endif
  233.  
  234.    for ( i = 0 ; i < i4 ; i++ ) {
  235. #ifdef tivodns_USE_IPV6
  236. 		/* send via ipv4-over-ipv6 if we've got an ipv6 socket */
  237. 		if (s->v6 == 1) {
  238. 			memset(&addr6,0,sizeof(addr6));
  239. 			memcpy(addr6.sin6_addr.s6_addr,"\0\0\0\0\0\0\0\0\0\0\xff\xff",12);
  240. 			memcpy(&addr6.sin6_addr.s6_addr[12],&servers4[i].s_addr,4);
  241. 			addr6.sin6_family = AF_INET6;
  242. 			addr6.sin6_port = htons(FDNS_PORT);
  243. 			sendto(s->fd, h, l + 12, 0, (struct sockaddr *) &addr6, sizeof(addr6));
  244. 			continue;
  245. 		}
  246. #endif
  247. 		/* otherwise send via standard ipv4 boringness */
  248. 		memset(&addr4,0,sizeof(addr4));
  249. 		memcpy(&addr4.sin_addr,&servers4[i],sizeof(addr4.sin_addr));
  250. 		addr4.sin_family = AF_INET;
  251. 		addr4.sin_port = htons(FDNS_PORT);
  252. 		sendto(s->fd, h, l + 12, 0, (struct sockaddr *) &addr4, sizeof(addr4));
  253. 	}
  254.  
  255. 	return 0;
  256. }
  257.  
  258. static struct s_connection *tivodns_add_query(struct s_header *h) { /* build DNS query, add to list */
  259. 	struct s_connection *s;
  260.  
  261. 	/* set header flags */
  262. 	h->id[0] = rand() % 255; /* verified by tivodns_getresult_s() */
  263. 	h->id[1] = rand() % 255;
  264. 	h->flags1 = 0 | FLAGS1_MASK_RD;
  265. 	h->flags2 = 0;
  266. 	h->qdcount = htons(1);
  267. 	h->ancount = htons(0);
  268. 	h->nscount = htons(0);
  269. 	h->arcount = htons(0);
  270.  
  271. 	/* create new connection object, add to linked list */
  272. 	s = malloc(sizeof(struct s_connection));
  273. 	my_pthread_mutex_lock(&connlist_lock);
  274. 	s->next = connection_head;
  275. 	connection_head = s;
  276.  
  277. 	/* turn off want_list by default */
  278. 	s->want_list = 0;
  279.  
  280. 	/* needed for security later */
  281. 	memcpy(s->id,h->id,2);
  282.  
  283. 	/* try to create ipv6 or ipv4 socket */
  284. #ifdef tivodns_USE_IPV6
  285. 	s->v6 = 0;
  286. 	if (i6 > 0) {
  287. 		s->fd = socket(PF_INET6, SOCK_DGRAM, 0);
  288. 		if (s->fd != -1) {
  289. 			if (fcntl(s->fd, F_SETFL, O_NONBLOCK) != 0) {
  290. 				close(s->fd);
  291. 				s->fd = -1;
  292. 			}
  293. 		}
  294. 		if (s->fd != -1) {
  295. 			struct sockaddr_in6 addr6;
  296. 			memset(&addr6,0,sizeof(addr6));
  297. 			addr6.sin6_family = AF_INET6;
  298. 			if (bind(s->fd,(struct sockaddr *)&addr6,sizeof(addr6)) == 0)
  299. 				s->v6 = 1;
  300. 			else
  301. 				close(s->fd);
  302. 		}
  303. 	}
  304. 	if (s->v6 == 0) {
  305. #endif
  306. 		s->fd = socket(PF_INET, SOCK_DGRAM, 0);
  307. 		if (s->fd != -1) {
  308. 			if (fcntl(s->fd, F_SETFL, O_NONBLOCK) != 0) {
  309. 				close(s->fd);
  310. 				s->fd = -1;
  311. 			}
  312. 		}
  313. 		if (s->fd != -1) {
  314. 			struct sockaddr_in addr;
  315. 			memset(&addr,0,sizeof(addr));
  316. 			addr.sin_family = AF_INET;
  317. 			addr.sin_port = 0;
  318. 			addr.sin_addr.s_addr = INADDR_ANY;
  319. 			if (bind(s->fd,(struct sockaddr *)&addr,sizeof(addr)) != 0) {
  320. 				close(s->fd);
  321. 				s->fd = -1;
  322. 			}
  323. 		}
  324. 		if (s->fd == -1) {
  325. 			connection_head = s->next;
  326. 			my_pthread_mutex_unlock(&connlist_lock);
  327. 			free(s);
  328. 			return NULL;
  329. 		}
  330. #ifdef tivodns_USE_IPV6
  331. 	}
  332. #endif
  333. 	if (wantclose == 1) {
  334. 		close(lastcreate);
  335. 		wantclose = 0;
  336. 	}
  337. 	lastcreate = s->fd;
  338. 	my_pthread_mutex_unlock(&connlist_lock);
  339. 	return s;
  340. }
  341.  
  342. static int tivodns_build_query_payload(const char * const name, const unsigned short rr, const unsigned short class, unsigned char * const payload) { /* populate payload with query: name= question, rr= record type */
  343. 	short payloadpos;
  344. 	const char * tempchr, * tempchr2;
  345. 	unsigned short l;
  346. 	
  347. 	payloadpos = 0;
  348. 	tempchr2 = name;
  349.  
  350. 	/* split name up into labels, create query */
  351. 	while ((tempchr = strchr(tempchr2,'.')) != NULL) {
  352. 		l = tempchr - tempchr2;
  353. 		if (payloadpos + l + 1 > 507)
  354. 			return -1;
  355. 		payload[payloadpos++] = l;
  356. 		memcpy(&payload[payloadpos],tempchr2,l);
  357. 		payloadpos += l;
  358. 		tempchr2 = &tempchr[1];
  359. 	}
  360. 	l = strlen(tempchr2);
  361. 	if (l) {
  362. 		if (payloadpos + l + 2 > 507)
  363. 			return -1;
  364. 		payload[payloadpos++] = l;
  365. 		memcpy(&payload[payloadpos],tempchr2,l);
  366. 		payloadpos += l;
  367. 		payload[payloadpos++] = '\0';
  368. 	}
  369. 	if (payloadpos > 508)
  370. 		return -1;
  371. 	l = htons(rr);
  372. 	memcpy(&payload[payloadpos],&l,2);
  373. 	l = htons(class);
  374. 	memcpy(&payload[payloadpos + 2],&l,2);
  375. 	return payloadpos + 4;
  376. }
  377.  
  378. struct in_addr *tivodns_aton4(const char * const ipstring) { /* ascii to numeric: convert string to static 4part IP addr struct */
  379. 	static struct in_addr ip;
  380. 	return tivodns_aton4_s(ipstring,&ip);
  381. }
  382.  
  383. struct in_addr *tivodns_aton4_r(const char *  ipstring) { /* ascii to numeric (reentrant): convert string to new 4part IP addr struct */
  384. 	struct in_addr *ip;
  385. 	ip = malloc(sizeof(struct in_addr));
  386. 	if(tivodns_aton4_s(ipstring,ip) == NULL) {
  387. 		free(ip);
  388. 		return NULL;
  389. 	}
  390. 	return ip;
  391. }
  392.  
  393. struct in_addr *tivodns_aton4_s(const char *  ipstring, struct in_addr *  ip) { /* ascii to numeric (buffered): convert string to given 4part IP addr struct */
  394. 	unsigned char *myip;
  395. 	int i,part = 0;
  396. 	myip = (unsigned char *)ip;
  397.  
  398. 	memset(myip,'\0',4);
  399. 	for (i = 0; i < 16; i++) {
  400. 		switch (ipstring[i]) {
  401. 			case '\0':
  402. 				if (part != 3)
  403. 					return NULL;
  404. 				return ip;
  405. 				break;
  406. 			case '0':
  407. 			case '1':
  408. 			case '2':
  409. 			case '3':
  410. 			case '4':
  411. 			case '5':
  412. 			case '6':
  413. 			case '7':
  414. 			case '8':
  415. 			case '9':
  416. 				if (myip[part] > 25)
  417. 					return NULL;
  418. 				myip[part] *= 10;
  419. 				if (myip[part] == 250 && ipstring[i] - '0' > 6)
  420. 					return NULL;
  421. 				myip[part] += ipstring[i] - '0';
  422. 				break;
  423. 			case '.':
  424. 				if (part == 3)
  425. 					return ip;
  426. 				else
  427. 					part++;
  428. 				break;
  429. 			default:
  430. 				if (part == 3)
  431. 					return ip;
  432. 				else
  433. 					return NULL;
  434. 				break;
  435. 		}
  436. 	}
  437. 	if (part == 3)
  438. 		return ip;
  439. 	else
  440. 		return NULL;
  441. }
  442.  
  443. #ifdef tivodns_USE_IPV6
  444. struct in6_addr *tivodns_aton6(const char * const ipstring) {
  445. 	static struct in6_addr ip;
  446. 	return tivodns_aton6_s(ipstring,&ip);
  447. }
  448.  
  449. struct in6_addr *tivodns_aton6_r(const char *  ipstring) {
  450. 	struct in6_addr *ip;
  451. 	ip = malloc(sizeof(struct in6_addr));
  452. 	if(tivodns_aton6_s(ipstring,ip) == NULL) {
  453. 		free(ip);
  454. 		return NULL;
  455. 	}
  456. 	return ip;
  457. }
  458.  
  459. struct in6_addr *tivodns_aton6_s(const char *  ipstring, struct in6_addr *  ip) {
  460. 	/* black magic */
  461. 	char instring[40];
  462. 	char tempstr[5];
  463. 	int i,o;
  464. 	int direction = 1;
  465. 	char *tempchr,*tempchr2;;
  466.  
  467. 	i = strlen(ipstring);
  468. 	if (i > 39)
  469. 		return NULL;
  470. 	memcpy(instring,ipstring,i+1);
  471.  
  472. 	memset(ip->s6_addr,'\0',16);
  473.  
  474. 	tempchr2 = instring;
  475. 	i = 0;
  476. 	while (direction > 0) {
  477. 		if (direction == 1) {
  478. 			tempchr = strchr(tempchr2,':');
  479. 			if (tempchr == NULL && i != 14)
  480. 				return NULL;
  481. 			if (tempchr != NULL)
  482. 				tempchr[0] = '\0';
  483. 			o = strlen(tempchr2);
  484. 			if (o > 4)
  485. 				return NULL;
  486. 			strcpy(tempstr,"0000");
  487. 			strcpy(&tempstr[4 - o],tempchr2);
  488. 			o = hextoi(tempstr);
  489. 			if (o == -1)
  490. 				return NULL;
  491. 			ip->s6_addr[i++] = o;
  492. 			o = hextoi(&tempstr[2]);
  493. 			if (o == -1)
  494. 				return NULL;
  495. 			ip->s6_addr[i++] = o;
  496. 			if (i >= 15)
  497. 				break;
  498. 			tempchr2 = tempchr + 1;
  499. 			if (tempchr2[0] == ':') {
  500. 				tempchr2++;
  501. 				direction = 2;
  502. 				i = 15;
  503. 				continue;
  504. 			}
  505. 		}
  506. 		if (direction == 2) {
  507. 			tempchr = strrchr(tempchr2,':');
  508. 			if (tempchr == NULL)
  509. 				tempchr = tempchr2;
  510. 			else {
  511. 				tempchr[0] = '\0';
  512. 				tempchr++;
  513. 			}
  514. 			o = strlen(tempchr);
  515. 			if (o > 4)
  516. 				return NULL;
  517. 			strcpy(tempstr,"0000");
  518. 			strcpy(&tempstr[4 - o],tempchr);
  519. 			o = hextoi(&tempstr[2]);
  520. 			if (o == -1)
  521. 				return NULL;
  522. 			ip->s6_addr[i--] = o;
  523. 			o = hextoi(tempstr);
  524. 			if (o == -1)
  525. 				return NULL;
  526. 			ip->s6_addr[i--] = o;
  527. 			if (i <= 1)
  528. 				break;
  529. 			if (tempchr == tempchr2)
  530. 				break;
  531. 		}
  532. 	}
  533. 	return ip;
  534. }
  535. #endif
  536.  
  537. int tivodns_getip4(const char *  name) { /* build, add and send A query; retrieve result with tivodns_getresult() */
  538. 	struct s_header h;
  539. 	struct s_connection *s;
  540. 	int l;
  541.  
  542. 	tivodns_init( "" );
  543. 	
  544.  
  545. 	l = tivodns_build_query_payload(name,FDNS_QRY_A,1,(unsigned char *)&h.payload);
  546. 	if (l == -1)
  547. 		return -1;
  548. 	s = tivodns_add_query(&h);
  549. 	if (s == NULL)
  550. 		return -1;
  551. 	s->class = 1;
  552. 	s->type = FDNS_QRY_A;
  553. 	if (tivodns_send_requests(&h,s,l) == -1)
  554. 		return -1;
  555.  
  556. 	return s->fd;
  557. }
  558.  
  559. int tivodns_getip6(const char *  name) {
  560. 	struct s_header h;
  561. 	struct s_connection *s;
  562. 	int l;
  563.  
  564. 	tivodns_init( "" );
  565.  
  566. 	l = tivodns_build_query_payload(name,FDNS_QRY_AAAA,1,(unsigned char *)&h.payload);
  567. 	if (l == -1)
  568. 		return -1;
  569. 	s = tivodns_add_query(&h);
  570. 	if (s == NULL)
  571. 		return -1;
  572. 	s->class = 1;
  573. 	s->type = FDNS_QRY_AAAA;
  574. 	if (tivodns_send_requests(&h,s,l) == -1)
  575. 		return -1;
  576.  
  577. 	return s->fd;
  578. }
  579.  
  580. int tivodns_gettxt(const char *  name) { /* build, add and send TXT query; retrieve result with tivodns_getresult() */
  581. 	struct s_header h;
  582. 	struct s_connection *s;
  583. 	int l;
  584.  
  585. 	tivodns_init( "" );
  586.  
  587. 	l = tivodns_build_query_payload(name,FDNS_QRY_TXT,1,(unsigned char *)&h.payload);
  588. 	if (l == -1)
  589. 		return -1;
  590. 	s = tivodns_add_query(&h);
  591. 	if (s == NULL)
  592. 		return -1;
  593. 	s->class = 1;
  594. 	s->type = FDNS_QRY_TXT;
  595. 	if (tivodns_send_requests(&h,s,l) == -1)
  596. 		return -1;
  597.  
  598. 	return s->fd;
  599. }
  600.  
  601. int tivodns_getmx(const char *  name) { /* build, add and send MX query; retrieve result with tivodns_getresult() */
  602. 	struct s_header h;
  603. 	struct s_connection *s;
  604. 	int l;
  605.  
  606. 	tivodns_init( "" );
  607.  
  608. 	l = tivodns_build_query_payload(name,FDNS_QRY_MX,1,(unsigned char *)&h.payload);
  609. 	if (l == -1)
  610. 		return -1;
  611. 	s = tivodns_add_query(&h);
  612. 	if (s == NULL)
  613. 		return -1;
  614. 	s->class = 1;
  615. 	s->type = FDNS_QRY_MX;
  616. 	if (tivodns_send_requests(&h,s,l) == -1)
  617. 		return -1;
  618.  
  619. 	return s->fd;
  620. }
  621.  
  622. int tivodns_getmxlist(const char * const name) {
  623. 	struct s_header h;
  624. 	struct s_connection *s;
  625. 	int l;
  626.  
  627. 	tivodns_init( "" );
  628.  
  629. 	l = tivodns_build_query_payload(name,FDNS_QRY_MX,1,(unsigned char *)&h.payload);
  630. 	if (l == -1)
  631. 		return -1;
  632. 	s = tivodns_add_query(&h);
  633. 	if (s == NULL)
  634. 		return -1;
  635. 	s->class = 1;
  636. 	s->type = FDNS_QRY_MX;
  637. 	s->want_list = 1;
  638. 	if (tivodns_send_requests(&h,s,l) == -1)
  639. 		return -1;
  640.  
  641. 	return s->fd;
  642. }
  643.  
  644. int tivodns_getname4(const struct in_addr *  ip) { /* build, add and send PTR query; retrieve result with tivodns_getresult() */
  645. 	char query[512];
  646. 	struct s_header h;
  647. 	struct s_connection *s;
  648. 	unsigned char *c;
  649. 	int l;
  650.  
  651. 	tivodns_init( "" );
  652.  
  653. 	c = (unsigned char *)&ip->s_addr;
  654.  
  655. 	sprintf(query,"%d.%d.%d.%d.in-addr.arpa",c[3],c[2],c[1],c[0]);
  656.  
  657. 	l = tivodns_build_query_payload(query,FDNS_QRY_PTR,1,(unsigned char *)&h.payload);
  658. 	if (l == -1)
  659. 		return -1;
  660. 	s = tivodns_add_query(&h);
  661. 	if (s == NULL)
  662. 		return -1;
  663. 	s->class = 1;
  664. 	s->type = FDNS_QRY_PTR;
  665. 	if (tivodns_send_requests(&h,s,l) == -1)
  666. 		return -1;
  667.  
  668. 	return s->fd;
  669. }
  670.  
  671. #ifdef tivodns_USE_IPV6
  672. int tivodns_getname6(const struct in6_addr *  ip) {
  673. 	char query[512];
  674. 	struct s_header h;
  675. 	struct s_connection *s;
  676. 	int l;
  677.  
  678. 	tivodns_init( "" );
  679.  
  680. 	sprintf(query,"%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.%0x.ip6.int",
  681. 			ip->s6_addr[15] & 0x0f,
  682. 			(ip->s6_addr[15] & 0xf0) >> 4,
  683. 			ip->s6_addr[14] & 0x0f,
  684. 			(ip->s6_addr[14] & 0xf0) >> 4,
  685. 			ip->s6_addr[13] & 0x0f,
  686. 			(ip->s6_addr[13] & 0xf0) >> 4,
  687. 			ip->s6_addr[12] & 0x0f,
  688. 			(ip->s6_addr[12] & 0xf0) >> 4,
  689. 			ip->s6_addr[11] & 0x0f,
  690. 			(ip->s6_addr[11] & 0xf0) >> 4,
  691. 			ip->s6_addr[10] & 0x0f,
  692. 			(ip->s6_addr[10] & 0xf0) >> 4,
  693. 			ip->s6_addr[9] & 0x0f,
  694. 			(ip->s6_addr[9] & 0xf0) >> 4,
  695. 			ip->s6_addr[8] & 0x0f,
  696. 			(ip->s6_addr[8] & 0xf0) >> 4,
  697. 			ip->s6_addr[7] & 0x0f,
  698. 			(ip->s6_addr[7] & 0xf0) >> 4,
  699. 			ip->s6_addr[6] & 0x0f,
  700. 			(ip->s6_addr[6] & 0xf0) >> 4,
  701. 			ip->s6_addr[5] & 0x0f,
  702. 			(ip->s6_addr[5] & 0xf0) >> 4,
  703. 			ip->s6_addr[4] & 0x0f,
  704. 			(ip->s6_addr[4] & 0xf0) >> 4,
  705. 			ip->s6_addr[3] & 0x0f,
  706. 			(ip->s6_addr[3] & 0xf0) >> 4,
  707. 			ip->s6_addr[2] & 0x0f,
  708. 			(ip->s6_addr[2] & 0xf0) >> 4,
  709. 			ip->s6_addr[1] & 0x0f,
  710. 			(ip->s6_addr[1] & 0xf0) >> 4,
  711. 			ip->s6_addr[0] & 0x0f,
  712. 			(ip->s6_addr[0] & 0xf0) >> 4
  713. 			);
  714.  
  715. 	l = tivodns_build_query_payload(query,12,1,(unsigned char *)&h.payload);
  716. 	if (l == -1)
  717. 		return -1;
  718. 	s = tivodns_add_query(&h);
  719. 	if (s == NULL)
  720. 		return -1;
  721. 	s->class = 1;
  722. 	s->type = 12;
  723. 	if (tivodns_send_requests(&h,s,l) == -1)
  724. 		return -1;
  725.  
  726. 	return s->fd;
  727. }
  728. #endif
  729.  
  730. int tivodns_dnsbl_lookup_a(const struct in_addr *  ip, const char *  name) { /* build, add and send A query to given DNSBL list; retrieve result with tivodns_getresult() */
  731. 	char hostname[256];
  732. 	snprintf(hostname,256,"%u.%u.%u.%u.%s",(unsigned int) ((unsigned char *)&ip->s_addr)[3],(unsigned int) ((unsigned char *)&ip->s_addr)[2],(unsigned int) ((unsigned char *)&ip->s_addr)[1],(unsigned int) ((unsigned char *)&ip->s_addr)[0],name);
  733. 	return tivodns_getip4(hostname);
  734. }
  735.  
  736. int tivodns_dnsbl_lookup_txt(const struct in_addr *  ip, const char *  name) { /* build, add and send TXT query to given DNSBL list; retrieve result with tivodns_getresult() */
  737. 	char hostname[256];
  738. 	snprintf(hostname,256,"%u.%u.%u.%u.%s",(unsigned int) ((unsigned char *)&ip->s_addr)[3],(unsigned int) ((unsigned char *)&ip->s_addr)[2],(unsigned int) ((unsigned char *)&ip->s_addr)[1],(unsigned int) ((unsigned char *)&ip->s_addr)[0],name);
  739. 	return tivodns_gettxt(hostname);
  740. }
  741.  
  742. char *tivodns_ntoa4(const struct in_addr * const ip) { /* numeric to ascii: convert 4part IP addr struct to static string */
  743. 	static char result[256];
  744. 	return tivodns_ntoa4_s(ip,result);
  745. }
  746.  
  747. char *tivodns_ntoa4_r(const struct in_addr *  ip) { /* numeric to ascii (reentrant): convert 4part IP addr struct to new string */
  748. 	char *result;
  749. 	result = malloc(256);
  750. 	return tivodns_ntoa4_s(ip,result);
  751. }
  752.  
  753. char *tivodns_ntoa4_s(const struct in_addr *  ip, char *  result) { /* numeric to ascii (buffered): convert 4part IP addr struct to given string */
  754. 	unsigned char *m;
  755. 	m = (unsigned char *)&ip->s_addr;
  756. 	sprintf(result,"%d.%d.%d.%d",m[0],m[1],m[2],m[3]);
  757. 	return result;
  758. }
  759.  
  760. #ifdef tivodns_USE_IPV6
  761. char *tivodns_ntoa6(const struct in6_addr *ip) {
  762. 	static char result[256];
  763. 	return tivodns_ntoa6_s(ip,result);
  764. }
  765.  
  766. char *tivodns_ntoa6_r(const struct in6_addr *ip) {
  767. 	char *result;
  768. 	result = malloc(256);
  769. 	return tivodns_ntoa6_s(ip,result);
  770. }
  771.  
  772. char *tivodns_ntoa6_s(const struct in6_addr *  ip, char *  result) {
  773. 	sprintf(result,"%x:%x:%x:%x:%x:%x:%x:%x",
  774. 			ntohs(*((unsigned short *)&ip->s6_addr[0])),
  775. 			ntohs(*((unsigned short *)&ip->s6_addr[2])),
  776. 			ntohs(*((unsigned short *)&ip->s6_addr[4])),
  777. 			ntohs(*((unsigned short *)&ip->s6_addr[6])),
  778. 			ntohs(*((unsigned short *)&ip->s6_addr[8])),
  779. 			ntohs(*((unsigned short *)&ip->s6_addr[10])),
  780. 			ntohs(*((unsigned short *)&ip->s6_addr[12])),
  781. 			ntohs(*((unsigned short *)&ip->s6_addr[14])));
  782. 	return result;
  783. }
  784. #endif
  785.  
  786. char *tivodns_getresult(const int fd) { /* retrieve result of DNS query */
  787. 	static char result[RESULTSIZE];
  788. 	return tivodns_getresult_s(fd,result);
  789. }
  790.  
  791. char *tivodns_getresult_r(const int fd) { /* retrieve result of DNS query (reentrant) */
  792. 	char *result;
  793. 	result = malloc(RESULTSIZE);
  794. 	if(tivodns_getresult_s(fd,result) == NULL) {
  795. 		free(result);
  796. 		return NULL;
  797. 	}
  798. 	return result;
  799. }
  800.  
  801. char *tivodns_getresult_s(const int fd, char *  result) { /* retrieve result of DNS query (buffered) */
  802. 	struct s_header h;
  803. 	struct s_connection *c, *prev;
  804. 	int l,i,q,curanswer,o;
  805. 	struct s_rr_middle *rr, rrbacking;
  806. 	char *src, *dst;
  807. 	int bytes;
  808. 	unsigned short p;
  809.  
  810.    rr = 0;
  811.  
  812. 	prev = NULL;
  813. 	my_pthread_mutex_lock(&connlist_lock);
  814. 	c = connection_head;
  815. 	while (c != NULL) { /* find query in list of open queries */
  816. 		if (c->fd == fd)
  817. 			break;
  818. 		prev = c;
  819. 		c = c->next;
  820. 	}
  821. 	if (c == NULL) {
  822. 		my_pthread_mutex_unlock(&connlist_lock);
  823. 		return NULL; /* query not found */
  824. 	}
  825. 	/* query found-- pull from list: */
  826. 	if (prev != NULL)
  827. 		prev->next = c->next;
  828. 	else
  829. 		connection_head = c->next;
  830. 	my_pthread_mutex_unlock(&connlist_lock);
  831.  
  832. 	l = recv(c->fd,&h,sizeof(struct s_header),0);
  833. 	tivodns_close(c->fd);
  834. 	if (l < 12) {
  835. 		free(c);
  836. 		return NULL;
  837. 	}
  838. 	if (c->id[0] != h.id[0] || c->id[1] != h.id[1]) {
  839. 		free(c);
  840. 		return NULL; /* ID mismatch */
  841. 	}
  842. 	if ((h.flags1 & FLAGS1_MASK_QR) == 0) {
  843. 		free(c);
  844. 		return NULL;
  845. 	}
  846. 	if ((h.flags1 & FLAGS1_MASK_OPCODE) != 0) {
  847. 		free(c);
  848. 		return NULL;
  849. 	}
  850. 	if ((h.flags2 & FLAGS2_MASK_RCODE) != 0) {
  851. 		free(c);
  852. 		return NULL;
  853. 	}
  854. 	h.ancount = ntohs(h.ancount);
  855. 	if (h.ancount < 1)  { /* no sense going on if we don't have any answers */
  856. 		free(c);
  857. 		return NULL;
  858. 	}
  859. 	/* skip queries */
  860. 	i = 0;
  861. 	q = 0;
  862. 	l -= 12;
  863. 	h.qdcount = ntohs(h.qdcount);
  864. 	while (q < h.qdcount && i < l) {
  865. 		if (h.payload[i] > 63) { /* pointer */
  866. 			i += 6; /* skip pointer, class and type */
  867. 			q++;
  868. 		} else { /* label */
  869. 			if (h.payload[i] == 0) {
  870. 				q++;
  871. 				i += 5; /* skip nil, class and type */
  872. 			} else
  873. 				i += h.payload[i] + 1; /* skip length and label */
  874. 		}
  875. 	}
  876. 	/* &h.payload[i] should now be the start of the first response */
  877. 	curanswer = 0;
  878. 	while (