1 /* 2 * util/data/msgparse.c - parse wireformat DNS messages. 3 * 4 * Copyright (c) 2007, NLnet Labs. All rights reserved. 5 * 6 * This software is open source. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * Redistributions of source code must retain the above copyright notice, 13 * this list of conditions and the following disclaimer. 14 * 15 * Redistributions in binary form must reproduce the above copyright notice, 16 * this list of conditions and the following disclaimer in the documentation 17 * and/or other materials provided with the distribution. 18 * 19 * Neither the name of the NLNET LABS nor the names of its contributors may 20 * be used to endorse or promote products derived from this software without 21 * specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 25 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 26 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE 27 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 30 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 31 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 32 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 33 * POSSIBILITY OF SUCH DAMAGE. 34 */ 35 /** 36 * \file 37 * Routines for message parsing a packet buffer to a descriptive structure. 38 */ 39 #include "config.h" 40 #include <ldns/ldns.h> 41 #include "util/data/msgparse.h" 42 #include "util/net_help.h" 43 #include "util/data/dname.h" 44 #include "util/data/packed_rrset.h" 45 #include "util/storage/lookup3.h" 46 #include "util/regional.h" 47 48 /** smart comparison of (compressed, valid) dnames from packet */ 49 static int 50 smart_compare(ldns_buffer* pkt, uint8_t* dnow, 51 uint8_t* dprfirst, uint8_t* dprlast) 52 { 53 if(LABEL_IS_PTR(*dnow)) { 54 /* ptr points to a previous dname */ 55 uint8_t* p = ldns_buffer_at(pkt, PTR_OFFSET(dnow[0], dnow[1])); 56 if( p == dprfirst || p == dprlast ) 57 return 0; 58 /* prev dname is also a ptr, both ptrs are the same. */ 59 if(LABEL_IS_PTR(*dprlast) && 60 dprlast[0] == dnow[0] && dprlast[1] == dnow[1]) 61 return 0; 62 } 63 return dname_pkt_compare(pkt, dnow, dprlast); 64 } 65 66 /** 67 * Allocate new rrset in region, fill with data. 68 */ 69 static struct rrset_parse* 70 new_rrset(struct msg_parse* msg, uint8_t* dname, size_t dnamelen, 71 uint16_t type, uint16_t dclass, hashvalue_t hash, 72 uint32_t rrset_flags, ldns_pkt_section section, 73 struct regional* region) 74 { 75 struct rrset_parse* p = regional_alloc(region, sizeof(*p)); 76 if(!p) return NULL; 77 p->rrset_bucket_next = msg->hashtable[hash & (PARSE_TABLE_SIZE-1)]; 78 msg->hashtable[hash & (PARSE_TABLE_SIZE-1)] = p; 79 p->rrset_all_next = 0; 80 if(msg->rrset_last) 81 msg->rrset_last->rrset_all_next = p; 82 else msg->rrset_first = p; 83 msg->rrset_last = p; 84 p->hash = hash; 85 p->section = section; 86 p->dname = dname; 87 p->dname_len = dnamelen; 88 p->type = type; 89 p->rrset_class = dclass; 90 p->flags = rrset_flags; 91 p->rr_count = 0; 92 p->size = 0; 93 p->rr_first = 0; 94 p->rr_last = 0; 95 p->rrsig_count = 0; 96 p->rrsig_first = 0; 97 p->rrsig_last = 0; 98 return p; 99 } 100 101 /** See if next rrset is nsec at zone apex */ 102 static int 103 nsec_at_apex(ldns_buffer* pkt) 104 { 105 /* we are at ttl position in packet. */ 106 size_t pos = ldns_buffer_position(pkt); 107 uint16_t rdatalen; 108 if(ldns_buffer_remaining(pkt) < 7) /* ttl+len+root */ 109 return 0; /* eek! */ 110 ldns_buffer_skip(pkt, 4); /* ttl */; 111 rdatalen = ldns_buffer_read_u16(pkt); 112 if(ldns_buffer_remaining(pkt) < rdatalen) { 113 ldns_buffer_set_position(pkt, pos); 114 return 0; /* parse error happens later */ 115 } 116 /* must validate the nsec next domain name format */ 117 if(pkt_dname_len(pkt) == 0) { 118 ldns_buffer_set_position(pkt, pos); 119 return 0; /* parse error */ 120 } 121 122 /* see if SOA bit is set. */ 123 if(ldns_buffer_position(pkt) < pos+4+rdatalen) { 124 /* nsec type bitmap contains items */ 125 uint8_t win, blen, bits; 126 /* need: windownum, bitmap len, firstbyte */ 127 if(ldns_buffer_position(pkt)+3 > pos+4+rdatalen) { 128 ldns_buffer_set_position(pkt, pos); 129 return 0; /* malformed nsec */ 130 } 131 win = ldns_buffer_read_u8(pkt); 132 blen = ldns_buffer_read_u8(pkt); 133 bits = ldns_buffer_read_u8(pkt); 134 /* 0window always first window. bitlen >=1 or parse 135 error really. bit 0x2 is SOA. */ 136 if(win == 0 && blen >= 1 && (bits & 0x02)) { 137 ldns_buffer_set_position(pkt, pos); 138 return 1; 139 } 140 } 141 142 ldns_buffer_set_position(pkt, pos); 143 return 0; 144 } 145 146 /** Calculate rrset flags */ 147 static uint32_t 148 pkt_rrset_flags(ldns_buffer* pkt, uint16_t type, ldns_pkt_section sec) 149 { 150 uint32_t f = 0; 151 if(type == LDNS_RR_TYPE_NSEC && nsec_at_apex(pkt)) { 152 f |= PACKED_RRSET_NSEC_AT_APEX; 153 } else if(type == LDNS_RR_TYPE_SOA && sec == LDNS_SECTION_AUTHORITY) { 154 f |= PACKED_RRSET_SOA_NEG; 155 } 156 return f; 157 } 158 159 hashvalue_t 160 pkt_hash_rrset(ldns_buffer* pkt, uint8_t* dname, uint16_t type, 161 uint16_t dclass, uint32_t rrset_flags) 162 { 163 /* note this MUST be identical to rrset_key_hash in packed_rrset.c */ 164 /* this routine handles compressed names */ 165 hashvalue_t h = 0xab; 166 h = dname_pkt_hash(pkt, dname, h); 167 h = hashlittle(&type, sizeof(type), h); /* host order */ 168 h = hashlittle(&dclass, sizeof(dclass), h); /* netw order */ 169 h = hashlittle(&rrset_flags, sizeof(uint32_t), h); 170 return h; 171 } 172 173 /** create partial dname hash for rrset hash */ 174 static hashvalue_t 175 pkt_hash_rrset_first(ldns_buffer* pkt, uint8_t* dname) 176 { 177 /* works together with pkt_hash_rrset_rest */ 178 /* note this MUST be identical to rrset_key_hash in packed_rrset.c */ 179 /* this routine handles compressed names */ 180 hashvalue_t h = 0xab; 181 h = dname_pkt_hash(pkt, dname, h); 182 return h; 183 } 184 185 /** create a rrset hash from a partial dname hash */ 186 static hashvalue_t 187 pkt_hash_rrset_rest(hashvalue_t dname_h, uint16_t type, uint16_t dclass, 188 uint32_t rrset_flags) 189 { 190 /* works together with pkt_hash_rrset_first */ 191 /* note this MUST be identical to rrset_key_hash in packed_rrset.c */ 192 hashvalue_t h; 193 h = hashlittle(&type, sizeof(type), dname_h); /* host order */ 194 h = hashlittle(&dclass, sizeof(dclass), h); /* netw order */ 195 h = hashlittle(&rrset_flags, sizeof(uint32_t), h); 196 return h; 197 } 198 199 /** compare rrset_parse with data */ 200 static int 201 rrset_parse_equals(struct rrset_parse* p, ldns_buffer* pkt, hashvalue_t h, 202 uint32_t rrset_flags, uint8_t* dname, size_t dnamelen, 203 uint16_t type, uint16_t dclass) 204 { 205 if(p->hash == h && p->dname_len == dnamelen && p->type == type && 206 p->rrset_class == dclass && p->flags == rrset_flags && 207 dname_pkt_compare(pkt, dname, p->dname) == 0) 208 return 1; 209 return 0; 210 } 211 212 213 struct rrset_parse* 214 msgparse_hashtable_lookup(struct msg_parse* msg, ldns_buffer* pkt, 215 hashvalue_t h, uint32_t rrset_flags, uint8_t* dname, size_t dnamelen, 216 uint16_t type, uint16_t dclass) 217 { 218 struct rrset_parse* p = msg->hashtable[h & (PARSE_TABLE_SIZE-1)]; 219 while(p) { 220 if(rrset_parse_equals(p, pkt, h, rrset_flags, dname, dnamelen, 221 type, dclass)) 222 return p; 223 p = p->rrset_bucket_next; 224 } 225 return NULL; 226 } 227 228 /** return type networkformat that rrsig in packet covers */ 229 static int 230 pkt_rrsig_covered(ldns_buffer* pkt, uint8_t* here, uint16_t* type) 231 { 232 size_t pos = ldns_buffer_position(pkt); 233 ldns_buffer_set_position(pkt, (size_t)(here-ldns_buffer_begin(pkt))); 234 /* ttl + len + size of small rrsig(rootlabel, no signature) */ 235 if(ldns_buffer_remaining(pkt) < 4+2+19) 236 return 0; 237 ldns_buffer_skip(pkt, 4); /* ttl */ 238 if(ldns_buffer_read_u16(pkt) < 19) /* too short */ { 239 ldns_buffer_set_position(pkt, pos); 240 return 0; 241 } 242 *type = ldns_buffer_read_u16(pkt); 243 ldns_buffer_set_position(pkt, pos); 244 return 1; 245 } 246 247 /** true if covered type equals prevtype */ 248 static int 249 pkt_rrsig_covered_equals(ldns_buffer* pkt, uint8_t* here, uint16_t type) 250 { 251 uint16_t t; 252 if(pkt_rrsig_covered(pkt, here, &t) && t == type) 253 return 1; 254 return 0; 255 } 256 257 void 258 msgparse_bucket_remove(struct msg_parse* msg, struct rrset_parse* rrset) 259 { 260 struct rrset_parse** p; 261 p = &msg->hashtable[ rrset->hash & (PARSE_TABLE_SIZE-1) ]; 262 while(*p) { 263 if(*p == rrset) { 264 *p = rrset->rrset_bucket_next; 265 return; 266 } 267 p = &( (*p)->rrset_bucket_next ); 268 } 269 } 270 271 /** change section of rrset from previous to current section */ 272 static void 273 change_section(struct msg_parse* msg, struct rrset_parse* rrset, 274 ldns_pkt_section section) 275 { 276 struct rrset_parse *p, *prev; 277 /* remove from list */ 278 if(section == rrset->section) 279 return; 280 p = msg->rrset_first; 281 prev = 0; 282 while(p) { 283 if(p == rrset) { 284 if(prev) prev->rrset_all_next = p->rrset_all_next; 285 else msg->rrset_first = p->rrset_all_next; 286 if(msg->rrset_last == rrset) 287 msg->rrset_last = prev; 288 break; 289 } 290 prev = p; 291 p = p->rrset_all_next; 292 } 293 /* remove from count */ 294 switch(rrset->section) { 295 case LDNS_SECTION_ANSWER: msg->an_rrsets--; break; 296 case LDNS_SECTION_AUTHORITY: msg->ns_rrsets--; break; 297 case LDNS_SECTION_ADDITIONAL: msg->ar_rrsets--; break; 298 default: log_assert(0); 299 } 300 /* insert at end of list */ 301 rrset->rrset_all_next = 0; 302 if(msg->rrset_last) 303 msg->rrset_last->rrset_all_next = rrset; 304 else msg->rrset_first = rrset; 305 msg->rrset_last = rrset; 306 /* up count of new section */ 307 switch(section) { 308 case LDNS_SECTION_AUTHORITY: msg->ns_rrsets++; break; 309 case LDNS_SECTION_ADDITIONAL: msg->ar_rrsets++; break; 310 default: log_assert(0); 311 } 312 rrset->section = section; 313 } 314 315 /** see if rrset of type RRSIG contains sig over given type */ 316 static int 317 rrset_has_sigover(ldns_buffer* pkt, struct rrset_parse* rrset, uint16_t type, 318 int* hasother) 319 { 320 int res = 0; 321 struct rr_parse* rr = rrset->rr_first; 322 log_assert( rrset->type == LDNS_RR_TYPE_RRSIG ); 323 while(rr) { 324 if(pkt_rrsig_covered_equals(pkt, rr->ttl_data, type)) 325 res = 1; 326 else *hasother = 1; 327 rr = rr->next; 328 } 329 return res; 330 } 331 332 /** move rrsigs from sigset to dataset */ 333 static int 334 moveover_rrsigs(ldns_buffer* pkt, struct regional* region, 335 struct rrset_parse* sigset, struct rrset_parse* dataset, int duplicate) 336 { 337 struct rr_parse* sig = sigset->rr_first; 338 struct rr_parse* prev = NULL; 339 struct rr_parse* insert; 340 struct rr_parse* nextsig; 341 while(sig) { 342 nextsig = sig->next; 343 if(pkt_rrsig_covered_equals(pkt, sig->ttl_data, 344 dataset->type)) { 345 if(duplicate) { 346 /* new */ 347 insert = (struct rr_parse*)regional_alloc( 348 region, sizeof(struct rr_parse)); 349 if(!insert) return 0; 350 insert->outside_packet = 0; 351 insert->ttl_data = sig->ttl_data; 352 insert->size = sig->size; 353 /* prev not used */ 354 } else { 355 /* remove from sigset */ 356 if(prev) prev->next = sig->next; 357 else sigset->rr_first = sig->next; 358 if(sigset->rr_last == sig) 359 sigset->rr_last = prev; 360 sigset->rr_count--; 361 sigset->size -= sig->size; 362 insert = sig; 363 /* prev not changed */ 364 } 365 /* add to dataset */ 366 dataset->rrsig_count++; 367 insert->next = 0; 368 if(dataset->rrsig_last) 369 dataset->rrsig_last->next = insert; 370 else dataset->rrsig_first = insert; 371 dataset->rrsig_last = insert; 372 dataset->size += insert->size; 373 } else { 374 prev = sig; 375 } 376 sig = nextsig; 377 } 378 return 1; 379 } 380 381 /** change an rrsig rrset for use as data rrset */ 382 static struct rrset_parse* 383 change_rrsig_rrset(struct rrset_parse* sigset, struct msg_parse* msg, 384 ldns_buffer* pkt, uint16_t datatype, uint32_t rrset_flags, 385 int hasother, ldns_pkt_section section, struct regional* region) 386 { 387 struct rrset_parse* dataset = sigset; 388 hashvalue_t hash = pkt_hash_rrset(pkt, sigset->dname, datatype, 389 sigset->rrset_class, rrset_flags); 390 log_assert( sigset->type == LDNS_RR_TYPE_RRSIG ); 391 log_assert( datatype != LDNS_RR_TYPE_RRSIG ); 392 if(hasother) { 393 /* need to make new rrset to hold data type */ 394 dataset = new_rrset(msg, sigset->dname, sigset->dname_len, 395 datatype, sigset->rrset_class, hash, rrset_flags, 396 section, region); 397 if(!dataset) 398 return NULL; 399 switch(section) { 400 case LDNS_SECTION_ANSWER: msg->an_rrsets++; break; 401 case LDNS_SECTION_AUTHORITY: msg->ns_rrsets++; break; 402 case LDNS_SECTION_ADDITIONAL: msg->ar_rrsets++; break; 403 default: log_assert(0); 404 } 405 if(!moveover_rrsigs(pkt, region, sigset, dataset, 406 msg->qtype == LDNS_RR_TYPE_RRSIG || 407 (msg->qtype == LDNS_RR_TYPE_ANY && 408 section != LDNS_SECTION_ANSWER) )) 409 return NULL; 410 return dataset; 411 } 412 /* changeover the type of the rrset to data set */ 413 msgparse_bucket_remove(msg, dataset); 414 /* insert into new hash bucket */ 415 dataset->rrset_bucket_next = msg->hashtable[hash&(PARSE_TABLE_SIZE-1)]; 416 msg->hashtable[hash&(PARSE_TABLE_SIZE-1)] = dataset; 417 dataset->hash = hash; 418 /* use section of data item for result */ 419 change_section(msg, dataset, section); 420 dataset->type = datatype; 421 dataset->flags = rrset_flags; 422 dataset->rrsig_count += dataset->rr_count; 423 dataset->rr_count = 0; 424 /* move sigs to end of siglist */ 425 if(dataset->rrsig_last) 426 dataset->rrsig_last->next = dataset->rr_first; 427 else dataset->rrsig_first = dataset->rr_first; 428 dataset->rrsig_last = dataset->rr_last; 429 dataset->rr_first = 0; 430 dataset->rr_last = 0; 431 return dataset; 432 } 433 434 /** Find rrset. If equal to previous it is fast. hash if not so. 435 * @param msg: the message with hash table. 436 * @param pkt: the packet in wireformat (needed for compression ptrs). 437 * @param dname: pointer to start of dname (compressed) in packet. 438 * @param dnamelen: uncompressed wirefmt length of dname. 439 * @param type: type of current rr. 440 * @param dclass: class of current rr. 441 * @param hash: hash value is returned if the rrset could not be found. 442 * @param rrset_flags: is returned if the rrset could not be found. 443 * @param prev_dname_first: dname of last seen RR. First seen dname. 444 * @param prev_dname_last: dname of last seen RR. Last seen dname. 445 * @param prev_dnamelen: dname len of last seen RR. 446 * @param prev_type: type of last seen RR. 447 * @param prev_dclass: class of last seen RR. 448 * @param rrset_prev: last seen RRset. 449 * @param section: the current section in the packet. 450 * @param region: used to allocate temporary parsing data. 451 * @return 0 on out of memory. 452 */ 453 static int 454 find_rrset(struct msg_parse* msg, ldns_buffer* pkt, uint8_t* dname, 455 size_t dnamelen, uint16_t type, uint16_t dclass, hashvalue_t* hash, 456 uint32_t* rrset_flags, 457 uint8_t** prev_dname_first, uint8_t** prev_dname_last, 458 size_t* prev_dnamelen, uint16_t* prev_type, 459 uint16_t* prev_dclass, struct rrset_parse** rrset_prev, 460 ldns_pkt_section section, struct regional* region) 461 { 462 hashvalue_t dname_h = pkt_hash_rrset_first(pkt, dname); 463 uint16_t covtype; 464 if(*rrset_prev) { 465 /* check if equal to previous item */ 466 if(type == *prev_type && dclass == *prev_dclass && 467 dnamelen == *prev_dnamelen && 468 smart_compare(pkt, dname, *prev_dname_first, 469 *prev_dname_last) == 0 && 470 type != LDNS_RR_TYPE_RRSIG) { 471 /* same as previous */ 472 *prev_dname_last = dname; 473 return 1; 474 } 475 /* check if rrsig over previous item */ 476 if(type == LDNS_RR_TYPE_RRSIG && dclass == *prev_dclass && 477 pkt_rrsig_covered_equals(pkt, ldns_buffer_current(pkt), 478 *prev_type) && 479 smart_compare(pkt, dname, *prev_dname_first, 480 *prev_dname_last) == 0) { 481 /* covers previous */ 482 *prev_dname_last = dname; 483 return 1; 484 } 485 } 486 /* find by hashing and lookup in hashtable */ 487 *rrset_flags = pkt_rrset_flags(pkt, type, section); 488 489 /* if rrsig - try to lookup matching data set first */ 490 if(type == LDNS_RR_TYPE_RRSIG && pkt_rrsig_covered(pkt, 491 ldns_buffer_current(pkt), &covtype)) { 492 *hash = pkt_hash_rrset_rest(dname_h, covtype, dclass, 493 *rrset_flags); 494 *rrset_prev = msgparse_hashtable_lookup(msg, pkt, *hash, 495 *rrset_flags, dname, dnamelen, covtype, dclass); 496 if(!*rrset_prev && covtype == LDNS_RR_TYPE_NSEC) { 497 /* if NSEC try with NSEC apex bit twiddled */ 498 *rrset_flags ^= PACKED_RRSET_NSEC_AT_APEX; 499 *hash = pkt_hash_rrset_rest(dname_h, covtype, dclass, 500 *rrset_flags); 501 *rrset_prev = msgparse_hashtable_lookup(msg, pkt, 502 *hash, *rrset_flags, dname, dnamelen, covtype, 503 dclass); 504 if(!*rrset_prev) /* untwiddle if not found */ 505 *rrset_flags ^= PACKED_RRSET_NSEC_AT_APEX; 506 } 507 if(!*rrset_prev && covtype == LDNS_RR_TYPE_SOA) { 508 /* if SOA try with SOA neg flag twiddled */ 509 *rrset_flags ^= PACKED_RRSET_SOA_NEG; 510 *hash = pkt_hash_rrset_rest(dname_h, covtype, dclass, 511 *rrset_flags); 512 *rrset_prev = msgparse_hashtable_lookup(msg, pkt, 513 *hash, *rrset_flags, dname, dnamelen, covtype, 514 dclass); 515 if(!*rrset_prev) /* untwiddle if not found */ 516 *rrset_flags ^= PACKED_RRSET_SOA_NEG; 517 } 518 if(*rrset_prev) { 519 *prev_dname_first = (*rrset_prev)->dname; 520 *prev_dname_last = dname; 521 *prev_dnamelen = dnamelen; 522 *prev_type = covtype; 523 *prev_dclass = dclass; 524 return 1; 525 } 526 } 527 if(type != LDNS_RR_TYPE_RRSIG) { 528 int hasother = 0; 529 /* find matching rrsig */ 530 *hash = pkt_hash_rrset_rest(dname_h, LDNS_RR_TYPE_RRSIG, 531 dclass, 0); 532 *rrset_prev = msgparse_hashtable_lookup(msg, pkt, *hash, 533 0, dname, dnamelen, LDNS_RR_TYPE_RRSIG, 534 dclass); 535 if(*rrset_prev && rrset_has_sigover(pkt, *rrset_prev, type, 536 &hasother)) { 537 /* yes! */ 538 *prev_dname_first = (*rrset_prev)->dname; 539 *prev_dname_last = dname; 540 *prev_dnamelen = dnamelen; 541 *prev_type = type; 542 *prev_dclass = dclass; 543 *rrset_prev = change_rrsig_rrset(*rrset_prev, msg, 544 pkt, type, *rrset_flags, hasother, section, 545 region); 546 if(!*rrset_prev) return 0; 547 return 1; 548 } 549 } 550 551 *hash = pkt_hash_rrset_rest(dname_h, type, dclass, *rrset_flags); 552 *rrset_prev = msgparse_hashtable_lookup(msg, pkt, *hash, *rrset_flags, 553 dname, dnamelen, type, dclass); 554 if(*rrset_prev) 555 *prev_dname_first = (*rrset_prev)->dname; 556 else *prev_dname_first = dname; 557 *prev_dname_last = dname; 558 *prev_dnamelen = dnamelen; 559 *prev_type = type; 560 *prev_dclass = dclass; 561 return 1; 562 } 563 564 /** 565 * Parse query section. 566 * @param pkt: packet, position at call must be at start of query section. 567 * at end position is after query section. 568 * @param msg: store results here. 569 * @return: 0 if OK, or rcode on error. 570 */ 571 static int 572 parse_query_section(ldns_buffer* pkt, struct msg_parse* msg) 573 { 574 if(msg->qdcount == 0) 575 return 0; 576 if(msg->qdcount > 1) 577 return LDNS_RCODE_FORMERR; 578 log_assert(msg->qdcount == 1); 579 if(ldns_buffer_remaining(pkt) <= 0) 580 return LDNS_RCODE_FORMERR; 581 msg->qname = ldns_buffer_current(pkt); 582 if((msg->qname_len = pkt_dname_len(pkt)) == 0) 583 return LDNS_RCODE_FORMERR; 584 if(ldns_buffer_remaining(pkt) < sizeof(uint16_t)*2) 585 return LDNS_RCODE_FORMERR; 586 msg->qtype = ldns_buffer_read_u16(pkt); 587 msg->qclass = ldns_buffer_read_u16(pkt); 588 return 0; 589 } 590 591 size_t 592 get_rdf_size(ldns_rdf_type rdf) 593 { 594 switch(rdf) { 595 case LDNS_RDF_TYPE_CLASS: 596 case LDNS_RDF_TYPE_ALG: 597 case LDNS_RDF_TYPE_INT8: 598 return 1; 599 break; 600 case LDNS_RDF_TYPE_INT16: 601 case LDNS_RDF_TYPE_TYPE: 602 case LDNS_RDF_TYPE_CERT_ALG: 603 return 2; 604 break; 605 case LDNS_RDF_TYPE_INT32: 606 case LDNS_RDF_TYPE_TIME: 607 case LDNS_RDF_TYPE_A: 608 case LDNS_RDF_TYPE_PERIOD: 609 return 4; 610 break; 611 case LDNS_RDF_TYPE_TSIGTIME: 612 return 6; 613 break; 614 case LDNS_RDF_TYPE_AAAA: 615 return 16; 616 break; 617 default: 618 log_assert(false); /* add type above */ 619 /* only types that appear before a domain * 620 * name are needed. rest is simply copied. */ 621 } 622 return 0; 623 } 624 625 /** calculate the size of one rr */ 626 static int 627 calc_size(ldns_buffer* pkt, uint16_t type, struct rr_parse* rr) 628 { 629 const ldns_rr_descriptor* desc; 630 uint16_t pkt_len; /* length of rr inside the packet */ 631 rr->size = sizeof(uint16_t); /* the rdatalen */ 632 ldns_buffer_skip(pkt, 4); /* skip ttl */ 633 pkt_len = ldns_buffer_read_u16(pkt); 634 if(ldns_buffer_remaining(pkt) < pkt_len) 635 return 0; 636 desc = ldns_rr_descript(type); 637 if(pkt_len > 0 && desc && desc->_dname_count > 0) { 638 int count = (int)desc->_dname_count; 639 int rdf = 0; 640 size_t len; 641 size_t oldpos; 642 /* skip first part. */ 643 while(pkt_len > 0 && count) { 644 switch(desc->_wireformat[rdf]) { 645 case LDNS_RDF_TYPE_DNAME: 646 /* decompress every domain name */ 647 oldpos = ldns_buffer_position(pkt); 648 if((len = pkt_dname_len(pkt)) == 0) 649 return 0; /* malformed dname */ 650 if(ldns_buffer_position(pkt)-oldpos > pkt_len) 651 return 0; /* dname exceeds rdata */ 652 pkt_len -= ldns_buffer_position(pkt)-oldpos; 653 rr->size += len; 654 count--; 655 len = 0; 656 break; 657 case LDNS_RDF_TYPE_STR: 658 if(pkt_len < 1) 659 return 0; /* len byte exceeds rdata */ 660 len = ldns_buffer_current(pkt)[0] + 1; 661 break; 662 default: 663 len = get_rdf_size(desc->_wireformat[rdf]); 664 } 665 if(len) { 666 if(pkt_len < len) 667 return 0; /* exceeds rdata */ 668 pkt_len -= len; 669 ldns_buffer_skip(pkt, (ssize_t)len); 670 rr->size += len; 671 } 672 rdf++; 673 } 674 } 675 /* remaining rdata */ 676 rr->size += pkt_len; 677 ldns_buffer_skip(pkt, (ssize_t)pkt_len); 678 return 1; 679 } 680 681 /** skip rr ttl and rdata */ 682 static int 683 skip_ttl_rdata(ldns_buffer* pkt) 684 { 685 uint16_t rdatalen; 686 if(ldns_buffer_remaining(pkt) < 6) /* ttl + rdatalen */ 687 return 0; 688 ldns_buffer_skip(pkt, 4); /* ttl */ 689 rdatalen = ldns_buffer_read_u16(pkt); 690 if(ldns_buffer_remaining(pkt) < rdatalen) 691 return 0; 692 ldns_buffer_skip(pkt, (ssize_t)rdatalen); 693 return 1; 694 } 695 696 /** see if RRSIG is a duplicate of another */ 697 static int 698 sig_is_double(ldns_buffer* pkt, struct rrset_parse* rrset, uint8_t* ttldata) 699 { 700 uint16_t rlen, siglen; 701 size_t pos = ldns_buffer_position(pkt); 702 struct rr_parse* sig; 703 if(ldns_buffer_remaining(pkt) < 6) 704 return 0; 705 ldns_buffer_skip(pkt, 4); /* ttl */ 706 rlen = ldns_buffer_read_u16(pkt); 707 if(ldns_buffer_remaining(pkt) < rlen) { 708 ldns_buffer_set_position(pkt, pos); 709 return 0; 710 } 711 ldns_buffer_set_position(pkt, pos); 712 713 sig = rrset->rrsig_first; 714 while(sig) { 715 /* check if rdatalen is same */ 716 memmove(&siglen, sig->ttl_data+4, sizeof(siglen)); 717 siglen = ntohs(siglen); 718 /* checks if data in packet is exactly the same, this means 719 * also dname in rdata is the same, but rrsig is not allowed 720 * to have compressed dnames anyway. If it is compressed anyway 721 * it will lead to duplicate rrs for qtype=RRSIG. (or ANY). 722 * 723 * Cannot use sig->size because size of the other one is not 724 * calculated yet. 725 */ 726 if(siglen == rlen) { 727 if(siglen>0 && memcmp(sig->ttl_data+6, ttldata+6, 728 siglen) == 0) { 729 /* same! */ 730 return 1; 731 } 732 } 733 sig = sig->next; 734 } 735 return 0; 736 } 737 738 /** Add rr (from packet here) to rrset, skips rr */ 739 static int 740 add_rr_to_rrset(struct rrset_parse* rrset, ldns_buffer* pkt, 741 struct msg_parse* msg, struct regional* region, 742 ldns_pkt_section section, uint16_t type) 743 { 744 struct rr_parse* rr; 745 /* check section of rrset. */ 746 if(rrset->section != section && type != LDNS_RR_TYPE_RRSIG && 747 rrset->type != LDNS_RR_TYPE_RRSIG) { 748 /* silently drop it - we drop the last part, since 749 * trust in rr data depends on the section it is in. 750 * the less trustworthy part is discarded. 751 * also the last part is more likely to be incomplete. 752 * RFC 2181: must put RRset only once in response. */ 753 /* 754 verbose(VERB_QUERY, "Packet contains rrset data in " 755 "multiple sections, dropped last part."); 756 log_buf(VERB_QUERY, "packet was", pkt); 757 */ 758 /* forwards */ 759 if(!skip_ttl_rdata(pkt)) 760 return LDNS_RCODE_FORMERR; 761 return 0; 762 } 763 764 if( (msg->qtype == LDNS_RR_TYPE_RRSIG || 765 msg->qtype == LDNS_RR_TYPE_ANY) 766 && sig_is_double(pkt, rrset, ldns_buffer_current(pkt))) { 767 if(!skip_ttl_rdata(pkt)) 768 return LDNS_RCODE_FORMERR; 769 return 0; 770 } 771 772 /* create rr */ 773 if(!(rr = (struct rr_parse*)regional_alloc(region, sizeof(*rr)))) 774 return LDNS_RCODE_SERVFAIL; 775 rr->outside_packet = 0; 776 rr->ttl_data = ldns_buffer_current(pkt); 777 rr->next = 0; 778 if(type == LDNS_RR_TYPE_RRSIG && rrset->type != LDNS_RR_TYPE_RRSIG) { 779 if(rrset->rrsig_last) 780 rrset->rrsig_last->next = rr; 781 else rrset->rrsig_first = rr; 782 rrset->rrsig_last = rr; 783 rrset->rrsig_count++; 784 } else { 785 if(rrset->rr_last) 786 rrset->rr_last->next = rr; 787 else rrset->rr_first = rr; 788 rrset->rr_last = rr; 789 rrset->rr_count++; 790 } 791 792 /* calc decompressed size */ 793 if(!calc_size(pkt, type, rr)) 794 return LDNS_RCODE_FORMERR; 795 rrset->size += rr->size; 796 797 return 0; 798 } 799 800 /** 801 * Parse packet RR section, for answer, authority and additional sections. 802 * @param pkt: packet, position at call must be at start of section. 803 * at end position is after section. 804 * @param msg: store results here. 805 * @param region: how to alloc results. 806 * @param section: section enum. 807 * @param num_rrs: how many rrs are in the section. 808 * @param num_rrsets: returns number of rrsets in the section. 809 * @return: 0 if OK, or rcode on error. 810 */ 811 static int 812 parse_section(ldns_buffer* pkt, struct msg_parse* msg, 813 struct regional* region, ldns_pkt_section section, 814 uint16_t num_rrs, size_t* num_rrsets) 815 { 816 uint16_t i; 817 uint8_t* dname, *prev_dname_f = NULL, *prev_dname_l = NULL; 818 size_t dnamelen, prev_dnamelen = 0; 819 uint16_t type, prev_type = 0; 820 uint16_t dclass, prev_dclass = 0; 821 uint32_t rrset_flags = 0; 822 hashvalue_t hash = 0; 823 struct rrset_parse* rrset = NULL; 824 int r; 825 826 if(num_rrs == 0) 827 return 0; 828 if(ldns_buffer_remaining(pkt) <= 0) 829 return LDNS_RCODE_FORMERR; 830 for(i=0; i<num_rrs; i++) { 831 /* parse this RR. */ 832 dname = ldns_buffer_current(pkt); 833 if((dnamelen = pkt_dname_len(pkt)) == 0) 834 return LDNS_RCODE_FORMERR; 835 if(ldns_buffer_remaining(pkt) < 10) /* type, class, ttl, len */ 836 return LDNS_RCODE_FORMERR; 837 type = ldns_buffer_read_u16(pkt); 838 ldns_buffer_read(pkt, &dclass, sizeof(dclass)); 839 840 if(0) { /* debug show what is being parsed. */ 841 if(type == LDNS_RR_TYPE_RRSIG) { 842 uint16_t t; 843 if(pkt_rrsig_covered(pkt, 844 ldns_buffer_current(pkt), &t)) 845 fprintf(stderr, "parse of %s(%d) [%s(%d)]", 846 ldns_rr_descript(type)? 847 ldns_rr_descript(type)->_name: "??", 848 (int)type, 849 ldns_rr_descript(t)? 850 ldns_rr_descript(t)->_name: "??", 851 (int)t); 852 } else 853 fprintf(stderr, "parse of %s(%d)", 854 ldns_rr_descript(type)? 855 ldns_rr_descript(type)->_name: "??", 856 (int)type); 857 fprintf(stderr, " %s(%d) ", 858 ldns_lookup_by_id(ldns_rr_classes, 859 (int)ntohs(dclass))?ldns_lookup_by_id( 860 ldns_rr_classes, (int)ntohs(dclass))->name: 861 "??", (int)ntohs(dclass)); 862 dname_print(stderr, pkt, dname); 863 fprintf(stderr, "\n"); 864 } 865 866 /* see if it is part of an existing RR set */ 867 if(!find_rrset(msg, pkt, dname, dnamelen, type, dclass, &hash, 868 &rrset_flags, &prev_dname_f, &prev_dname_l, 869 &prev_dnamelen, &prev_type, &prev_dclass, &rrset, 870 section, region)) 871 return LDNS_RCODE_SERVFAIL; 872 if(!rrset) { 873 /* it is a new RR set. hash&flags already calculated.*/ 874 (*num_rrsets)++; 875 rrset = new_rrset(msg, dname, dnamelen, type, dclass, 876 hash, rrset_flags, section, region); 877 if(!rrset) 878 return LDNS_RCODE_SERVFAIL; 879 } 880 else if(0) { 881 fprintf(stderr, "is part of existing: "); 882 dname_print(stderr, pkt, rrset->dname); 883 fprintf(stderr, " type %s(%d)\n", 884 ldns_rr_descript(rrset->type)? 885 ldns_rr_descript(rrset->type)->_name: "??", 886 (int)rrset->type); 887 } 888 /* add to rrset. */ 889 if((r=add_rr_to_rrset(rrset, pkt, msg, region, section, 890 type)) != 0) 891 return r; 892 } 893 return 0; 894 } 895 896 int 897 parse_packet(ldns_buffer* pkt, struct msg_parse* msg, struct regional* region) 898 { 899 int ret; 900 if(ldns_buffer_remaining(pkt) < LDNS_HEADER_SIZE) 901 return LDNS_RCODE_FORMERR; 902 /* read the header */ 903 ldns_buffer_read(pkt, &msg->id, sizeof(uint16_t)); 904 msg->flags = ldns_buffer_read_u16(pkt); 905 msg->qdcount = ldns_buffer_read_u16(pkt); 906 msg->ancount = ldns_buffer_read_u16(pkt); 907 msg->nscount = ldns_buffer_read_u16(pkt); 908 msg->arcount = ldns_buffer_read_u16(pkt); 909 if(msg->qdcount > 1) 910 return LDNS_RCODE_FORMERR; 911 if((ret = parse_query_section(pkt, msg)) != 0) 912 return ret; 913 if((ret = parse_section(pkt, msg, region, LDNS_SECTION_ANSWER, 914 msg->ancount, &msg->an_rrsets)) != 0) 915 return ret; 916 if((ret = parse_section(pkt, msg, region, LDNS_SECTION_AUTHORITY, 917 msg->nscount, &msg->ns_rrsets)) != 0) 918 return ret; 919 if(ldns_buffer_remaining(pkt) == 0 && msg->arcount == 1) { 920 /* BIND accepts leniently that an EDNS record is missing. 921 * so, we do too. */ 922 } else if((ret = parse_section(pkt, msg, region, 923 LDNS_SECTION_ADDITIONAL, msg->arcount, &msg->ar_rrsets)) != 0) 924 return ret; 925 /* if(ldns_buffer_remaining(pkt) > 0) { */ 926 /* there is spurious data at end of packet. ignore */ 927 /* } */ 928 msg->rrset_count = msg->an_rrsets + msg->ns_rrsets + msg->ar_rrsets; 929 return 0; 930 } 931 932 int 933 parse_extract_edns(struct msg_parse* msg, struct edns_data* edns) 934 { 935 struct rrset_parse* rrset = msg->rrset_first; 936 struct rrset_parse* prev = 0; 937 struct rrset_parse* found = 0; 938 struct rrset_parse* found_prev = 0; 939 /* since the class encodes the UDP size, we cannot use hash table to 940 * find the EDNS OPT record. Scan the packet. */ 941 while(rrset) { 942 if(rrset->type == LDNS_RR_TYPE_OPT) { 943 /* only one OPT RR allowed. */ 944 if(found) return LDNS_RCODE_FORMERR; 945 /* found it! */ 946 found_prev = prev; 947 found = rrset; 948 } 949 prev = rrset; 950 rrset = rrset->rrset_all_next; 951 } 952 if(!found) { 953 memset(edns, 0, sizeof(*edns)); 954 edns->udp_size = 512; 955 return 0; 956 } 957 /* check the found RRset */ 958 /* most lenient check possible. ignore dname, use last opt */ 959 if(found->section != LDNS_SECTION_ADDITIONAL) 960 return LDNS_RCODE_FORMERR; 961 if(found->rr_count == 0) 962 return LDNS_RCODE_FORMERR; 963 if(0) { /* strict checking of dname and RRcount */ 964 if(found->dname_len != 1 || !found->dname 965 || found->dname[0] != 0) return LDNS_RCODE_FORMERR; 966 if(found->rr_count != 1) return LDNS_RCODE_FORMERR; 967 } 968 log_assert(found->rr_first && found->rr_last); 969 970 /* remove from packet */ 971 if(found_prev) found_prev->rrset_all_next = found->rrset_all_next; 972 else msg->rrset_first = found->rrset_all_next; 973 if(found == msg->rrset_last) 974 msg->rrset_last = found_prev; 975 msg->arcount --; 976 msg->ar_rrsets --; 977 msg->rrset_count --; 978 979 /* take the data ! */ 980 edns->edns_present = 1; 981 edns->ext_rcode = found->rr_last->ttl_data[0]; 982 edns->edns_version = found->rr_last->ttl_data[1]; 983 edns->bits = ldns_read_uint16(&found->rr_last->ttl_data[2]); 984 edns->udp_size = ntohs(found->rrset_class); 985 /* ignore rdata and rrsigs */ 986 return 0; 987 } 988 989 int 990 parse_edns_from_pkt(ldns_buffer* pkt, struct edns_data* edns) 991 { 992 log_assert(LDNS_QDCOUNT(ldns_buffer_begin(pkt)) == 1); 993 log_assert(LDNS_ANCOUNT(ldns_buffer_begin(pkt)) == 0); 994 log_assert(LDNS_NSCOUNT(ldns_buffer_begin(pkt)) == 0); 995 /* check edns section is present */ 996 if(LDNS_ARCOUNT(ldns_buffer_begin(pkt)) > 1) { 997 return LDNS_RCODE_FORMERR; 998 } 999 if(LDNS_ARCOUNT(ldns_buffer_begin(pkt)) == 0) { 1000 memset(edns, 0, sizeof(*edns)); 1001 edns->udp_size = 512; 1002 return 0; 1003 } 1004 /* domain name must be the root of length 1. */ 1005 if(pkt_dname_len(pkt) != 1) 1006 return LDNS_RCODE_FORMERR; 1007 if(ldns_buffer_remaining(pkt) < 10) /* type, class, ttl, rdatalen */ 1008 return LDNS_RCODE_FORMERR; 1009 if(ldns_buffer_read_u16(pkt) != LDNS_RR_TYPE_OPT) 1010 return LDNS_RCODE_FORMERR; 1011 edns->edns_present = 1; 1012 edns->udp_size = ldns_buffer_read_u16(pkt); /* class is udp size */ 1013 edns->ext_rcode = ldns_buffer_read_u8(pkt); /* ttl used for bits */ 1014 edns->edns_version = ldns_buffer_read_u8(pkt); 1015 edns->bits = ldns_buffer_read_u16(pkt); 1016 /* ignore rdata and rrsigs */ 1017 return 0; 1018 } 1019