resolve.c revision 102644
1178129Smarius/* 2178129Smarius * Copyright (c) 1995 - 2002 Kungliga Tekniska H�gskolan 3178129Smarius * (Royal Institute of Technology, Stockholm, Sweden). 4178129Smarius * All rights reserved. 5178129Smarius * 6178129Smarius * Redistribution and use in source and binary forms, with or without 7178129Smarius * modification, are permitted provided that the following conditions 8178129Smarius * are met: 9178129Smarius * 10178129Smarius * 1. Redistributions of source code must retain the above copyright 11178129Smarius * notice, this list of conditions and the following disclaimer. 12178129Smarius * 13178129Smarius * 2. Redistributions in binary form must reproduce the above copyright 14178129Smarius * notice, this list of conditions and the following disclaimer in the 15178129Smarius * documentation and/or other materials provided with the distribution. 16178129Smarius * 17178129Smarius * 3. Neither the name of the Institute nor the names of its contributors 18178129Smarius * may be used to endorse or promote products derived from this software 19178129Smarius * without specific prior written permission. 20178129Smarius * 21178129Smarius * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 22178129Smarius * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23178129Smarius * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24178129Smarius * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 25178129Smarius * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26178129Smarius * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27178129Smarius * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28178129Smarius * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29178129Smarius * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30178129Smarius * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31178129Smarius * SUCH DAMAGE. 32178129Smarius */ 33178129Smarius 34178129Smarius#ifdef HAVE_CONFIG_H 35178129Smarius#include <config.h> 36178129Smarius#endif 37178129Smarius#include "roken.h" 38178129Smarius#ifdef HAVE_ARPA_NAMESER_H 39178129Smarius#include <arpa/nameser.h> 40178129Smarius#endif 41178129Smarius#ifdef HAVE_RESOLV_H 42178129Smarius#include <resolv.h> 43178129Smarius#endif 44178129Smarius#include "resolve.h" 45178129Smarius 46178129Smarius#include <assert.h> 47178129Smarius 48178129SmariusRCSID("$Id: resolve.c,v 1.33 2002/08/28 20:07:24 joda Exp $"); 49178129Smarius 50178129Smarius#if defined(HAVE_RES_SEARCH) && defined(HAVE_DN_EXPAND) 51178129Smarius 52178129Smarius#define DECL(X) {#X, T_##X} 53178129Smarius 54178129Smariusstatic struct stot{ 55178129Smarius const char *name; 56178129Smarius int type; 57178129Smarius}stot[] = { 58178129Smarius DECL(A), 59178129Smarius DECL(NS), 60178129Smarius DECL(CNAME), 61178129Smarius DECL(SOA), 62178129Smarius DECL(PTR), 63178129Smarius DECL(MX), 64178129Smarius DECL(TXT), 65178129Smarius DECL(AFSDB), 66178129Smarius DECL(SIG), 67178129Smarius DECL(KEY), 68178129Smarius DECL(SRV), 69178129Smarius DECL(NAPTR), 70178129Smarius {NULL, 0} 71178129Smarius}; 72178129Smarius 73178129Smariusint _resolve_debug = 0; 74178129Smarius 75178129Smariusint 76178129Smariusdns_string_to_type(const char *name) 77178129Smarius{ 78178129Smarius struct stot *p = stot; 79178129Smarius for(p = stot; p->name; p++) 80178129Smarius if(strcasecmp(name, p->name) == 0) 81178129Smarius return p->type; 82178129Smarius return -1; 83178129Smarius} 84178129Smarius 85178129Smariusconst char * 86178129Smariusdns_type_to_string(int type) 87178129Smarius{ 88178129Smarius struct stot *p = stot; 89178129Smarius for(p = stot; p->name; p++) 90178129Smarius if(type == p->type) 91178129Smarius return p->name; 92178129Smarius return NULL; 93178129Smarius} 94178129Smarius 95178129Smariusvoid 96178129Smariusdns_free_data(struct dns_reply *r) 97178129Smarius{ 98178129Smarius struct resource_record *rr; 99178129Smarius if(r->q.domain) 100178129Smarius free(r->q.domain); 101178129Smarius for(rr = r->head; rr;){ 102178129Smarius struct resource_record *tmp = rr; 103178129Smarius if(rr->domain) 104178129Smarius free(rr->domain); 105178129Smarius if(rr->u.data) 106178129Smarius free(rr->u.data); 107178129Smarius rr = rr->next; 108178129Smarius free(tmp); 109178129Smarius } 110178129Smarius free (r); 111178129Smarius} 112178129Smarius 113178129Smariusstatic struct dns_reply* 114parse_reply(unsigned char *data, int len) 115{ 116 const unsigned char *p; 117 char host[128]; 118 int status; 119 const unsigned char *end_data = data + len; 120 struct dns_reply *r; 121 struct resource_record **rr; 122 123 r = calloc(1, sizeof(*r)); 124 if (r == NULL) 125 return NULL; 126 127 p = data; 128#if 0 129 /* doesn't work on Crays */ 130 memcpy(&r->h, p, sizeof(HEADER)); 131 p += sizeof(HEADER); 132#else 133 memcpy(&r->h, p, 12); /* XXX this will probably be mostly garbage */ 134 p += 12; 135#endif 136 status = dn_expand(data, end_data, p, host, sizeof(host)); 137 if(status < 0){ 138 dns_free_data(r); 139 return NULL; 140 } 141 r->q.domain = strdup(host); 142 if(r->q.domain == NULL) { 143 dns_free_data(r); 144 return NULL; 145 } 146 if (p + status + 4 > end_data) { 147 dns_free_data(r); 148 return NULL; 149 } 150 p += status; 151 r->q.type = (p[0] << 8 | p[1]); 152 p += 2; 153 r->q.class = (p[0] << 8 | p[1]); 154 p += 2; 155 rr = &r->head; 156 while(p < end_data){ 157 int type, class, ttl, size; 158 status = dn_expand(data, end_data, p, host, sizeof(host)); 159 if(status < 0){ 160 dns_free_data(r); 161 return NULL; 162 } 163 if (p + status + 10 > end_data) { 164 dns_free_data(r); 165 return NULL; 166 } 167 p += status; 168 type = (p[0] << 8) | p[1]; 169 p += 2; 170 class = (p[0] << 8) | p[1]; 171 p += 2; 172 ttl = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]; 173 p += 4; 174 size = (p[0] << 8) | p[1]; 175 p += 2; 176 177 if (p + size > end_data) { 178 dns_free_data(r); 179 return NULL; 180 } 181 182 *rr = (struct resource_record*)calloc(1, 183 sizeof(struct resource_record)); 184 if(*rr == NULL) { 185 dns_free_data(r); 186 return NULL; 187 } 188 (*rr)->domain = strdup(host); 189 if((*rr)->domain == NULL) { 190 dns_free_data(r); 191 return NULL; 192 } 193 (*rr)->type = type; 194 (*rr)->class = class; 195 (*rr)->ttl = ttl; 196 (*rr)->size = size; 197 switch(type){ 198 case T_NS: 199 case T_CNAME: 200 case T_PTR: 201 status = dn_expand(data, end_data, p, host, sizeof(host)); 202 if(status < 0){ 203 dns_free_data(r); 204 return NULL; 205 } 206 (*rr)->u.txt = strdup(host); 207 if((*rr)->u.txt == NULL) { 208 dns_free_data(r); 209 return NULL; 210 } 211 break; 212 case T_MX: 213 case T_AFSDB:{ 214 status = dn_expand(data, end_data, p + 2, host, sizeof(host)); 215 if(status < 0){ 216 dns_free_data(r); 217 return NULL; 218 } 219 if (status + 2 > size) { 220 dns_free_data(r); 221 return NULL; 222 } 223 224 (*rr)->u.mx = (struct mx_record*)malloc(sizeof(struct mx_record) + 225 strlen(host)); 226 if((*rr)->u.mx == NULL) { 227 dns_free_data(r); 228 return NULL; 229 } 230 (*rr)->u.mx->preference = (p[0] << 8) | p[1]; 231 strcpy((*rr)->u.mx->domain, host); 232 break; 233 } 234 case T_SRV:{ 235 status = dn_expand(data, end_data, p + 6, host, sizeof(host)); 236 if(status < 0){ 237 dns_free_data(r); 238 return NULL; 239 } 240 if (status + 6 > size) { 241 dns_free_data(r); 242 return NULL; 243 } 244 245 (*rr)->u.srv = 246 (struct srv_record*)malloc(sizeof(struct srv_record) + 247 strlen(host)); 248 if((*rr)->u.srv == NULL) { 249 dns_free_data(r); 250 return NULL; 251 } 252 (*rr)->u.srv->priority = (p[0] << 8) | p[1]; 253 (*rr)->u.srv->weight = (p[2] << 8) | p[3]; 254 (*rr)->u.srv->port = (p[4] << 8) | p[5]; 255 strcpy((*rr)->u.srv->target, host); 256 break; 257 } 258 case T_TXT:{ 259 (*rr)->u.txt = (char*)malloc(size + 1); 260 if((*rr)->u.txt == NULL) { 261 dns_free_data(r); 262 return NULL; 263 } 264 strncpy((*rr)->u.txt, (char*)p + 1, *p); 265 (*rr)->u.txt[*p] = 0; 266 break; 267 } 268 case T_KEY : { 269 size_t key_len; 270 271 if (size < 4) { 272 dns_free_data (r); 273 return NULL; 274 } 275 276 key_len = size - 4; 277 (*rr)->u.key = malloc (sizeof(*(*rr)->u.key) + key_len - 1); 278 if ((*rr)->u.key == NULL) { 279 dns_free_data (r); 280 return NULL; 281 } 282 283 (*rr)->u.key->flags = (p[0] << 8) | p[1]; 284 (*rr)->u.key->protocol = p[2]; 285 (*rr)->u.key->algorithm = p[3]; 286 (*rr)->u.key->key_len = key_len; 287 memcpy ((*rr)->u.key->key_data, p + 4, key_len); 288 break; 289 } 290 case T_SIG : { 291 size_t sig_len; 292 293 status = dn_expand (data, end_data, p + 18, host, sizeof(host)); 294 if (status < 0) { 295 dns_free_data (r); 296 return NULL; 297 } 298 if (status + 18 > size) { 299 dns_free_data(r); 300 return NULL; 301 } 302 303 sig_len = len - 18 - status; 304 (*rr)->u.sig = malloc(sizeof(*(*rr)->u.sig) 305 + strlen(host) + sig_len); 306 if ((*rr)->u.sig == NULL) { 307 dns_free_data (r); 308 return NULL; 309 } 310 (*rr)->u.sig->type = (p[0] << 8) | p[1]; 311 (*rr)->u.sig->algorithm = p[2]; 312 (*rr)->u.sig->labels = p[3]; 313 (*rr)->u.sig->orig_ttl = (p[4] << 24) | (p[5] << 16) 314 | (p[6] << 8) | p[7]; 315 (*rr)->u.sig->sig_expiration = (p[8] << 24) | (p[9] << 16) 316 | (p[10] << 8) | p[11]; 317 (*rr)->u.sig->sig_inception = (p[12] << 24) | (p[13] << 16) 318 | (p[14] << 8) | p[15]; 319 (*rr)->u.sig->key_tag = (p[16] << 8) | p[17]; 320 (*rr)->u.sig->sig_len = sig_len; 321 memcpy ((*rr)->u.sig->sig_data, p + 18 + status, sig_len); 322 (*rr)->u.sig->signer = &(*rr)->u.sig->sig_data[sig_len]; 323 strcpy((*rr)->u.sig->signer, host); 324 break; 325 } 326 327 case T_CERT : { 328 size_t cert_len; 329 330 if (size < 5) { 331 dns_free_data(r); 332 return NULL; 333 } 334 335 cert_len = size - 5; 336 (*rr)->u.cert = malloc (sizeof(*(*rr)->u.cert) + cert_len - 1); 337 if ((*rr)->u.cert == NULL) { 338 dns_free_data (r); 339 return NULL; 340 } 341 342 (*rr)->u.cert->type = (p[0] << 8) | p[1]; 343 (*rr)->u.cert->tag = (p[2] << 8) | p[3]; 344 (*rr)->u.cert->algorithm = p[4]; 345 (*rr)->u.cert->cert_len = cert_len; 346 memcpy ((*rr)->u.cert->cert_data, p + 5, cert_len); 347 break; 348 } 349 default: 350 (*rr)->u.data = (unsigned char*)malloc(size); 351 if(size != 0 && (*rr)->u.data == NULL) { 352 dns_free_data(r); 353 return NULL; 354 } 355 memcpy((*rr)->u.data, p, size); 356 } 357 p += size; 358 rr = &(*rr)->next; 359 } 360 *rr = NULL; 361 return r; 362} 363 364static struct dns_reply * 365dns_lookup_int(const char *domain, int rr_class, int rr_type) 366{ 367 unsigned char reply[1024]; 368 int len; 369#ifdef HAVE__RES 370 u_long old_options = 0; 371#endif 372 373 if (_resolve_debug) { 374#ifdef HAVE__RES 375 old_options = _res.options; 376 _res.options |= RES_DEBUG; 377#endif 378 fprintf(stderr, "dns_lookup(%s, %d, %s)\n", domain, 379 rr_class, dns_type_to_string(rr_type)); 380 } 381 len = res_search(domain, rr_class, rr_type, reply, sizeof(reply)); 382 if (_resolve_debug) { 383#ifdef HAVE__RES 384 _res.options = old_options; 385#endif 386 fprintf(stderr, "dns_lookup(%s, %d, %s) --> %d\n", 387 domain, rr_class, dns_type_to_string(rr_type), len); 388 } 389 if(len < 0) { 390 return NULL; 391 } else { 392 len = min(len, sizeof(reply)); 393 return parse_reply(reply, len); 394 } 395} 396 397struct dns_reply * 398dns_lookup(const char *domain, const char *type_name) 399{ 400 int type; 401 402 type = dns_string_to_type(type_name); 403 if(type == -1) { 404 if(_resolve_debug) 405 fprintf(stderr, "dns_lookup: unknown resource type: `%s'\n", 406 type_name); 407 return NULL; 408 } 409 return dns_lookup_int(domain, C_IN, type); 410} 411 412static int 413compare_srv(const void *a, const void *b) 414{ 415 const struct resource_record *const* aa = a, *const* bb = b; 416 417 if((*aa)->u.srv->priority == (*bb)->u.srv->priority) 418 return ((*aa)->u.srv->weight - (*bb)->u.srv->weight); 419 return ((*aa)->u.srv->priority - (*bb)->u.srv->priority); 420} 421 422#ifndef HAVE_RANDOM 423#define random() rand() 424#endif 425 426/* try to rearrange the srv-records by the algorithm in RFC2782 */ 427void 428dns_srv_order(struct dns_reply *r) 429{ 430 struct resource_record **srvs, **ss, **headp; 431 struct resource_record *rr; 432 int num_srv = 0; 433 434#if defined(HAVE_INITSTATE) && defined(HAVE_SETSTATE) 435 int state[256 / sizeof(int)]; 436 char *oldstate; 437#endif 438 439 for(rr = r->head; rr; rr = rr->next) 440 if(rr->type == T_SRV) 441 num_srv++; 442 443 if(num_srv == 0) 444 return; 445 446 srvs = malloc(num_srv * sizeof(*srvs)); 447 if(srvs == NULL) 448 return; /* XXX not much to do here */ 449 450 /* unlink all srv-records from the linked list and put them in 451 a vector */ 452 for(ss = srvs, headp = &r->head; *headp; ) 453 if((*headp)->type == T_SRV) { 454 *ss = *headp; 455 *headp = (*headp)->next; 456 (*ss)->next = NULL; 457 ss++; 458 } else 459 headp = &(*headp)->next; 460 461 /* sort them by priority and weight */ 462 qsort(srvs, num_srv, sizeof(*srvs), compare_srv); 463 464#if defined(HAVE_INITSTATE) && defined(HAVE_SETSTATE) 465 oldstate = initstate(time(NULL), (char*)state, sizeof(state)); 466#endif 467 468 headp = &r->head; 469 470 for(ss = srvs; ss < srvs + num_srv; ) { 471 int sum, rnd, count; 472 struct resource_record **ee, **tt; 473 /* find the last record with the same priority and count the 474 sum of all weights */ 475 for(sum = 0, tt = ss; tt < srvs + num_srv; tt++) { 476 if(*tt == NULL) 477 continue; 478 if((*tt)->u.srv->priority != (*ss)->u.srv->priority) 479 break; 480 sum += (*tt)->u.srv->weight; 481 } 482 ee = tt; 483 /* ss is now the first record of this priority and ee is the 484 first of the next */ 485 while(ss < ee) { 486 rnd = random() % (sum + 1); 487 for(count = 0, tt = ss; ; tt++) { 488 if(*tt == NULL) 489 continue; 490 count += (*tt)->u.srv->weight; 491 if(count >= rnd) 492 break; 493 } 494 495 assert(tt < ee); 496 497 /* insert the selected record at the tail (of the head) of 498 the list */ 499 (*tt)->next = *headp; 500 *headp = *tt; 501 headp = &(*tt)->next; 502 sum -= (*tt)->u.srv->weight; 503 *tt = NULL; 504 while(ss < ee && *ss == NULL) 505 ss++; 506 } 507 } 508 509#if defined(HAVE_INITSTATE) && defined(HAVE_SETSTATE) 510 setstate(oldstate); 511#endif 512 free(srvs); 513 return; 514} 515 516#else /* NOT defined(HAVE_RES_SEARCH) && defined(HAVE_DN_EXPAND) */ 517 518struct dns_reply * 519dns_lookup(const char *domain, const char *type_name) 520{ 521 return NULL; 522} 523 524void 525dns_free_data(struct dns_reply *r) 526{ 527} 528 529void 530dns_srv_order(struct dns_reply *r) 531{ 532} 533 534#endif 535 536#ifdef TEST 537int 538main(int argc, char **argv) 539{ 540 struct dns_reply *r; 541 struct resource_record *rr; 542 r = dns_lookup(argv[1], argv[2]); 543 if(r == NULL){ 544 printf("No reply.\n"); 545 return 1; 546 } 547 if(r->q.type == T_SRV) 548 dns_srv_order(r); 549 550 for(rr = r->head; rr;rr=rr->next){ 551 printf("%s %s %d ", rr->domain, dns_type_to_string(rr->type), rr->ttl); 552 switch(rr->type){ 553 case T_NS: 554 case T_CNAME: 555 case T_PTR: 556 printf("%s\n", (char*)rr->u.data); 557 break; 558 case T_A: 559 printf("%s\n", inet_ntoa(*rr->u.a)); 560 break; 561 case T_MX: 562 case T_AFSDB:{ 563 printf("%d %s\n", rr->u.mx->preference, rr->u.mx->domain); 564 break; 565 } 566 case T_SRV:{ 567 struct srv_record *srv = rr->u.srv; 568 printf("%d %d %d %s\n", srv->priority, srv->weight, 569 srv->port, srv->target); 570 break; 571 } 572 case T_TXT: { 573 printf("%s\n", rr->u.txt); 574 break; 575 } 576 case T_SIG : { 577 struct sig_record *sig = rr->u.sig; 578 const char *type_string = dns_type_to_string (sig->type); 579 580 printf ("type %u (%s), algorithm %u, labels %u, orig_ttl %u, sig_expiration %u, sig_inception %u, key_tag %u, signer %s\n", 581 sig->type, type_string ? type_string : "", 582 sig->algorithm, sig->labels, sig->orig_ttl, 583 sig->sig_expiration, sig->sig_inception, sig->key_tag, 584 sig->signer); 585 break; 586 } 587 case T_KEY : { 588 struct key_record *key = rr->u.key; 589 590 printf ("flags %u, protocol %u, algorithm %u\n", 591 key->flags, key->protocol, key->algorithm); 592 break; 593 } 594 default: 595 printf("\n"); 596 break; 597 } 598 } 599 600 return 0; 601} 602#endif 603