1 /* 2 * testpkts. Data file parse for test packets, and query matching. 3 * 4 * Data storage for specially crafted replies for testing purposes. 5 * 6 * (c) NLnet Labs, 2005, 2006, 2007, 2008 7 * See the file LICENSE for the license 8 */ 9 10 /** 11 * \file 12 * This is a debugging aid. It is not efficient, especially 13 * with a long config file, but it can give any reply to any query. 14 * This can help the developer pre-script replies for queries. 15 * 16 * You can specify a packet RR by RR with header flags to return. 17 * 18 * Missing features: 19 * - matching content different from reply content. 20 * - find way to adjust mangled packets? 21 */ 22 23 #include "config.h" 24 #include <errno.h> 25 #include <stdarg.h> 26 #include <ctype.h> 27 #include "testcode/testpkts.h" 28 #include "util/net_help.h" 29 #include "sldns/sbuffer.h" 30 #include "sldns/rrdef.h" 31 #include "sldns/pkthdr.h" 32 #include "sldns/str2wire.h" 33 #include "sldns/wire2str.h" 34 35 /** max size of a packet */ 36 #define MAX_PACKETLEN 65536 37 /** max line length */ 38 #define MAX_LINE 10240 39 /** string to show in warnings and errors */ 40 static const char* prog_name = "testpkts"; 41 42 #ifndef UTIL_LOG_H 43 /** verbosity definition for compat */ 44 enum verbosity_value { NO_VERBOSE=0 }; 45 #endif 46 /** logging routine, provided by caller */ 47 void verbose(enum verbosity_value lvl, const char* msg, ...) ATTR_FORMAT(printf, 2, 3); 48 static void error(const char* msg, ...) ATTR_NORETURN; 49 50 /** print error and exit */ 51 static void error(const char* msg, ...) 52 { 53 va_list args; 54 va_start(args, msg); 55 fprintf(stderr, "%s error: ", prog_name); 56 vfprintf(stderr, msg, args); 57 fprintf(stderr, "\n"); 58 fflush(stderr); 59 va_end(args); 60 exit(EXIT_FAILURE); 61 } 62 63 /** return if string is empty or comment */ 64 static int isendline(char c) 65 { 66 if(c == ';' || c == '#' 67 || c == '\n' || c == 0) 68 return 1; 69 return 0; 70 } 71 72 /** true if the string starts with the keyword given. Moves the str ahead. 73 * @param str: before keyword, afterwards after keyword and spaces. 74 * @param keyword: the keyword to match 75 * @return: true if keyword present. False otherwise, and str unchanged. 76 */ 77 static int str_keyword(char** str, const char* keyword) 78 { 79 size_t len = strlen(keyword); 80 assert(str && keyword); 81 if(strncmp(*str, keyword, len) != 0) 82 return 0; 83 *str += len; 84 while(isspace((unsigned char)**str)) 85 (*str)++; 86 return 1; 87 } 88 89 /** Add reply packet to entry */ 90 static struct reply_packet* 91 entry_add_reply(struct entry* entry) 92 { 93 struct reply_packet* pkt = (struct reply_packet*)malloc( 94 sizeof(struct reply_packet)); 95 struct reply_packet ** p = &entry->reply_list; 96 if(!pkt) error("out of memory"); 97 pkt->next = NULL; 98 pkt->packet_sleep = 0; 99 pkt->reply_pkt = NULL; 100 pkt->reply_from_hex = NULL; 101 pkt->raw_ednsdata = NULL; 102 /* link at end */ 103 while(*p) 104 p = &((*p)->next); 105 *p = pkt; 106 return pkt; 107 } 108 109 /** parse MATCH line */ 110 static void matchline(char* line, struct entry* e) 111 { 112 char* parse = line; 113 while(*parse) { 114 if(isendline(*parse)) 115 return; 116 if(str_keyword(&parse, "opcode")) { 117 e->match_opcode = 1; 118 } else if(str_keyword(&parse, "qtype")) { 119 e->match_qtype = 1; 120 } else if(str_keyword(&parse, "qname")) { 121 e->match_qname = 1; 122 } else if(str_keyword(&parse, "rcode")) { 123 e->match_rcode = 1; 124 } else if(str_keyword(&parse, "question")) { 125 e->match_question = 1; 126 } else if(str_keyword(&parse, "answer")) { 127 e->match_answer = 1; 128 } else if(str_keyword(&parse, "subdomain")) { 129 e->match_subdomain = 1; 130 } else if(str_keyword(&parse, "all_noedns")) { 131 e->match_all_noedns = 1; 132 } else if(str_keyword(&parse, "all")) { 133 e->match_all = 1; 134 } else if(str_keyword(&parse, "ttl")) { 135 e->match_ttl = 1; 136 } else if(str_keyword(&parse, "DO")) { 137 e->match_do = 1; 138 } else if(str_keyword(&parse, "CO")) { 139 e->match_co = 1; 140 } else if(str_keyword(&parse, "noedns")) { 141 e->match_noedns = 1; 142 } else if(str_keyword(&parse, "ednsdata")) { 143 e->match_ednsdata_raw = 1; 144 } else if(str_keyword(&parse, "client_cookie")) { 145 e->match_client_cookie = 1; 146 } else if(str_keyword(&parse, "server_cookie")) { 147 e->match_server_cookie = 1; 148 } else if(str_keyword(&parse, "UDP")) { 149 e->match_transport = transport_udp; 150 } else if(str_keyword(&parse, "TCP")) { 151 e->match_transport = transport_tcp; 152 } else if(str_keyword(&parse, "serial")) { 153 e->match_serial = 1; 154 if(*parse != '=' && *parse != ':') 155 error("expected = or : in MATCH: %s", line); 156 parse++; 157 e->ixfr_soa_serial = (uint32_t)strtol(parse, (char**)&parse, 10); 158 while(isspace((unsigned char)*parse)) 159 parse++; 160 } else if(str_keyword(&parse, "ede")) { 161 e->match_ede = 1; 162 if(*parse != '=' && *parse != ':') 163 error("expected = or : in MATCH: %s", line); 164 parse++; 165 while(isspace((unsigned char)*parse)) 166 parse++; 167 if(str_keyword(&parse, "any")) { 168 e->match_ede_any = 1; 169 } else { 170 e->ede_info_code = (uint16_t)strtol(parse, 171 (char**)&parse, 10); 172 } 173 while(isspace((unsigned char)*parse)) 174 parse++; 175 } else { 176 error("could not parse MATCH: '%s'", parse); 177 } 178 } 179 } 180 181 /** parse REPLY line */ 182 static void replyline(char* line, uint8_t* reply, size_t reply_len, 183 int* do_flag, int* co_flag) 184 { 185 char* parse = line; 186 if(reply_len < LDNS_HEADER_SIZE) error("packet too short for header"); 187 while(*parse) { 188 if(isendline(*parse)) 189 return; 190 /* opcodes */ 191 if(str_keyword(&parse, "QUERY")) { 192 LDNS_OPCODE_SET(reply, LDNS_PACKET_QUERY); 193 } else if(str_keyword(&parse, "IQUERY")) { 194 LDNS_OPCODE_SET(reply, LDNS_PACKET_IQUERY); 195 } else if(str_keyword(&parse, "STATUS")) { 196 LDNS_OPCODE_SET(reply, LDNS_PACKET_STATUS); 197 } else if(str_keyword(&parse, "NOTIFY")) { 198 LDNS_OPCODE_SET(reply, LDNS_PACKET_NOTIFY); 199 } else if(str_keyword(&parse, "UPDATE")) { 200 LDNS_OPCODE_SET(reply, LDNS_PACKET_UPDATE); 201 /* rcodes */ 202 } else if(str_keyword(&parse, "NOERROR")) { 203 LDNS_RCODE_SET(reply, LDNS_RCODE_NOERROR); 204 } else if(str_keyword(&parse, "FORMERR")) { 205 LDNS_RCODE_SET(reply, LDNS_RCODE_FORMERR); 206 } else if(str_keyword(&parse, "SERVFAIL")) { 207 LDNS_RCODE_SET(reply, LDNS_RCODE_SERVFAIL); 208 } else if(str_keyword(&parse, "NXDOMAIN")) { 209 LDNS_RCODE_SET(reply, LDNS_RCODE_NXDOMAIN); 210 } else if(str_keyword(&parse, "NOTIMPL")) { 211 LDNS_RCODE_SET(reply, LDNS_RCODE_NOTIMPL); 212 } else if(str_keyword(&parse, "REFUSED")) { 213 LDNS_RCODE_SET(reply, LDNS_RCODE_REFUSED); 214 } else if(str_keyword(&parse, "YXDOMAIN")) { 215 LDNS_RCODE_SET(reply, LDNS_RCODE_YXDOMAIN); 216 } else if(str_keyword(&parse, "YXRRSET")) { 217 LDNS_RCODE_SET(reply, LDNS_RCODE_YXRRSET); 218 } else if(str_keyword(&parse, "NXRRSET")) { 219 LDNS_RCODE_SET(reply, LDNS_RCODE_NXRRSET); 220 } else if(str_keyword(&parse, "NOTAUTH")) { 221 LDNS_RCODE_SET(reply, LDNS_RCODE_NOTAUTH); 222 } else if(str_keyword(&parse, "NOTZONE")) { 223 LDNS_RCODE_SET(reply, LDNS_RCODE_NOTZONE); 224 /* flags */ 225 } else if(str_keyword(&parse, "QR")) { 226 LDNS_QR_SET(reply); 227 } else if(str_keyword(&parse, "AA")) { 228 LDNS_AA_SET(reply); 229 } else if(str_keyword(&parse, "TC")) { 230 LDNS_TC_SET(reply); 231 } else if(str_keyword(&parse, "RD")) { 232 LDNS_RD_SET(reply); 233 } else if(str_keyword(&parse, "CD")) { 234 LDNS_CD_SET(reply); 235 } else if(str_keyword(&parse, "RA")) { 236 LDNS_RA_SET(reply); 237 } else if(str_keyword(&parse, "AD")) { 238 LDNS_AD_SET(reply); 239 } else if(str_keyword(&parse, "DO")) { 240 *do_flag = 1; 241 } else if(str_keyword(&parse, "CO")) { 242 *co_flag = 1; 243 } else { 244 error("could not parse REPLY: '%s'", parse); 245 } 246 } 247 } 248 249 /** parse ADJUST line */ 250 static void adjustline(char* line, struct entry* e, 251 struct reply_packet* pkt) 252 { 253 char* parse = line; 254 while(*parse) { 255 if(isendline(*parse)) 256 return; 257 if(str_keyword(&parse, "copy_id")) { 258 e->copy_id = 1; 259 } else if(str_keyword(&parse, "copy_query")) { 260 e->copy_query = 1; 261 } else if(str_keyword(&parse, "copy_ednsdata_assume_clientsubnet")) { 262 e->copy_ednsdata_assume_clientsubnet = 1; 263 } else if(str_keyword(&parse, "increment_ecs_scope")) { 264 e->increment_ecs_scope = 1; 265 } else if(str_keyword(&parse, "sleep=")) { 266 e->sleeptime = (unsigned int) strtol(parse, (char**)&parse, 10); 267 while(isspace((unsigned char)*parse)) 268 parse++; 269 } else if(str_keyword(&parse, "packet_sleep=")) { 270 pkt->packet_sleep = (unsigned int) strtol(parse, (char**)&parse, 10); 271 while(isspace((unsigned char)*parse)) 272 parse++; 273 } else { 274 error("could not parse ADJUST: '%s'", parse); 275 } 276 } 277 } 278 279 /** create new entry */ 280 static struct entry* new_entry(void) 281 { 282 struct entry* e = (struct entry*)malloc(sizeof(struct entry)); 283 if(!e) error("out of memory"); 284 memset(e, 0, sizeof(*e)); 285 e->match_opcode = 0; 286 e->match_qtype = 0; 287 e->match_qname = 0; 288 e->match_rcode = 0; 289 e->match_question = 0; 290 e->match_answer = 0; 291 e->match_subdomain = 0; 292 e->match_all = 0; 293 e->match_all_noedns = 0; 294 e->match_ttl = 0; 295 e->match_do = 0; 296 e->match_co = 0; 297 e->match_noedns = 0; 298 e->match_serial = 0; 299 e->ixfr_soa_serial = 0; 300 e->match_ede = 0; 301 e->match_ede_any = 0; 302 e->ede_info_code = -1; 303 e->match_transport = transport_any; 304 e->reply_list = NULL; 305 e->copy_id = 0; 306 e->copy_query = 0; 307 e->copy_ednsdata_assume_clientsubnet = 0; 308 e->increment_ecs_scope = 0; 309 e->sleeptime = 0; 310 e->next = NULL; 311 return e; 312 } 313 314 /** 315 * Converts a hex string to binary data 316 * @param hexstr: string of hex. 317 * @param len: is the length of the string 318 * @param buf: is the buffer to store the result in 319 * @param offset: is the starting position in the result buffer 320 * @param buf_len: is the length of buf. 321 * @return This function returns the length of the result 322 */ 323 static size_t 324 hexstr2bin(char *hexstr, int len, uint8_t *buf, size_t offset, size_t buf_len) 325 { 326 char c; 327 int i; 328 uint8_t int8 = 0; 329 int sec = 0; 330 size_t bufpos = 0; 331 332 if (len % 2 != 0) { 333 return 0; 334 } 335 336 for (i=0; i<len; i++) { 337 c = hexstr[i]; 338 339 /* case insensitive, skip spaces */ 340 if (c != ' ') { 341 if (c >= '0' && c <= '9') { 342 int8 += c & 0x0f; 343 } else if (c >= 'a' && c <= 'z') { 344 int8 += (c & 0x0f) + 9; 345 } else if (c >= 'A' && c <= 'Z') { 346 int8 += (c & 0x0f) + 9; 347 } else { 348 return 0; 349 } 350 351 if (sec == 0) { 352 int8 = int8 << 4; 353 sec = 1; 354 } else { 355 if (bufpos + offset + 1 <= buf_len) { 356 buf[bufpos+offset] = int8; 357 int8 = 0; 358 sec = 0; 359 bufpos++; 360 } else { 361 fprintf(stderr, "Buffer too small in hexstr2bin"); 362 } 363 } 364 } 365 } 366 return bufpos; 367 } 368 369 /** convert hex buffer to binary buffer */ 370 static sldns_buffer * 371 hex_buffer2wire(sldns_buffer *data_buffer) 372 { 373 sldns_buffer *wire_buffer = NULL; 374 int c; 375 376 /* stat hack 377 * 0 = normal 378 * 1 = comment (skip to end of line) 379 * 2 = unprintable character found, read binary data directly 380 */ 381 size_t data_buf_pos = 0; 382 int state = 0; 383 uint8_t *hexbuf; 384 int hexbufpos = 0; 385 size_t wirelen; 386 uint8_t *data_wire = (uint8_t *) sldns_buffer_begin(data_buffer); 387 uint8_t *wire = (uint8_t*)malloc(MAX_PACKETLEN); 388 if(!wire) error("out of memory"); 389 390 hexbuf = (uint8_t*)malloc(MAX_PACKETLEN); 391 if(!hexbuf) error("out of memory"); 392 for (data_buf_pos = 0; data_buf_pos < sldns_buffer_position(data_buffer); data_buf_pos++) { 393 c = (int) data_wire[data_buf_pos]; 394 395 if (state < 2 && !isascii((unsigned char)c)) { 396 /*verbose("non ascii character found in file: (%d) switching to raw mode\n", c);*/ 397 state = 2; 398 } 399 switch (state) { 400 case 0: 401 if ( (c >= '0' && c <= '9') || 402 (c >= 'a' && c <= 'f') || 403 (c >= 'A' && c <= 'F') ) 404 { 405 if (hexbufpos >= MAX_PACKETLEN) { 406 error("buffer overflow"); 407 free(hexbuf); 408 return 0; 409 410 } 411 hexbuf[hexbufpos] = (uint8_t) c; 412 hexbufpos++; 413 } else if (c == ';') { 414 state = 1; 415 } else if (c == ' ' || c == '\t' || c == '\n') { 416 /* skip whitespace */ 417 } 418 break; 419 case 1: 420 if (c == '\n' || c == EOF) { 421 state = 0; 422 } 423 break; 424 case 2: 425 if (hexbufpos >= MAX_PACKETLEN) { 426 error("buffer overflow"); 427 free(hexbuf); 428 return 0; 429 } 430 hexbuf[hexbufpos] = (uint8_t) c; 431 hexbufpos++; 432 break; 433 } 434 } 435 436 if (hexbufpos >= MAX_PACKETLEN) { 437 /*verbose("packet size reached\n");*/ 438 } 439 440 /* lenient mode: length must be multiple of 2 */ 441 if (hexbufpos % 2 != 0) { 442 if (hexbufpos >= MAX_PACKETLEN) { 443 error("buffer overflow"); 444 free(hexbuf); 445 return 0; 446 } 447 hexbuf[hexbufpos] = (uint8_t) '0'; 448 hexbufpos++; 449 } 450 451 if (state < 2) { 452 wirelen = hexstr2bin((char *) hexbuf, hexbufpos, wire, 0, MAX_PACKETLEN); 453 wire_buffer = sldns_buffer_new(wirelen); 454 sldns_buffer_new_frm_data(wire_buffer, wire, wirelen); 455 } else { 456 error("Incomplete hex data, not at byte boundary\n"); 457 } 458 free(wire); 459 free(hexbuf); 460 return wire_buffer; 461 } 462 463 /** parse ORIGIN */ 464 static void 465 get_origin(const char* name, struct sldns_file_parse_state* pstate, char* parse) 466 { 467 /* snip off rest of the text so as to make the parse work in ldns */ 468 char* end; 469 char store; 470 int status; 471 472 end=parse; 473 while(!isspace((unsigned char)*end) && !isendline(*end)) 474 end++; 475 store = *end; 476 *end = 0; 477 verbose(3, "parsing '%s'\n", parse); 478 pstate->origin_len = sizeof(pstate->origin); 479 status = sldns_str2wire_dname_buf(parse, pstate->origin, 480 &pstate->origin_len); 481 *end = store; 482 if(status != 0) 483 error("%s line %d:\n\t%s: %s", name, pstate->lineno, 484 sldns_get_errorstr_parse(status), parse); 485 } 486 487 /** add RR to packet */ 488 static void add_rr(char* rrstr, uint8_t* pktbuf, size_t pktsize, 489 size_t* pktlen, struct sldns_file_parse_state* pstate, 490 sldns_pkt_section add_section, const char* fname) 491 { 492 /* it must be a RR, parse and add to packet. */ 493 size_t rr_len = pktsize - *pktlen; 494 size_t dname_len = 0; 495 int status; 496 uint8_t* origin = pstate->origin_len?pstate->origin:0; 497 uint8_t* prev = pstate->prev_rr_len?pstate->prev_rr:0; 498 if(*pktlen > pktsize || *pktlen < LDNS_HEADER_SIZE) 499 error("packet overflow"); 500 501 /* parse RR */ 502 if(add_section == LDNS_SECTION_QUESTION) 503 status = sldns_str2wire_rr_question_buf(rrstr, pktbuf+*pktlen, 504 &rr_len, &dname_len, origin, pstate->origin_len, 505 prev, pstate->prev_rr_len); 506 else status = sldns_str2wire_rr_buf(rrstr, pktbuf+*pktlen, &rr_len, 507 &dname_len, pstate->default_ttl, origin, 508 pstate->origin_len, prev, pstate->prev_rr_len); 509 if(status != 0) 510 error("%s line %d:%d %s\n\t%s", fname, pstate->lineno, 511 LDNS_WIREPARSE_OFFSET(status), 512 sldns_get_errorstr_parse(status), rrstr); 513 *pktlen += rr_len; 514 515 /* increase RR count */ 516 if(add_section == LDNS_SECTION_QUESTION) 517 sldns_write_uint16(pktbuf+4, LDNS_QDCOUNT(pktbuf)+1); 518 else if(add_section == LDNS_SECTION_ANSWER) 519 sldns_write_uint16(pktbuf+6, LDNS_ANCOUNT(pktbuf)+1); 520 else if(add_section == LDNS_SECTION_AUTHORITY) 521 sldns_write_uint16(pktbuf+8, LDNS_NSCOUNT(pktbuf)+1); 522 else if(add_section == LDNS_SECTION_ADDITIONAL) 523 sldns_write_uint16(pktbuf+10, LDNS_ARCOUNT(pktbuf)+1); 524 else error("internal error bad section %d", (int)add_section); 525 } 526 527 /* add EDNS 4096 opt record */ 528 static void 529 add_edns(uint8_t* pktbuf, size_t pktsize, int do_flag, int co_flag, 530 uint8_t *ednsdata, uint16_t ednslen, size_t* pktlen) 531 { 532 uint8_t edns[] = {0x00, /* root label */ 533 0x00, LDNS_RR_TYPE_OPT, /* type */ 534 0x04, 0xD0, /* class is UDPSIZE 1232 */ 535 0x00, /* TTL[0] is ext rcode */ 536 0x00, /* TTL[1] is edns version */ 537 (uint8_t)(do_flag?0x80:0x00) 538 | (uint8_t)(co_flag?0x40:0x00) 539 , 0x00, /* TTL[2-3] is edns flags, DO */ 540 (uint8_t)((ednslen >> 8) & 0xff), 541 (uint8_t)(ednslen & 0xff), /* rdatalength */ 542 }; 543 if(*pktlen < LDNS_HEADER_SIZE) 544 return; 545 if(*pktlen + sizeof(edns) + ednslen > pktsize) 546 error("not enough space for EDNS OPT record"); 547 memmove(pktbuf+*pktlen, edns, sizeof(edns)); 548 if(ednsdata && ednslen) 549 memmove(pktbuf+*pktlen+sizeof(edns), ednsdata, ednslen); 550 sldns_write_uint16(pktbuf+10, LDNS_ARCOUNT(pktbuf)+1); 551 *pktlen += (sizeof(edns) + ednslen); 552 } 553 554 /* Reads one entry from file. Returns entry or NULL on error. */ 555 struct entry* 556 read_entry(FILE* in, const char* name, struct sldns_file_parse_state* pstate, 557 int skip_whitespace) 558 { 559 struct entry* current = NULL; 560 char line[MAX_LINE]; 561 char* parse; 562 sldns_pkt_section add_section = LDNS_SECTION_QUESTION; 563 struct reply_packet *cur_reply = NULL; 564 int reading_hex = 0; 565 int reading_hex_ednsdata = 0; 566 sldns_buffer* hex_data_buffer = NULL; 567 sldns_buffer* hex_ednsdata_buffer = NULL; 568 uint8_t pktbuf[MAX_PACKETLEN]; 569 size_t pktlen = LDNS_HEADER_SIZE; 570 int do_flag = 0; /* DO flag in EDNS */ 571 int co_flag = 0; /* CO flag in EDNS */ 572 memset(pktbuf, 0, pktlen); /* ID = 0, FLAGS="", and rr counts 0 */ 573 574 while(fgets(line, (int)sizeof(line), in) != NULL) { 575 line[MAX_LINE-1] = 0; 576 parse = line; 577 pstate->lineno++; 578 579 while(isspace((unsigned char)*parse)) 580 parse++; 581 /* test for keywords */ 582 if(isendline(*parse)) 583 continue; /* skip comment and empty lines */ 584 if(str_keyword(&parse, "ENTRY_BEGIN")) { 585 if(current) { 586 error("%s line %d: previous entry does not ENTRY_END", 587 name, pstate->lineno); 588 } 589 current = new_entry(); 590 current->lineno = pstate->lineno; 591 cur_reply = entry_add_reply(current); 592 continue; 593 } else if(str_keyword(&parse, "$ORIGIN")) { 594 get_origin(name, pstate, parse); 595 continue; 596 } else if(str_keyword(&parse, "$TTL")) { 597 pstate->default_ttl = (uint32_t)atoi(parse); 598 continue; 599 } 600 601 /* working inside an entry */ 602 if(!current) { 603 error("%s line %d: expected ENTRY_BEGIN but got %s", 604 name, pstate->lineno, line); 605 } 606 if(str_keyword(&parse, "MATCH")) { 607 matchline(parse, current); 608 } else if(str_keyword(&parse, "REPLY")) { 609 replyline(parse, pktbuf, pktlen, &do_flag, &co_flag); 610 } else if(str_keyword(&parse, "ADJUST")) { 611 adjustline(parse, current, cur_reply); 612 } else if(str_keyword(&parse, "EXTRA_PACKET")) { 613 /* copy current packet into buffer */ 614 cur_reply->reply_pkt = memdup(pktbuf, pktlen); 615 cur_reply->reply_len = pktlen; 616 if(!cur_reply->reply_pkt) 617 error("out of memory"); 618 cur_reply = entry_add_reply(current); 619 /* clear for next packet */ 620 pktlen = LDNS_HEADER_SIZE; 621 memset(pktbuf, 0, pktlen); /* ID = 0, FLAGS="", and rr counts 0 */ 622 } else if(str_keyword(&parse, "SECTION")) { 623 if(str_keyword(&parse, "QUESTION")) 624 add_section = LDNS_SECTION_QUESTION; 625 else if(str_keyword(&parse, "ANSWER")) 626 add_section = LDNS_SECTION_ANSWER; 627 else if(str_keyword(&parse, "AUTHORITY")) 628 add_section = LDNS_SECTION_AUTHORITY; 629 else if(str_keyword(&parse, "ADDITIONAL")) 630 add_section = LDNS_SECTION_ADDITIONAL; 631 else error("%s line %d: bad section %s", name, pstate->lineno, parse); 632 } else if(str_keyword(&parse, "HEX_ANSWER_BEGIN")) { 633 hex_data_buffer = sldns_buffer_new(MAX_PACKETLEN); 634 reading_hex = 1; 635 } else if(str_keyword(&parse, "HEX_ANSWER_END")) { 636 if(!reading_hex) { 637 error("%s line %d: HEX_ANSWER_END read but no HEX_ANSWER_BEGIN keyword seen", name, pstate->lineno); 638 } 639 reading_hex = 0; 640 cur_reply->reply_from_hex = hex_buffer2wire(hex_data_buffer); 641 sldns_buffer_free(hex_data_buffer); 642 hex_data_buffer = NULL; 643 } else if(reading_hex) { 644 sldns_buffer_printf(hex_data_buffer, "%s", line); 645 } else if(str_keyword(&parse, "HEX_EDNSDATA_BEGIN")) { 646 hex_ednsdata_buffer = sldns_buffer_new(MAX_PACKETLEN); 647 reading_hex_ednsdata = 1; 648 } else if(str_keyword(&parse, "HEX_EDNSDATA_END")) { 649 if (!reading_hex_ednsdata) { 650 error("%s line %d: HEX_EDNSDATA_END read but no" 651 "HEX_EDNSDATA_BEGIN keyword seen", name, pstate->lineno); 652 } 653 reading_hex_ednsdata = 0; 654 cur_reply->raw_ednsdata = hex_buffer2wire(hex_ednsdata_buffer); 655 sldns_buffer_free(hex_ednsdata_buffer); 656 hex_ednsdata_buffer = NULL; 657 } else if(reading_hex_ednsdata) { 658 sldns_buffer_printf(hex_ednsdata_buffer, "%s", line); 659 } else if(str_keyword(&parse, "ENTRY_END")) { 660 if(hex_data_buffer) 661 sldns_buffer_free(hex_data_buffer); 662 if(hex_ednsdata_buffer) 663 sldns_buffer_free(hex_ednsdata_buffer); 664 if(pktlen != 0) { 665 if(do_flag || co_flag 666 || cur_reply->raw_ednsdata) { 667 if(cur_reply->raw_ednsdata && 668 sldns_buffer_limit(cur_reply->raw_ednsdata)) 669 add_edns(pktbuf, sizeof(pktbuf), do_flag, co_flag, 670 sldns_buffer_begin(cur_reply->raw_ednsdata), 671 (uint16_t)sldns_buffer_limit(cur_reply->raw_ednsdata), 672 &pktlen); 673 else 674 add_edns(pktbuf, sizeof(pktbuf), do_flag, co_flag, 675 NULL, 0, &pktlen); 676 } 677 cur_reply->reply_pkt = memdup(pktbuf, pktlen); 678 cur_reply->reply_len = pktlen; 679 if(!cur_reply->reply_pkt) 680 error("out of memory"); 681 } 682 return current; 683 } else { 684 add_rr(skip_whitespace?parse:line, pktbuf, 685 sizeof(pktbuf), &pktlen, pstate, add_section, 686 name); 687 } 688 689 } 690 if(reading_hex) { 691 error("%s: End of file reached while still reading hex, " 692 "missing HEX_ANSWER_END\n", name); 693 } 694 if(reading_hex_ednsdata) { 695 error("%s: End of file reached while still reading edns data, " 696 "missing HEX_EDNSDATA_END\n", name); 697 } 698 if(current) { 699 error("%s: End of file reached while reading entry. " 700 "missing ENTRY_END\n", name); 701 } 702 return 0; 703 } 704 705 /* reads the canned reply file and returns a list of structs */ 706 struct entry* 707 read_datafile(const char* name, int skip_whitespace) 708 { 709 struct entry* list = NULL; 710 struct entry* last = NULL; 711 struct entry* current = NULL; 712 FILE *in; 713 struct sldns_file_parse_state pstate; 714 int entry_num = 0; 715 memset(&pstate, 0, sizeof(pstate)); 716 717 if((in=fopen(name, "r")) == NULL) { 718 error("could not open file %s: %s", name, strerror(errno)); 719 } 720 721 while((current = read_entry(in, name, &pstate, skip_whitespace))) 722 { 723 if(last) 724 last->next = current; 725 else list = current; 726 last = current; 727 entry_num ++; 728 } 729 verbose(1, "%s: Read %d entries\n", prog_name, entry_num); 730 731 fclose(in); 732 return list; 733 } 734 735 /** get qtype from packet */ 736 static sldns_rr_type get_qtype(uint8_t* pkt, size_t pktlen) 737 { 738 uint8_t* d; 739 size_t dl, sl=0; 740 char* snull = NULL; 741 int comprloop = 0; 742 if(pktlen < LDNS_HEADER_SIZE) 743 return 0; 744 if(LDNS_QDCOUNT(pkt) == 0) 745 return 0; 746 /* skip over dname with dname-scan routine */ 747 d = pkt+LDNS_HEADER_SIZE; 748 dl = pktlen-LDNS_HEADER_SIZE; 749 (void)sldns_wire2str_dname_scan(&d, &dl, &snull, &sl, pkt, pktlen, &comprloop); 750 if(dl < 2) 751 return 0; 752 return sldns_read_uint16(d); 753 } 754 755 /** get qtype from packet */ 756 static size_t get_qname_len(uint8_t* pkt, size_t pktlen) 757 { 758 uint8_t* d; 759 size_t dl, sl=0; 760 char* snull = NULL; 761 int comprloop = 0; 762 if(pktlen < LDNS_HEADER_SIZE) 763 return 0; 764 if(LDNS_QDCOUNT(pkt) == 0) 765 return 0; 766 /* skip over dname with dname-scan routine */ 767 d = pkt+LDNS_HEADER_SIZE; 768 dl = pktlen-LDNS_HEADER_SIZE; 769 (void)sldns_wire2str_dname_scan(&d, &dl, &snull, &sl, pkt, pktlen, &comprloop); 770 return pktlen-dl-LDNS_HEADER_SIZE; 771 } 772 773 /** returns owner from packet */ 774 static uint8_t* get_qname(uint8_t* pkt, size_t pktlen) 775 { 776 if(pktlen < LDNS_HEADER_SIZE) 777 return NULL; 778 if(LDNS_QDCOUNT(pkt) == 0) 779 return NULL; 780 return pkt+LDNS_HEADER_SIZE; 781 } 782 783 /** returns opcode from packet */ 784 static int get_opcode(uint8_t* pkt, size_t pktlen) 785 { 786 if(pktlen < LDNS_HEADER_SIZE) 787 return 0; 788 return (int)LDNS_OPCODE_WIRE(pkt); 789 } 790 791 /** returns rcode from packet */ 792 static int get_rcode(uint8_t* pkt, size_t pktlen) 793 { 794 if(pktlen < LDNS_HEADER_SIZE) 795 return 0; 796 return (int)LDNS_RCODE_WIRE(pkt); 797 } 798 799 /** get authority section SOA serial value */ 800 static uint32_t get_serial(uint8_t* p, size_t plen) 801 { 802 uint8_t* walk = p; 803 size_t walk_len = plen, sl=0; 804 char* snull = NULL; 805 uint16_t i; 806 int comprloop = 0; 807 808 if(walk_len < LDNS_HEADER_SIZE) 809 return 0; 810 walk += LDNS_HEADER_SIZE; 811 walk_len -= LDNS_HEADER_SIZE; 812 813 /* skip other records with wire2str_scan */ 814 for(i=0; i < LDNS_QDCOUNT(p); i++) 815 (void)sldns_wire2str_rrquestion_scan(&walk, &walk_len, 816 &snull, &sl, p, plen, &comprloop); 817 for(i=0; i < LDNS_ANCOUNT(p); i++) 818 (void)sldns_wire2str_rr_scan(&walk, &walk_len, &snull, &sl, 819 p, plen, &comprloop); 820 821 /* walk through authority section */ 822 for(i=0; i < LDNS_NSCOUNT(p); i++) { 823 /* if this is SOA then get serial, skip compressed dname */ 824 uint8_t* dstart = walk; 825 size_t dlen = walk_len; 826 (void)sldns_wire2str_dname_scan(&dstart, &dlen, &snull, &sl, 827 p, plen, &comprloop); 828 if(dlen >= 2 && sldns_read_uint16(dstart) == LDNS_RR_TYPE_SOA) { 829 /* skip type, class, TTL, rdatalen */ 830 if(dlen < 10) 831 return 0; 832 if(dlen < 10 + (size_t)sldns_read_uint16(dstart+8)) 833 return 0; 834 dstart += 10; 835 dlen -= 10; 836 /* check third rdf */ 837 (void)sldns_wire2str_dname_scan(&dstart, &dlen, &snull, 838 &sl, p, plen, &comprloop); 839 (void)sldns_wire2str_dname_scan(&dstart, &dlen, &snull, 840 &sl, p, plen, &comprloop); 841 if(dlen < 4) 842 return 0; 843 verbose(3, "found serial %u in msg. ", 844 (int)sldns_read_uint32(dstart)); 845 return sldns_read_uint32(dstart); 846 } 847 /* move to next RR */ 848 (void)sldns_wire2str_rr_scan(&walk, &walk_len, &snull, &sl, 849 p, plen, &comprloop); 850 } 851 return 0; 852 } 853 854 /** get ptr to EDNS OPT record (and remaining length); after the type u16 */ 855 static int 856 pkt_find_edns_opt(uint8_t** p, size_t* plen) 857 { 858 /* walk over the packet with scan routines */ 859 uint8_t* w = *p; 860 size_t wlen = *plen, sl=0; 861 char* snull = NULL; 862 uint16_t i; 863 int comprloop = 0; 864 865 if(wlen < LDNS_HEADER_SIZE) 866 return 0; 867 w += LDNS_HEADER_SIZE; 868 wlen -= LDNS_HEADER_SIZE; 869 870 /* skip other records with wire2str_scan */ 871 for(i=0; i < LDNS_QDCOUNT(*p); i++) 872 (void)sldns_wire2str_rrquestion_scan(&w, &wlen, &snull, &sl, 873 *p, *plen, &comprloop); 874 for(i=0; i < LDNS_ANCOUNT(*p); i++) 875 (void)sldns_wire2str_rr_scan(&w, &wlen, &snull, &sl, *p, *plen, &comprloop); 876 for(i=0; i < LDNS_NSCOUNT(*p); i++) 877 (void)sldns_wire2str_rr_scan(&w, &wlen, &snull, &sl, *p, *plen, &comprloop); 878 879 /* walk through additional section */ 880 for(i=0; i < LDNS_ARCOUNT(*p); i++) { 881 /* if this is OPT then done */ 882 uint8_t* dstart = w; 883 size_t dlen = wlen; 884 (void)sldns_wire2str_dname_scan(&dstart, &dlen, &snull, &sl, 885 *p, *plen, &comprloop); 886 if(dlen >= 2 && sldns_read_uint16(dstart) == LDNS_RR_TYPE_OPT) { 887 *p = dstart+2; 888 *plen = dlen-2; 889 return 1; 890 } 891 /* move to next RR */ 892 (void)sldns_wire2str_rr_scan(&w, &wlen, &snull, &sl, *p, *plen, &comprloop); 893 } 894 return 0; 895 } 896 897 /** return true if the packet has EDNS OPT record */ 898 static int 899 get_has_edns(uint8_t* pkt, size_t len) 900 { 901 /* use arguments as temporary variables */ 902 return pkt_find_edns_opt(&pkt, &len); 903 } 904 905 /** return true if the DO flag is set */ 906 static int 907 get_do_flag(uint8_t* pkt, size_t len) 908 { 909 uint16_t edns_bits; 910 uint8_t* walk = pkt; 911 size_t walk_len = len; 912 if(!pkt_find_edns_opt(&walk, &walk_len)) { 913 return 0; 914 } 915 if(walk_len < 6) 916 return 0; /* malformed */ 917 edns_bits = sldns_read_uint16(walk+4); 918 return (int)(edns_bits&LDNS_EDNS_MASK_DO_BIT); 919 } 920 921 /** return true if the CO flag is set */ 922 static int 923 get_co_flag(uint8_t* pkt, size_t len) 924 { 925 uint16_t edns_bits; 926 uint8_t* walk = pkt; 927 size_t walk_len = len; 928 if(!pkt_find_edns_opt(&walk, &walk_len)) { 929 return 0; 930 } 931 if(walk_len < 6) 932 return 0; /* malformed */ 933 edns_bits = sldns_read_uint16(walk+4); 934 return (int)(edns_bits&LDNS_EDNS_MASK_CO_BIT); 935 } 936 937 /** Snips the specified EDNS option out of the OPT record and puts it in the 938 * provided buffer. The buffer should be able to hold any opt data ie 65535. 939 * Returns the length of the option written, 940 * or 0 if not found, else -1 on error. */ 941 static int 942 pkt_snip_edns_option(uint8_t* pkt, size_t len, sldns_edns_option code, 943 uint8_t* buf) 944 { 945 uint8_t *rdata, *opt_position = pkt; 946 uint16_t rdlen, optlen; 947 size_t remaining = len; 948 if(!pkt_find_edns_opt(&opt_position, &remaining)) return 0; 949 if(remaining < 8) return -1; /* malformed */ 950 rdlen = sldns_read_uint16(opt_position+6); 951 if(remaining < ((size_t)rdlen)+8) 952 return -1; /* malformed */ 953 rdata = opt_position + 8; 954 while(rdlen > 0) { 955 if(rdlen < 4) return -1; /* malformed */ 956 optlen = sldns_read_uint16(rdata+2); 957 if((size_t)rdlen < 4+((size_t)optlen)) 958 return -1; /* malformed */ 959 if(sldns_read_uint16(rdata) == code) { 960 /* save data to buf for caller inspection */ 961 memmove(buf, rdata+4, optlen); 962 /* snip option from packet; assumes len is correct */ 963 memmove(rdata, rdata+4+optlen, 964 (pkt+len)-(rdata+4+optlen)); 965 /* update OPT size */ 966 sldns_write_uint16(opt_position+6, 967 sldns_read_uint16(opt_position+6)-(4+optlen)); 968 return optlen; 969 } 970 rdlen -= 4 + optlen; 971 rdata += 4 + optlen; 972 } 973 return 0; 974 } 975 976 /** Snips the EDE option out of the OPT record and returns the EDNS EDE 977 * INFO-CODE if found, else -1 */ 978 static int 979 extract_ede(uint8_t* pkt, size_t len) 980 { 981 uint8_t buf[65535]; 982 int buflen = pkt_snip_edns_option(pkt, len, LDNS_EDNS_EDE, buf); 983 if(buflen < 2 /*ede without text at minimum*/) return -1; 984 return sldns_read_uint16(buf); 985 } 986 987 /** Snips the DNS Cookie option out of the OPT record and puts it in the 988 * provided cookie buffer (should be at least 24 octets). 989 * Returns the length of the cookie if found, else -1. */ 990 static int 991 extract_cookie(uint8_t* pkt, size_t len, uint8_t* cookie) 992 { 993 uint8_t buf[65535]; 994 int buflen = pkt_snip_edns_option(pkt, len, LDNS_EDNS_COOKIE, buf); 995 if(buflen != 8 /*client cookie*/ && 996 buflen != 8 + 16 /*server cookie*/) return -1; 997 memcpy(cookie, buf, buflen); 998 return buflen; 999 } 1000 1001 /** zero TTLs in packet */ 1002 static void 1003 zerottls(uint8_t* pkt, size_t pktlen) 1004 { 1005 uint8_t* walk = pkt; 1006 size_t walk_len = pktlen, sl=0; 1007 char* snull = NULL; 1008 uint16_t i; 1009 uint16_t num = LDNS_ANCOUNT(pkt)+LDNS_NSCOUNT(pkt)+LDNS_ARCOUNT(pkt); 1010 int comprloop = 0; 1011 if(walk_len < LDNS_HEADER_SIZE) 1012 return; 1013 walk += LDNS_HEADER_SIZE; 1014 walk_len -= LDNS_HEADER_SIZE; 1015 for(i=0; i < LDNS_QDCOUNT(pkt); i++) 1016 (void)sldns_wire2str_rrquestion_scan(&walk, &walk_len, 1017 &snull, &sl, pkt, pktlen, &comprloop); 1018 for(i=0; i < num; i++) { 1019 /* wipe TTL */ 1020 uint8_t* dstart = walk; 1021 size_t dlen = walk_len; 1022 (void)sldns_wire2str_dname_scan(&dstart, &dlen, &snull, &sl, 1023 pkt, pktlen, &comprloop); 1024 if(dlen < 8) 1025 return; 1026 sldns_write_uint32(dstart+4, 0); 1027 /* go to next RR */ 1028 (void)sldns_wire2str_rr_scan(&walk, &walk_len, &snull, &sl, 1029 pkt, pktlen, &comprloop); 1030 } 1031 } 1032 1033 /** get one line (\n) from a string, move next to after the \n, zero \n */ 1034 static int 1035 get_line(char** s, char** n) 1036 { 1037 /* at end of string? end */ 1038 if(*n == NULL || **n == 0) 1039 return 0; 1040 /* result starts at next string */ 1041 *s = *n; 1042 /* find \n after that */ 1043 *n = strchr(*s, '\n'); 1044 if(*n && **n != 0) { 1045 /* terminate line */ 1046 (*n)[0] = 0; 1047 (*n)++; 1048 } 1049 return 1; 1050 } 1051 1052 /** match two RR sections without ordering */ 1053 static int 1054 match_noloc_section(char** q, char** nq, char** p, char** np, uint16_t num) 1055 { 1056 /* for max number of RRs in packet */ 1057 const uint16_t numarray = 3000; 1058 char* qlines[numarray], *plines[numarray]; 1059 uint16_t i, j, numq=0, nump=0; 1060 if(num > numarray) fatal_exit("too many RRs"); 1061 /* gather lines */ 1062 for(i=0; i<num; i++) { 1063 get_line(q, nq); 1064 get_line(p, np); 1065 qlines[numq++] = *q; 1066 plines[nump++] = *p; 1067 } 1068 /* see if they are all present in the other */ 1069 for(i=0; i<num; i++) { 1070 int found = 0; 1071 for(j=0; j<num; j++) { 1072 if(strcmp(qlines[i], plines[j]) == 0) { 1073 found = 1; 1074 break; 1075 } 1076 } 1077 if(!found) { 1078 verbose(3, "comparenoloc: failed for %s", qlines[i]); 1079 return 0; 1080 } 1081 } 1082 return 1; 1083 } 1084 1085 /** match two strings for unordered equality of RRs and everything else */ 1086 static int 1087 match_noloc(char* q, char* p, uint8_t* q_pkt, size_t q_pkt_len, 1088 uint8_t* p_pkt, size_t p_pkt_len) 1089 { 1090 char* nq = q, *np = p; 1091 /* if no header, compare bytes */ 1092 if(p_pkt_len < LDNS_HEADER_SIZE || q_pkt_len < LDNS_HEADER_SIZE) { 1093 if(p_pkt_len != q_pkt_len) return 0; 1094 return memcmp(p, q, p_pkt_len); 1095 } 1096 /* compare RR counts */ 1097 if(LDNS_QDCOUNT(p_pkt) != LDNS_QDCOUNT(q_pkt)) 1098 return 0; 1099 if(LDNS_ANCOUNT(p_pkt) != LDNS_ANCOUNT(q_pkt)) 1100 return 0; 1101 if(LDNS_NSCOUNT(p_pkt) != LDNS_NSCOUNT(q_pkt)) 1102 return 0; 1103 if(LDNS_ARCOUNT(p_pkt) != LDNS_ARCOUNT(q_pkt)) 1104 return 0; 1105 /* get a line from both; compare; at sections do section */ 1106 get_line(&q, &nq); 1107 get_line(&p, &np); 1108 if(strcmp(q, p) != 0) { 1109 /* header line opcode, rcode, id */ 1110 return 0; 1111 } 1112 get_line(&q, &nq); 1113 get_line(&p, &np); 1114 if(strcmp(q, p) != 0) { 1115 /* header flags, rr counts */ 1116 return 0; 1117 } 1118 /* ;; QUESTION SECTION */ 1119 get_line(&q, &nq); 1120 get_line(&p, &np); 1121 if(strcmp(q, p) != 0) return 0; 1122 if(!match_noloc_section(&q, &nq, &p, &np, LDNS_QDCOUNT(p_pkt))) 1123 return 0; 1124 1125 /* empty line and ;; ANSWER SECTION */ 1126 get_line(&q, &nq); 1127 get_line(&p, &np); 1128 if(strcmp(q, p) != 0) return 0; 1129 get_line(&q, &nq); 1130 get_line(&p, &np); 1131 if(strcmp(q, p) != 0) return 0; 1132 if(!match_noloc_section(&q, &nq, &p, &np, LDNS_ANCOUNT(p_pkt))) 1133 return 0; 1134 1135 /* empty line and ;; AUTHORITY SECTION */ 1136 get_line(&q, &nq); 1137 get_line(&p, &np); 1138 if(strcmp(q, p) != 0) return 0; 1139 get_line(&q, &nq); 1140 get_line(&p, &np); 1141 if(strcmp(q, p) != 0) return 0; 1142 if(!match_noloc_section(&q, &nq, &p, &np, LDNS_NSCOUNT(p_pkt))) 1143 return 0; 1144 1145 /* empty line and ;; ADDITIONAL SECTION */ 1146 get_line(&q, &nq); 1147 get_line(&p, &np); 1148 if(strcmp(q, p) != 0) return 0; 1149 get_line(&q, &nq); 1150 get_line(&p, &np); 1151 if(strcmp(q, p) != 0) return 0; 1152 if(!match_noloc_section(&q, &nq, &p, &np, LDNS_ARCOUNT(p_pkt))) 1153 return 0; 1154 1155 return 1; 1156 } 1157 1158 /** lowercase domain name - does not follow compression pointers */ 1159 static void lowercase_dname(uint8_t** p, size_t* remain) 1160 { 1161 unsigned i, llen; 1162 if(*remain == 0) return; 1163 while(**p != 0) { 1164 /* compressed? */ 1165 if((**p & 0xc0) == 0xc0) { 1166 llen = *remain < 2 ? (unsigned int)*remain : 2; 1167 *p += llen; 1168 *remain -= llen; 1169 return; 1170 } 1171 llen = (unsigned int)**p; 1172 *p += 1; 1173 *remain -= 1; 1174 if(*remain < llen) 1175 llen = (unsigned int)*remain; 1176 for(i=0; i<llen; i++) { 1177 (*p)[i] = (uint8_t)tolower((int)(*p)[i]); 1178 } 1179 *p += llen; 1180 *remain -= llen; 1181 if(*remain == 0) return; 1182 } 1183 /* skip root label */ 1184 *p += 1; 1185 *remain -= 1; 1186 } 1187 1188 /** lowercase rdata of type */ 1189 static void lowercase_rdata(uint8_t** p, size_t* remain, 1190 uint16_t rdatalen, uint16_t t) 1191 { 1192 const sldns_rr_descriptor *desc = sldns_rr_descript(t); 1193 uint8_t dname_count = 0; 1194 size_t i = 0; 1195 size_t rdataremain = rdatalen; 1196 if(!desc) { 1197 /* unknown type */ 1198 *p += rdatalen; 1199 *remain -= rdatalen; 1200 return; 1201 } 1202 while(dname_count < desc->_dname_count) { 1203 sldns_rdf_type f = sldns_rr_descriptor_field_type(desc, i++); 1204 if(f == LDNS_RDF_TYPE_DNAME) { 1205 lowercase_dname(p, &rdataremain); 1206 dname_count++; 1207 } else if(f == LDNS_RDF_TYPE_STR) { 1208 uint8_t len; 1209 if(rdataremain == 0) return; 1210 len = **p; 1211 if(rdataremain < ((size_t)len)+1) { 1212 /* malformed LDNS_RDF_TYPE_STR, skip remainder */ 1213 *p += rdataremain; 1214 *remain -= rdatalen; 1215 return; 1216 } 1217 *p += len+1; 1218 rdataremain -= len+1; 1219 } else { 1220 int len = 0; 1221 switch(f) { 1222 case LDNS_RDF_TYPE_CLASS: 1223 case LDNS_RDF_TYPE_ALG: 1224 case LDNS_RDF_TYPE_INT8: 1225 len = 1; 1226 break; 1227 case LDNS_RDF_TYPE_INT16: 1228 case LDNS_RDF_TYPE_TYPE: 1229 case LDNS_RDF_TYPE_CERT_ALG: 1230 len = 2; 1231 break; 1232 case LDNS_RDF_TYPE_INT32: 1233 case LDNS_RDF_TYPE_TIME: 1234 case LDNS_RDF_TYPE_A: 1235 case LDNS_RDF_TYPE_PERIOD: 1236 len = 4; 1237 break; 1238 case LDNS_RDF_TYPE_TSIGTIME: 1239 len = 6; 1240 break; 1241 case LDNS_RDF_TYPE_AAAA: 1242 len = 16; 1243 break; 1244 default: error("bad rdf type in lowercase %d", (int)f); 1245 } 1246 if (rdataremain < (size_t)len) { 1247 /* malformed RDF, skip remainder */ 1248 *p += rdataremain; 1249 *remain -= rdatalen; 1250 return; 1251 } 1252 *p += len; 1253 rdataremain -= len; 1254 } 1255 } 1256 /* skip remainder of rdata */ 1257 *p += rdataremain; 1258 *remain -= rdatalen; 1259 } 1260 1261 /** lowercase all names in the message */ 1262 static void lowercase_pkt(uint8_t* pkt, size_t pktlen) 1263 { 1264 uint16_t i; 1265 uint8_t* p = pkt; 1266 size_t remain = pktlen; 1267 uint16_t t, rdatalen; 1268 if(pktlen < LDNS_HEADER_SIZE) 1269 return; 1270 p += LDNS_HEADER_SIZE; 1271 remain -= LDNS_HEADER_SIZE; 1272 for(i=0; i<LDNS_QDCOUNT(pkt); i++) { 1273 lowercase_dname(&p, &remain); 1274 if(remain < 4) return; 1275 p += 4; 1276 remain -= 4; 1277 } 1278 for(i=0; i<LDNS_ANCOUNT(pkt)+LDNS_NSCOUNT(pkt)+LDNS_ARCOUNT(pkt); i++) { 1279 lowercase_dname(&p, &remain); 1280 if(remain < 10) return; 1281 t = sldns_read_uint16(p); 1282 rdatalen = sldns_read_uint16(p+8); 1283 p += 10; 1284 remain -= 10; 1285 if(remain < rdatalen) return; 1286 lowercase_rdata(&p, &remain, rdatalen, t); 1287 } 1288 } 1289 1290 /** match question section of packet */ 1291 static int 1292 match_question(uint8_t* q, size_t qlen, uint8_t* p, size_t plen, int mttl) 1293 { 1294 char* qstr, *pstr, *s, *qcmpstr, *pcmpstr; 1295 uint8_t* qb = q, *pb = p; 1296 int r; 1297 /* zero TTLs */ 1298 qb = memdup(q, qlen); 1299 pb = memdup(p, plen); 1300 if(!qb || !pb) error("out of memory"); 1301 if(!mttl) { 1302 zerottls(qb, qlen); 1303 zerottls(pb, plen); 1304 } 1305 lowercase_pkt(qb, qlen); 1306 lowercase_pkt(pb, plen); 1307 qstr = sldns_wire2str_pkt(qb, qlen); 1308 pstr = sldns_wire2str_pkt(pb, plen); 1309 if(!qstr || !pstr) error("cannot pkt2string"); 1310 1311 /* remove before ;; QUESTION */ 1312 s = strstr(qstr, ";; QUESTION SECTION"); 1313 qcmpstr = s; 1314 s = strstr(pstr, ";; QUESTION SECTION"); 1315 pcmpstr = s; 1316 if(!qcmpstr && !pcmpstr) { 1317 free(qstr); 1318 free(pstr); 1319 free(qb); 1320 free(pb); 1321 return 1; 1322 } 1323 if(!qcmpstr || !pcmpstr) { 1324 free(qstr); 1325 free(pstr); 1326 free(qb); 1327 free(pb); 1328 return 0; 1329 } 1330 1331 /* remove after answer section, (;; ANS, ;; AUTH, ;; ADD ..) */ 1332 s = strstr(qcmpstr, ";; ANSWER SECTION"); 1333 if(!s) s = strstr(qcmpstr, ";; AUTHORITY SECTION"); 1334 if(!s) s = strstr(qcmpstr, ";; ADDITIONAL SECTION"); 1335 if(!s) s = strstr(qcmpstr, ";; MSG SIZE"); 1336 if(s) *s = 0; 1337 s = strstr(pcmpstr, ";; ANSWER SECTION"); 1338 if(!s) s = strstr(pcmpstr, ";; AUTHORITY SECTION"); 1339 if(!s) s = strstr(pcmpstr, ";; ADDITIONAL SECTION"); 1340 if(!s) s = strstr(pcmpstr, ";; MSG SIZE"); 1341 if(s) *s = 0; 1342 1343 r = (strcmp(qcmpstr, pcmpstr) == 0); 1344 1345 if(!r) { 1346 verbose(3, "mismatch question section '%s' and '%s'", 1347 qcmpstr, pcmpstr); 1348 } 1349 1350 free(qstr); 1351 free(pstr); 1352 free(qb); 1353 free(pb); 1354 return r; 1355 } 1356 1357 /** match answer section of packet */ 1358 static int 1359 match_answer(uint8_t* q, size_t qlen, uint8_t* p, size_t plen, int mttl) 1360 { 1361 char* qstr, *pstr, *s, *qcmpstr, *pcmpstr; 1362 uint8_t* qb = q, *pb = p; 1363 int r; 1364 /* zero TTLs */ 1365 qb = memdup(q, qlen); 1366 pb = memdup(p, plen); 1367 if(!qb || !pb) error("out of memory"); 1368 if(!mttl) { 1369 zerottls(qb, qlen); 1370 zerottls(pb, plen); 1371 } 1372 lowercase_pkt(qb, qlen); 1373 lowercase_pkt(pb, plen); 1374 qstr = sldns_wire2str_pkt(qb, qlen); 1375 pstr = sldns_wire2str_pkt(pb, plen); 1376 if(!qstr || !pstr) error("cannot pkt2string"); 1377 1378 /* remove before ;; ANSWER */ 1379 s = strstr(qstr, ";; ANSWER SECTION"); 1380 qcmpstr = s; 1381 s = strstr(pstr, ";; ANSWER SECTION"); 1382 pcmpstr = s; 1383 if(!qcmpstr && !pcmpstr) { 1384 free(qstr); 1385 free(pstr); 1386 free(qb); 1387 free(pb); 1388 return 1; 1389 } 1390 if(!qcmpstr || !pcmpstr) { 1391 free(qstr); 1392 free(pstr); 1393 free(qb); 1394 free(pb); 1395 return 0; 1396 } 1397 1398 /* remove after answer section, (;; AUTH, ;; ADD, ;; MSG size ..) */ 1399 s = strstr(qcmpstr, ";; AUTHORITY SECTION"); 1400 if(!s) s = strstr(qcmpstr, ";; ADDITIONAL SECTION"); 1401 if(!s) s = strstr(qcmpstr, ";; MSG SIZE"); 1402 if(s) *s = 0; 1403 s = strstr(pcmpstr, ";; AUTHORITY SECTION"); 1404 if(!s) s = strstr(pcmpstr, ";; ADDITIONAL SECTION"); 1405 if(!s) s = strstr(pcmpstr, ";; MSG SIZE"); 1406 if(s) *s = 0; 1407 1408 r = (strcmp(qcmpstr, pcmpstr) == 0); 1409 1410 if(!r) { 1411 verbose(3, "mismatch answer section '%s' and '%s'", 1412 qcmpstr, pcmpstr); 1413 } 1414 1415 free(qstr); 1416 free(pstr); 1417 free(qb); 1418 free(pb); 1419 return r; 1420 } 1421 1422 /** ignore EDNS lines in the string by overwriting them with what's left or 1423 * zero out if at end of the string */ 1424 static int 1425 ignore_edns_lines(char* str) { 1426 char* edns = str, *n; 1427 size_t str_len = strlen(str); 1428 while((edns = strstr(edns, "; EDNS"))) { 1429 n = strchr(edns, '\n'); 1430 if(!n) { 1431 /* EDNS at end of string; zero */ 1432 *edns = 0; 1433 break; 1434 } 1435 memmove(edns, n+1, str_len-(n-str)); 1436 } 1437 return 1; 1438 } 1439 1440 /** match all of the packet */ 1441 int 1442 match_all(uint8_t* q, size_t qlen, uint8_t* p, size_t plen, int mttl, 1443 int noloc, int noedns) 1444 { 1445 char* qstr, *pstr; 1446 uint8_t* qb = q, *pb = p; 1447 int r; 1448 qb = memdup(q, qlen); 1449 pb = memdup(p, plen); 1450 if(!qb || !pb) error("out of memory"); 1451 /* zero TTLs */ 1452 if(!mttl) { 1453 zerottls(qb, qlen); 1454 zerottls(pb, plen); 1455 } 1456 lowercase_pkt(qb, qlen); 1457 lowercase_pkt(pb, plen); 1458 qstr = sldns_wire2str_pkt(qb, qlen); 1459 pstr = sldns_wire2str_pkt(pb, plen); 1460 if(!qstr || !pstr) error("cannot pkt2string"); 1461 /* should we ignore EDNS lines? */ 1462 if(noedns) { 1463 ignore_edns_lines(qstr); 1464 ignore_edns_lines(pstr); 1465 } 1466 r = (strcmp(qstr, pstr) == 0); 1467 if(!r) { 1468 /* remove ;; MSG SIZE (at end of string) */ 1469 char* s = strstr(qstr, ";; MSG SIZE"); 1470 if(s) *s=0; 1471 s = strstr(pstr, ";; MSG SIZE"); 1472 if(s) *s=0; 1473 r = (strcmp(qstr, pstr) == 0); 1474 if(!r && !noloc && !noedns) { 1475 /* we are going to fail, see if the cause is EDNS */ 1476 char* a = strstr(qstr, "; EDNS"); 1477 char* b = strstr(pstr, "; EDNS"); 1478 if( (a&&!b) || (b&&!a) ) { 1479 verbose(3, "mismatch in EDNS\n"); 1480 } 1481 } 1482 } 1483 if(!r && noloc) { 1484 /* check for reordered sections */ 1485 r = match_noloc(qstr, pstr, q, qlen, p, plen); 1486 } 1487 if(!r) { 1488 verbose(3, "mismatch pkt '%s' and '%s'", qstr, pstr); 1489 } 1490 free(qstr); 1491 free(pstr); 1492 free(qb); 1493 free(pb); 1494 return r; 1495 } 1496 1497 /** see if domain names are equal */ 1498 static int equal_dname(uint8_t* q, size_t qlen, uint8_t* p, size_t plen) 1499 { 1500 uint8_t* qn = get_qname(q, qlen); 1501 uint8_t* pn = get_qname(p, plen); 1502 char qs[512], ps[512]; 1503 size_t qslen = sizeof(qs), pslen = sizeof(ps); 1504 char* qss = qs, *pss = ps; 1505 int comprloop = 0; 1506 if(!qn || !pn) 1507 return 0; 1508 (void)sldns_wire2str_dname_scan(&qn, &qlen, &qss, &qslen, q, qlen, &comprloop); 1509 (void)sldns_wire2str_dname_scan(&pn, &plen, &pss, &pslen, p, plen, &comprloop); 1510 return (strcmp(qs, ps) == 0); 1511 } 1512 1513 /** see if domain names are subdomain q of p */ 1514 static int subdomain_dname(uint8_t* q, size_t qlen, uint8_t* p, size_t plen) 1515 { 1516 /* we use the tostring routines so as to test unbound's routines 1517 * with something else */ 1518 uint8_t* qn = get_qname(q, qlen); 1519 uint8_t* pn = get_qname(p, plen); 1520 char qs[5120], ps[5120]; 1521 size_t qslen = sizeof(qs), pslen = sizeof(ps); 1522 char* qss = qs, *pss = ps; 1523 int comprloop = 0; 1524 if(!qn || !pn) 1525 return 0; 1526 /* decompresses domain names */ 1527 (void)sldns_wire2str_dname_scan(&qn, &qlen, &qss, &qslen, q, qlen, &comprloop); 1528 (void)sldns_wire2str_dname_scan(&pn, &plen, &pss, &pslen, p, plen, &comprloop); 1529 /* same: false, (strict subdomain check)??? */ 1530 if(strcmp(qs, ps) == 0) 1531 return 1; 1532 /* qs must end in ps, at a dot, without \ in front */ 1533 qslen = strlen(qs); 1534 pslen = strlen(ps); 1535 if(qslen > pslen && strcmp(qs + (qslen-pslen), ps) == 0 && 1536 qslen + 2 >= pslen && /* space for label and dot */ 1537 qs[qslen-pslen-1] == '.') { 1538 unsigned int slashcount = 0; 1539 size_t i = qslen-pslen-2; 1540 while(i>0 && qs[i]=='\\') { 1541 i++; 1542 slashcount++; 1543 } 1544 if(slashcount%1 == 1) return 0; /* . preceded by \ */ 1545 return 1; 1546 } 1547 return 0; 1548 } 1549 1550 /** Match OPT RDATA (not the EDNS payload size or flags) */ 1551 static int 1552 match_ednsdata(uint8_t* q, size_t qlen, uint8_t* p, size_t plen) 1553 { 1554 uint8_t* walk_q = q; 1555 size_t walk_qlen = qlen; 1556 uint8_t* walk_p = p; 1557 size_t walk_plen = plen; 1558 1559 if(!pkt_find_edns_opt(&walk_q, &walk_qlen)) 1560 walk_qlen = 0; 1561 if(!pkt_find_edns_opt(&walk_p, &walk_plen)) 1562 walk_plen = 0; 1563 1564 /* class + ttl + rdlen = 8 */ 1565 if(walk_qlen <= 8 && walk_plen <= 8) { 1566 verbose(3, "NO edns opt, move on"); 1567 return 1; 1568 } 1569 if(walk_qlen != walk_plen) 1570 return 0; 1571 1572 return (memcmp(walk_p+8, walk_q+8, walk_qlen-8) == 0); 1573 } 1574 1575 /* finds entry in list, or returns NULL */ 1576 struct entry* 1577 find_match(struct entry* entries, uint8_t* query_pkt, size_t len, 1578 enum transport_type transport) 1579 { 1580 struct entry* p = entries; 1581 uint8_t* reply, *query_pkt_orig; 1582 size_t rlen, query_pkt_orig_len; 1583 /* Keep the original packet; it may be modified */ 1584 query_pkt_orig = memdup(query_pkt, len); 1585 query_pkt_orig_len = len; 1586 for(p=entries; p; p=p->next) { 1587 verbose(3, "comparepkt: "); 1588 reply = p->reply_list->reply_pkt; 1589 rlen = p->reply_list->reply_len; 1590 /* Restore the original packet for each entry */ 1591 memcpy(query_pkt, query_pkt_orig, query_pkt_orig_len); 1592 /* EDE should be first since it may modify the query_pkt */ 1593 if(p->match_ede) { 1594 int info_code = extract_ede(query_pkt, len); 1595 if(info_code == -1) { 1596 verbose(3, "bad EDE. Expected but not found\n"); 1597 continue; 1598 } else if(!p->match_ede_any && 1599 (uint16_t)info_code != p->ede_info_code) { 1600 verbose(3, "bad EDE INFO-CODE. Expected: %d, " 1601 "and got: %d\n", (int)p->ede_info_code, 1602 info_code); 1603 continue; 1604 } 1605 } 1606 /* Cookies could also modify the query_pkt; keep them early */ 1607 if(p->match_client_cookie || p->match_server_cookie) { 1608 uint8_t cookie[24]; 1609 int cookie_len = extract_cookie(query_pkt, len, 1610 cookie); 1611 if(cookie_len == -1) { 1612 verbose(3, "bad DNS Cookie. " 1613 "Expected but not found\n"); 1614 continue; 1615 } else if(p->match_client_cookie && 1616 cookie_len != 8) { 1617 verbose(3, "bad DNS Cookie. Expected client " 1618 "cookie of length 8."); 1619 continue; 1620 } else if((p->match_server_cookie) && 1621 cookie_len != 24) { 1622 verbose(3, "bad DNS Cookie. Expected server " 1623 "cookie of length 24."); 1624 continue; 1625 } 1626 } 1627 if(p->match_opcode && get_opcode(query_pkt, len) != 1628 get_opcode(reply, rlen)) { 1629 verbose(3, "bad opcode\n"); 1630 continue; 1631 } 1632 if(p->match_qtype && get_qtype(query_pkt, len) != 1633 get_qtype(reply, rlen)) { 1634 verbose(3, "bad qtype %d %d\n", get_qtype(query_pkt, len), get_qtype(reply, rlen)); 1635 continue; 1636 } 1637 if(p->match_qname) { 1638 if(!equal_dname(query_pkt, len, reply, rlen)) { 1639 verbose(3, "bad qname\n"); 1640 continue; 1641 } 1642 } 1643 if(p->match_rcode) { 1644 if(get_rcode(query_pkt, len) != get_rcode(reply, rlen)) { 1645 char *r1 = sldns_wire2str_rcode(get_rcode(query_pkt, len)); 1646 char *r2 = sldns_wire2str_rcode(get_rcode(reply, rlen)); 1647 verbose(3, "bad rcode %s instead of %s\n", 1648 r1, r2); 1649 free(r1); 1650 free(r2); 1651 continue; 1652 } 1653 } 1654 if(p->match_question) { 1655 if(!match_question(query_pkt, len, reply, rlen, 1656 (int)p->match_ttl)) { 1657 verbose(3, "bad question section\n"); 1658 continue; 1659 } 1660 } 1661 if(p->match_answer) { 1662 if(!match_answer(query_pkt, len, reply, rlen, 1663 (int)p->match_ttl)) { 1664 verbose(3, "bad answer section\n"); 1665 continue; 1666 } 1667 } 1668 if(p->match_subdomain) { 1669 if(!subdomain_dname(query_pkt, len, reply, rlen)) { 1670 verbose(3, "bad subdomain\n"); 1671 continue; 1672 } 1673 } 1674 if(p->match_serial && get_serial(query_pkt, len) != p->ixfr_soa_serial) { 1675 verbose(3, "bad serial\n"); 1676 continue; 1677 } 1678 if(p->match_do && !get_do_flag(query_pkt, len)) { 1679 verbose(3, "no DO bit set\n"); 1680 continue; 1681 } 1682 if(p->match_co && !get_co_flag(query_pkt, len)) { 1683 verbose(3, "no CO bit set\n"); 1684 continue; 1685 } 1686 if(p->match_noedns && get_has_edns(query_pkt, len)) { 1687 verbose(3, "bad; EDNS OPT present\n"); 1688 continue; 1689 } 1690 if(p->match_ednsdata_raw && 1691 !match_ednsdata(query_pkt, len, reply, rlen)) { 1692 verbose(3, "bad EDNS data match.\n"); 1693 continue; 1694 } 1695 if(p->match_transport != transport_any && p->match_transport != transport) { 1696 verbose(3, "bad transport\n"); 1697 continue; 1698 } 1699 if(p->match_all_noedns && !match_all(query_pkt, len, reply, 1700 rlen, (int)p->match_ttl, 0, 1)) { 1701 verbose(3, "bad all_noedns match\n"); 1702 continue; 1703 } 1704 if(p->match_all && !match_all(query_pkt, len, reply, rlen, 1705 (int)p->match_ttl, 0, 0)) { 1706 verbose(3, "bad allmatch\n"); 1707 continue; 1708 } 1709 verbose(3, "match!\n"); 1710 /* Restore the original packet */ 1711 memcpy(query_pkt, query_pkt_orig, query_pkt_orig_len); 1712 free(query_pkt_orig); 1713 return p; 1714 } 1715 /* Restore the original packet */ 1716 memcpy(query_pkt, query_pkt_orig, query_pkt_orig_len); 1717 free(query_pkt_orig); 1718 return NULL; 1719 } 1720 1721 void 1722 adjust_packet(struct entry* match, uint8_t** answer_pkt, size_t *answer_len, 1723 uint8_t* query_pkt, size_t query_len) 1724 { 1725 uint8_t* orig = *answer_pkt; 1726 size_t origlen = *answer_len; 1727 uint8_t* res; 1728 size_t reslen; 1729 1730 /* perform the copy; if possible; must be uncompressed */ 1731 if(match->copy_query && origlen >= LDNS_HEADER_SIZE && 1732 query_len >= LDNS_HEADER_SIZE && LDNS_QDCOUNT(query_pkt)!=0 1733 && LDNS_QDCOUNT(orig)==0) { 1734 /* no qname in output packet, insert it */ 1735 size_t dlen = get_qname_len(query_pkt, query_len); 1736 reslen = origlen + dlen + 4; 1737 res = (uint8_t*)malloc(reslen); 1738 if(!res) { 1739 verbose(1, "out of memory; send without adjust\n"); 1740 return; 1741 } 1742 /* copy the header, query, remainder */ 1743 memcpy(res, orig, LDNS_HEADER_SIZE); 1744 memmove(res+LDNS_HEADER_SIZE, query_pkt+LDNS_HEADER_SIZE, 1745 dlen+4); 1746 memmove(res+LDNS_HEADER_SIZE+dlen+4, orig+LDNS_HEADER_SIZE, 1747 reslen-(LDNS_HEADER_SIZE+dlen+4)); 1748 /* set QDCOUNT */ 1749 sldns_write_uint16(res+4, 1); 1750 } else if(match->copy_query && origlen >= LDNS_HEADER_SIZE && 1751 query_len >= LDNS_HEADER_SIZE && LDNS_QDCOUNT(query_pkt)!=0 1752 && get_qname_len(orig, origlen) == 0) { 1753 /* QDCOUNT(orig)!=0 but qlen == 0, therefore, an error */ 1754 verbose(1, "error: malformed qname; send without adjust\n"); 1755 res = memdup(orig, origlen); 1756 reslen = origlen; 1757 } else if(match->copy_query && origlen >= LDNS_HEADER_SIZE && 1758 query_len >= LDNS_HEADER_SIZE && LDNS_QDCOUNT(query_pkt)!=0 1759 && LDNS_QDCOUNT(orig)!=0) { 1760 /* in this case olen != 0 and QDCOUNT(orig)!=0 */ 1761 /* copy query section */ 1762 size_t dlen = get_qname_len(query_pkt, query_len); 1763 size_t olen = get_qname_len(orig, origlen); 1764 reslen = origlen + dlen - olen; 1765 res = (uint8_t*)malloc(reslen); 1766 if(!res) { 1767 verbose(1, "out of memory; send without adjust\n"); 1768 return; 1769 } 1770 /* copy the header, query, remainder */ 1771 memcpy(res, orig, LDNS_HEADER_SIZE); 1772 memmove(res+LDNS_HEADER_SIZE, query_pkt+LDNS_HEADER_SIZE, 1773 dlen+4); 1774 memmove(res+LDNS_HEADER_SIZE+dlen+4, 1775 orig+LDNS_HEADER_SIZE+olen+4, 1776 reslen-(LDNS_HEADER_SIZE+dlen+4)); 1777 } else if(origlen == 0) { 1778 res = NULL; 1779 reslen = 0; 1780 } else { 1781 res = memdup(orig, origlen); 1782 reslen = origlen; 1783 } 1784 if(!res && reslen > 0) { 1785 verbose(1, "out of memory; send without adjust\n"); 1786 return; 1787 } 1788 /* copy the ID */ 1789 if(match->copy_id && reslen >= 2 && query_len >= 2) 1790 res[1] = query_pkt[1]; 1791 if(match->copy_id && reslen >= 1 && query_len >= 1) 1792 res[0] = query_pkt[0]; 1793 1794 if(match->copy_ednsdata_assume_clientsubnet) { 1795 /** Assume there is only one EDNS option, which is ECS. 1796 * Copy source mask from query to scope mask in reply. Assume 1797 * rest of ECS data in response (eg address) matches the query. 1798 */ 1799 uint8_t* walk_q = orig; 1800 size_t walk_qlen = origlen; 1801 uint8_t* walk_p = res; 1802 size_t walk_plen = reslen; 1803 1804 if(!pkt_find_edns_opt(&walk_q, &walk_qlen)) { 1805 walk_qlen = 0; 1806 } 1807 if(!pkt_find_edns_opt(&walk_p, &walk_plen)) { 1808 walk_plen = 0; 1809 } 1810 /* class + ttl + rdlen + optcode + optlen + ecs fam + ecs source 1811 * + ecs scope = index 15 */ 1812 if(walk_qlen >= 15 && walk_plen >= 15) { 1813 walk_p[15] = walk_q[14]; 1814 } 1815 if(match->increment_ecs_scope) { 1816 walk_p[15]++; 1817 } 1818 } 1819 1820 if(match->sleeptime > 0) { 1821 verbose(3, "sleeping for %d seconds\n", match->sleeptime); 1822 #ifdef HAVE_SLEEP 1823 sleep(match->sleeptime); 1824 #else 1825 Sleep(match->sleeptime * 1000); 1826 #endif 1827 } 1828 *answer_pkt = res; 1829 *answer_len = reslen; 1830 } 1831 1832 /* 1833 * Parses data buffer to a query, finds the correct answer 1834 * and calls the given function for every packet to send. 1835 */ 1836 void 1837 handle_query(uint8_t* inbuf, ssize_t inlen, struct entry* entries, int* count, 1838 enum transport_type transport, void (*sendfunc)(uint8_t*, size_t, void*), 1839 void* userdata, FILE* verbose_out) 1840 { 1841 struct reply_packet *p; 1842 uint8_t *outbuf = NULL; 1843 size_t outlen = 0; 1844 struct entry* entry = NULL; 1845 1846 verbose(1, "query %d: id %d: %s %d bytes: ", ++(*count), 1847 (int)(inlen>=2?LDNS_ID_WIRE(inbuf):0), 1848 (transport==transport_tcp)?"TCP":"UDP", (int)inlen); 1849 if(verbose_out) { 1850 char* out = sldns_wire2str_pkt(inbuf, (size_t)inlen); 1851 printf("%s\n", out); 1852 free(out); 1853 } 1854 1855 /* fill up answer packet */ 1856 entry = find_match(entries, inbuf, (size_t)inlen, transport); 1857 if(!entry || !entry->reply_list) { 1858 verbose(1, "no answer packet for this query, no reply.\n"); 1859 return; 1860 } 1861 for(p = entry->reply_list; p; p = p->next) 1862 { 1863 verbose(3, "Answer pkt:\n"); 1864 if (p->reply_from_hex) { 1865 /* try to adjust the hex packet, if it can be 1866 * parsed, we can use adjust rules. if not, 1867 * send packet literally */ 1868 /* still try to adjust ID if others fail */ 1869 outlen = sldns_buffer_limit(p->reply_from_hex); 1870 outbuf = sldns_buffer_begin(p->reply_from_hex); 1871 } else { 1872 outbuf = p->reply_pkt; 1873 outlen = p->reply_len; 1874 } 1875 if(!outbuf) { 1876 verbose(1, "out of memory\n"); 1877 return; 1878 } 1879 /* copies outbuf in memory allocation */ 1880 adjust_packet(entry, &outbuf, &outlen, inbuf, (size_t)inlen); 1881 verbose(1, "Answer packet size: %u bytes.\n", (unsigned int)outlen); 1882 if(verbose_out) { 1883 char* out = sldns_wire2str_pkt(outbuf, outlen); 1884 printf("%s\n", out); 1885 free(out); 1886 } 1887 if(p->packet_sleep) { 1888 verbose(3, "sleeping for next packet %d secs\n", 1889 p->packet_sleep); 1890 #ifdef HAVE_SLEEP 1891 sleep(p->packet_sleep); 1892 #else 1893 Sleep(p->packet_sleep * 1000); 1894 #endif 1895 verbose(3, "wakeup for next packet " 1896 "(slept %d secs)\n", p->packet_sleep); 1897 } 1898 sendfunc(outbuf, outlen, userdata); 1899 free(outbuf); 1900 outbuf = NULL; 1901 outlen = 0; 1902 } 1903 } 1904 1905 /** delete the list of reply packets */ 1906 void delete_replylist(struct reply_packet* replist) 1907 { 1908 struct reply_packet *p=replist, *np; 1909 while(p) { 1910 np = p->next; 1911 free(p->reply_pkt); 1912 sldns_buffer_free(p->reply_from_hex); 1913 sldns_buffer_free(p->raw_ednsdata); 1914 free(p); 1915 p=np; 1916 } 1917 } 1918 1919 void delete_entry(struct entry* list) 1920 { 1921 struct entry *p=list, *np; 1922 while(p) { 1923 np = p->next; 1924 delete_replylist(p->reply_list); 1925 free(p); 1926 p = np; 1927 } 1928 } 1929
Indexes created Mon Sep 28 00:25:45 UTC 2026