crypto/external/bsd/openssh/dist/getrrsetbyname.c

   1 /*      $NetBSD: getrrsetbyname.c,v 1.3 2006/09/28 21:22:14 christos Exp $      */
   2 /* $OpenBSD: getrrsetbyname.c,v 1.10 2005/03/30 02:58:28 tedu Exp $ */
   3
   4 /*
   5  * Copyright (c) 2001 Jakob Schlyter. 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  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 /*
  31  * Portions Copyright (c) 1999-2001 Internet Software Consortium.
  32  *
  33  * Permission to use, copy, modify, and distribute this software for any
  34  * purpose with or without fee is hereby granted, provided that the above
  35  * copyright notice and this permission notice appear in all copies.
  36  *
  37  * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM
  38  * DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
  39  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
  40  * INTERNET SOFTWARE CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT,
  41  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING
  42  * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  43  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
  44  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  45  */
  46
  47 /* OPENBSD ORIGINAL: lib/libc/net/getrrsetbyname.c */
  48
  49 #include "includes.h"
  50 __RCSID("$NetBSD: getrrsetbyname.c,v 1.3 2006/09/28 21:22:14 christos Exp $");
  51
  52 #ifndef HAVE_GETRRSETBYNAME
  53
  54 #include <string.h>
  55 #include <stdlib.h>
  56 #include <unistd.h>
  57
  58 #include "getrrsetbyname.h"
  59
  60 #if defined(HAVE_DECL_H_ERRNO) && !HAVE_DECL_H_ERRNO
  61 extern int h_errno;
  62 #endif
  63
  64 /* We don't need multithread support here */
  65 #ifdef _THREAD_PRIVATE
  66 # undef _THREAD_PRIVATE
  67 #endif
  68 #define _THREAD_PRIVATE(a,b,c) (c)
  69 #ifndef __NetBSD__
  70 struct __res_state _res;
  71 #else
  72 #define HAVE__GETSHORT
  73 #define HAVE__GETLONG
  74 #endif
  75
  76 /* Necessary functions and macros */
  77
  78 /*
  79  * Inline versions of get/put short/long.  Pointer is advanced.
  80  *
  81  * These macros demonstrate the property of C whereby it can be
  82  * portable or it can be elegant but rarely both.
  83  */
  84
  85 #ifndef INT32SZ
  86 # define INT32SZ        4
  87 #endif
  88 #ifndef INT16SZ
  89 # define INT16SZ        2
  90 #endif
  91
  92 #ifndef GETSHORT
  93 #define GETSHORT(s, cp) { \
  94         register u_char *t_cp = (u_char *)(cp); \
  95         (s) = ((u_int16_t)t_cp[0] << 8) \
  96             | ((u_int16_t)t_cp[1]) \
  97             ; \
  98         (cp) += INT16SZ; \
  99 }
 100 #endif
 101
 102 #ifndef GETLONG
 103 #define GETLONG(l, cp) { \
 104         register u_char *t_cp = (u_char *)(cp); \
 105         (l) = ((u_int32_t)t_cp[0] << 24) \
 106             | ((u_int32_t)t_cp[1] << 16) \
 107             | ((u_int32_t)t_cp[2] << 8) \
 108             | ((u_int32_t)t_cp[3]) \
 109             ; \
 110         (cp) += INT32SZ; \
 111 }
 112 #endif
 113
 114 /*
 115  * Routines to insert/extract short/long's.
 116  */
 117
 118 #ifndef HAVE__GETSHORT
 119 static u_int16_t
 120 _getshort(msgp)
 121         register const u_char *msgp;
 122 {
 123         register u_int16_t u;
 124
 125         GETSHORT(u, msgp);
 126         return (u);
 127 }
 128 #elif defined(HAVE_DECL__GETSHORT) && (HAVE_DECL__GETSHORT == 0)
 129 u_int16_t _getshort(register const u_char *);
 130 #endif
 131
 132 #ifndef HAVE__GETLONG
 133 static u_int32_t
 134 _getlong(msgp)
 135         register const u_char *msgp;
 136 {
 137         register u_int32_t u;
 138
 139         GETLONG(u, msgp);
 140         return (u);
 141 }
 142 #elif defined(HAVE_DECL__GETLONG) && (HAVE_DECL__GETLONG == 0)
 143 u_int32_t _getlong(register const u_char *);
 144 #endif
 145
 146 /* ************** */
 147
 148 #define ANSWER_BUFFER_SIZE 1024*64
 149
 150 struct dns_query {
 151         char                    *name;
 152         u_int16_t               type;
 153         u_int16_t               class;
 154         struct dns_query        *next;
 155 };
 156
 157 struct dns_rr {
 158         char                    *name;
 159         u_int16_t               type;
 160         u_int16_t               class;
 161         u_int16_t               ttl;
 162         u_int16_t               size;
 163         void                    *rdata;
 164         struct dns_rr           *next;
 165 };
 166
 167 struct dns_response {
 168         HEADER                  header;
 169         struct dns_query        *query;
 170         struct dns_rr           *answer;
 171         struct dns_rr           *authority;
 172         struct dns_rr           *additional;
 173 };
 174
 175 static struct dns_response *parse_dns_response(const u_char *, int);
 176 static struct dns_query *parse_dns_qsection(const u_char *, int,
 177     const u_char **, int);
 178 static struct dns_rr *parse_dns_rrsection(const u_char *, int, const u_char **,
 179     int);
 180
 181 static void free_dns_query(struct dns_query *);
 182 static void free_dns_rr(struct dns_rr *);
 183 static void free_dns_response(struct dns_response *);
 184
 185 static int count_dns_rr(struct dns_rr *, u_int16_t, u_int16_t);
 186
 187 int
 188 getrrsetbyname(const char *hostname, unsigned int rdclass,
 189     unsigned int rdtype, unsigned int flags,
 190     struct rrsetinfo **res)
 191 {
 192         struct __res_state *_resp = _THREAD_PRIVATE(_res, _res, &_res);
 193         int result;
 194         struct rrsetinfo *rrset = NULL;
 195         struct dns_response *response = NULL;
 196         struct dns_rr *rr;
 197         struct rdatainfo *rdata;
 198         int length;
 199         unsigned int index_ans, index_sig;
 200         u_char answer[ANSWER_BUFFER_SIZE];
 201
 202         /* check for invalid class and type */
 203         if (rdclass > 0xffff || rdtype > 0xffff) {
 204                 result = ERRSET_INVAL;
 205                 goto fail;
 206         }
 207
 208         /* don't allow queries of class or type ANY */
 209         if (rdclass == 0xff || rdtype == 0xff) {
 210                 result = ERRSET_INVAL;
 211                 goto fail;
 212         }
 213
 214         /* don't allow flags yet, unimplemented */
 215         if (flags) {
 216                 result = ERRSET_INVAL;
 217                 goto fail;
 218         }
 219
 220         /* initialize resolver */
 221         if ((_resp->options & RES_INIT) == 0 && res_init() == -1) {
 222                 result = ERRSET_FAIL;
 223                 goto fail;
 224         }
 225
 226 #ifdef DEBUG
 227         _resp->options |= RES_DEBUG;
 228 #endif /* DEBUG */
 229
 230 #ifdef RES_USE_DNSSEC
 231         /* turn on DNSSEC if EDNS0 is configured */
 232         if (_resp->options & RES_USE_EDNS0)
 233                 _resp->options |= RES_USE_DNSSEC;
 234 #endif /* RES_USE_DNSEC */
 235
 236         /* make query */
 237         length = res_query(hostname, (signed int) rdclass, (signed int) rdtype,
 238             answer, sizeof(answer));
 239         if (length < 0) {
 240                 switch(h_errno) {
 241                 case HOST_NOT_FOUND:
 242                         result = ERRSET_NONAME;
 243                         goto fail;
 244                 case NO_DATA:
 245                         result = ERRSET_NODATA;
 246                         goto fail;
 247                 default:
 248                         result = ERRSET_FAIL;
 249                         goto fail;
 250                 }
 251         }
 252
 253         /* parse result */
 254         response = parse_dns_response(answer, length);
 255         if (response == NULL) {
 256                 result = ERRSET_FAIL;
 257                 goto fail;
 258         }
 259
 260         if (response->header.qdcount != 1) {
 261                 result = ERRSET_FAIL;
 262                 goto fail;
 263         }
 264
 265         /* initialize rrset */
 266         rrset = calloc(1, sizeof(struct rrsetinfo));
 267         if (rrset == NULL) {
 268                 result = ERRSET_NOMEMORY;
 269                 goto fail;
 270         }
 271         rrset->rri_rdclass = response->query->class;
 272         rrset->rri_rdtype = response->query->type;
 273         rrset->rri_ttl = response->answer->ttl;
 274         rrset->rri_nrdatas = response->header.ancount;
 275
 276 #ifdef HAVE_HEADER_AD
 277         /* check for authenticated data */
 278         if (response->header.ad == 1)
 279                 rrset->rri_flags |= RRSET_VALIDATED;
 280 #endif
 281
 282         /* copy name from answer section */
 283         rrset->rri_name = strdup(response->answer->name);
 284         if (rrset->rri_name == NULL) {
 285                 result = ERRSET_NOMEMORY;
 286                 goto fail;
 287         }
 288
 289         /* count answers */
 290         rrset->rri_nrdatas = count_dns_rr(response->answer, rrset->rri_rdclass,
 291             rrset->rri_rdtype);
 292         rrset->rri_nsigs = count_dns_rr(response->answer, rrset->rri_rdclass,
 293             T_SIG);
 294
 295         /* allocate memory for answers */
 296         rrset->rri_rdatas = calloc(rrset->rri_nrdatas,
 297             sizeof(struct rdatainfo));
 298         if (rrset->rri_rdatas == NULL) {
 299                 result = ERRSET_NOMEMORY;
 300                 goto fail;
 301         }
 302
 303         /* allocate memory for signatures */
 304         rrset->rri_sigs = calloc(rrset->rri_nsigs, sizeof(struct rdatainfo));
 305         if (rrset->rri_sigs == NULL) {
 306                 result = ERRSET_NOMEMORY;
 307                 goto fail;
 308         }
 309
 310         /* copy answers & signatures */
 311         for (rr = response->answer, index_ans = 0, index_sig = 0;
 312             rr; rr = rr->next) {
 313
 314                 rdata = NULL;
 315
 316                 if (rr->class == rrset->rri_rdclass &&
 317                     rr->type  == rrset->rri_rdtype)
 318                         rdata = &rrset->rri_rdatas[index_ans++];
 319
 320                 if (rr->class == rrset->rri_rdclass &&
 321                     rr->type  == T_SIG)
 322                         rdata = &rrset->rri_sigs[index_sig++];
 323
 324                 if (rdata) {
 325                         rdata->rdi_length = rr->size;
 326                         rdata->rdi_data   = malloc(rr->size);
 327
 328                         if (rdata->rdi_data == NULL) {
 329                                 result = ERRSET_NOMEMORY;
 330                                 goto fail;
 331                         }
 332                         memcpy(rdata->rdi_data, rr->rdata, rr->size);
 333                 }
 334         }
 335         free_dns_response(response);
 336
 337         *res = rrset;
 338         return (ERRSET_SUCCESS);
 339
 340 fail:
 341         if (rrset != NULL)
 342                 freerrset(rrset);
 343         if (response != NULL)
 344                 free_dns_response(response);
 345         return (result);
 346 }
 347
 348 void
 349 freerrset(struct rrsetinfo *rrset)
 350 {
 351         u_int16_t i;
 352
 353         if (rrset == NULL)
 354                 return;
 355
 356         if (rrset->rri_rdatas) {
 357                 for (i = 0; i < rrset->rri_nrdatas; i++) {
 358                         if (rrset->rri_rdatas[i].rdi_data == NULL)
 359                                 break;
 360                         free(rrset->rri_rdatas[i].rdi_data);
 361                 }
 362                 free(rrset->rri_rdatas);
 363         }
 364
 365         if (rrset->rri_sigs) {
 366                 for (i = 0; i < rrset->rri_nsigs; i++) {
 367                         if (rrset->rri_sigs[i].rdi_data == NULL)
 368                                 break;
 369                         free(rrset->rri_sigs[i].rdi_data);
 370                 }
 371                 free(rrset->rri_sigs);
 372         }
 373
 374         if (rrset->rri_name)
 375                 free(rrset->rri_name);
 376         free(rrset);
 377 }
 378
 379 /*
 380  * DNS response parsing routines
 381  */
 382 static struct dns_response *
 383 parse_dns_response(const u_char *answer, int size)
 384 {
 385         struct dns_response *resp;
 386         const u_char *cp;
 387
 388         /* allocate memory for the response */
 389         resp = calloc(1, sizeof(*resp));
 390         if (resp == NULL)
 391                 return (NULL);
 392
 393         /* initialize current pointer */
 394         cp = answer;
 395
 396         /* copy header */
 397         memcpy(&resp->header, cp, HFIXEDSZ);
 398         cp += HFIXEDSZ;
 399
 400         /* fix header byte order */
 401         resp->header.qdcount = ntohs(resp->header.qdcount);
 402         resp->header.ancount = ntohs(resp->header.ancount);
 403         resp->header.nscount = ntohs(resp->header.nscount);
 404         resp->header.arcount = ntohs(resp->header.arcount);
 405
 406         /* there must be at least one query */
 407         if (resp->header.qdcount < 1) {
 408                 free_dns_response(resp);
 409                 return (NULL);
 410         }
 411
 412         /* parse query section */
 413         resp->query = parse_dns_qsection(answer, size, &cp,
 414             resp->header.qdcount);
 415         if (resp->header.qdcount && resp->query == NULL) {
 416                 free_dns_response(resp);
 417                 return (NULL);
 418         }
 419
 420         /* parse answer section */
 421         resp->answer = parse_dns_rrsection(answer, size, &cp,
 422             resp->header.ancount);
 423         if (resp->header.ancount && resp->answer == NULL) {
 424                 free_dns_response(resp);
 425                 return (NULL);
 426         }
 427
 428         /* parse authority section */
 429         resp->authority = parse_dns_rrsection(answer, size, &cp,
 430             resp->header.nscount);
 431         if (resp->header.nscount && resp->authority == NULL) {
 432                 free_dns_response(resp);
 433                 return (NULL);
 434         }
 435
 436         /* parse additional section */
 437         resp->additional = parse_dns_rrsection(answer, size, &cp,
 438             resp->header.arcount);
 439         if (resp->header.arcount && resp->additional == NULL) {
 440                 free_dns_response(resp);
 441                 return (NULL);
 442         }
 443
 444         return (resp);
 445 }
 446
 447 static struct dns_query *
 448 parse_dns_qsection(const u_char *answer, int size, const u_char **cp, int count)
 449 {
 450         struct dns_query *head, *curr, *prev;
 451         int i, length;
 452         char name[MAXDNAME];
 453
 454         for (i = 1, head = NULL, prev = NULL; i <= count; i++, prev = curr) {
 455
 456                 /* allocate and initialize struct */
 457                 curr = calloc(1, sizeof(struct dns_query));
 458                 if (curr == NULL) {
 459                         free_dns_query(head);
 460                         return (NULL);
 461                 }
 462                 if (head == NULL)
 463                         head = curr;
 464                 if (prev != NULL)
 465                         prev->next = curr;
 466
 467                 /* name */
 468                 length = dn_expand(answer, answer + size, *cp, name,
 469                     sizeof(name));
 470                 if (length < 0) {
 471                         free_dns_query(head);
 472                         return (NULL);
 473                 }
 474                 curr->name = strdup(name);
 475                 if (curr->name == NULL) {
 476                         free_dns_query(head);
 477                         return (NULL);
 478                 }
 479                 *cp += length;
 480
 481                 /* type */
 482                 curr->type = _getshort(*cp);
 483                 *cp += INT16SZ;
 484
 485                 /* class */
 486                 curr->class = _getshort(*cp);
 487                 *cp += INT16SZ;
 488         }
 489
 490         return (head);
 491 }
 492
 493 static struct dns_rr *
 494 parse_dns_rrsection(const u_char *answer, int size, const u_char **cp,
 495     int count)
 496 {
 497         struct dns_rr *head, *curr, *prev;
 498         int i, length;
 499         char name[MAXDNAME];
 500
 501         for (i = 1, head = NULL, prev = NULL; i <= count; i++, prev = curr) {
 502
 503                 /* allocate and initialize struct */
 504                 curr = calloc(1, sizeof(struct dns_rr));
 505                 if (curr == NULL) {
 506                         free_dns_rr(head);
 507                         return (NULL);
 508                 }
 509                 if (head == NULL)
 510                         head = curr;
 511                 if (prev != NULL)
 512                         prev->next = curr;
 513
 514                 /* name */
 515                 length = dn_expand(answer, answer + size, *cp, name,
 516                     sizeof(name));
 517                 if (length < 0) {
 518                         free_dns_rr(head);
 519                         return (NULL);
 520                 }
 521                 curr->name = strdup(name);
 522                 if (curr->name == NULL) {
 523                         free_dns_rr(head);
 524                         return (NULL);
 525                 }
 526                 *cp += length;
 527
 528                 /* type */
 529                 curr->type = _getshort(*cp);
 530                 *cp += INT16SZ;
 531
 532                 /* class */
 533                 curr->class = _getshort(*cp);
 534                 *cp += INT16SZ;
 535
 536                 /* ttl */
 537                 curr->ttl = _getlong(*cp);
 538                 *cp += INT32SZ;
 539
 540                 /* rdata size */
 541                 curr->size = _getshort(*cp);
 542                 *cp += INT16SZ;
 543
 544                 /* rdata itself */
 545                 curr->rdata = malloc(curr->size);
 546                 if (curr->rdata == NULL) {
 547                         free_dns_rr(head);
 548                         return (NULL);
 549                 }
 550                 memcpy(curr->rdata, *cp, curr->size);
 551                 *cp += curr->size;
 552         }
 553
 554         return (head);
 555 }
 556
 557 static void
 558 free_dns_query(struct dns_query *p)
 559 {
 560         if (p == NULL)
 561                 return;
 562
 563         if (p->name)
 564                 free(p->name);
 565         free_dns_query(p->next);
 566         free(p);
 567 }
 568
 569 static void
 570 free_dns_rr(struct dns_rr *p)
 571 {
 572         if (p == NULL)
 573                 return;
 574
 575         if (p->name)
 576                 free(p->name);
 577         if (p->rdata)
 578                 free(p->rdata);
 579         free_dns_rr(p->next);
 580         free(p);
 581 }
 582
 583 static void
 584 free_dns_response(struct dns_response *p)
 585 {
 586         if (p == NULL)
 587                 return;
 588
 589         free_dns_query(p->query);
 590         free_dns_rr(p->answer);
 591         free_dns_rr(p->authority);
 592         free_dns_rr(p->additional);
 593         free(p);
 594 }
 595
 596 static int
 597 count_dns_rr(struct dns_rr *p, u_int16_t class, u_int16_t type)
 598 {
 599         int n = 0;
 600
 601         while(p) {
 602                 if (p->class == class && p->type == type)
 603                         n++;
 604                 p = p->next;
 605         }
 606
 607         return (n);
 608 }
 609
 610 #endif /* !defined(HAVE_GETRRSETBYNAME) */