1 /* 2 * net.c 3 * 4 * Network implementation 5 * All network related functions are grouped here 6 * 7 * a Net::DNS like library for C 8 * 9 * (c) NLnet Labs, 2004-2006 10 * 11 * See the file LICENSE for the license 12 */ 13 14 #include <ldns/config.h> 15 16 #include <ldns/ldns.h> 17 18 #ifdef HAVE_NETINET_IN_H 19 #include <netinet/in.h> 20 #endif 21 #ifdef HAVE_SYS_SOCKET_H 22 #include <sys/socket.h> 23 #endif 24 #ifdef HAVE_NETDB_H 25 #include <netdb.h> 26 #endif 27 #ifdef HAVE_ARPA_INET_H 28 #include <arpa/inet.h> 29 #endif 30 #include <sys/time.h> 31 #include <errno.h> 32 #include <fcntl.h> 33 34 ldns_status 35 ldns_send(ldns_pkt **result_packet, ldns_resolver *r, const ldns_pkt *query_pkt) 36 { 37 ldns_buffer *qb; 38 ldns_status result; 39 ldns_rdf *tsig_mac = NULL; 40 41 qb = ldns_buffer_new(LDNS_MIN_BUFLEN); 42 43 if (query_pkt && ldns_pkt_tsig(query_pkt)) { 44 tsig_mac = ldns_rr_rdf(ldns_pkt_tsig(query_pkt), 3); 45 } 46 47 if (!query_pkt || 48 ldns_pkt2buffer_wire(qb, query_pkt) != LDNS_STATUS_OK) { 49 result = LDNS_STATUS_ERR; 50 } else { 51 result = ldns_send_buffer(result_packet, r, qb, tsig_mac); 52 } 53 54 ldns_buffer_free(qb); 55 56 return result; 57 } 58 59 ldns_status 60 ldns_send_buffer(ldns_pkt **result, ldns_resolver *r, ldns_buffer *qb, ldns_rdf *tsig_mac) 61 { 62 uint8_t i; 63 64 struct sockaddr_storage *ns; 65 size_t ns_len; 66 struct timeval tv_s; 67 struct timeval tv_e; 68 69 ldns_rdf **ns_array; 70 size_t *rtt; 71 ldns_pkt *reply; 72 bool all_servers_rtt_inf; 73 uint8_t retries; 74 75 uint8_t *reply_bytes = NULL; 76 size_t reply_size = 0; 77 ldns_status status, send_status; 78 79 assert(r != NULL); 80 81 status = LDNS_STATUS_OK; 82 rtt = ldns_resolver_rtt(r); 83 ns_array = ldns_resolver_nameservers(r); 84 reply = NULL; 85 ns_len = 0; 86 87 all_servers_rtt_inf = true; 88 89 if (ldns_resolver_random(r)) { 90 ldns_resolver_nameservers_randomize(r); 91 } 92 93 /* loop through all defined nameservers */ 94 for (i = 0; i < ldns_resolver_nameserver_count(r); i++) { 95 if (rtt[i] == LDNS_RESOLV_RTT_INF) { 96 /* not reachable nameserver! */ 97 continue; 98 } 99 100 /* maybe verbosity setting? 101 printf("Sending to "); 102 ldns_rdf_print(stdout, ns_array[i]); 103 printf("\n"); 104 */ 105 ns = ldns_rdf2native_sockaddr_storage(ns_array[i], 106 ldns_resolver_port(r), &ns_len); 107 108 if ((ns->ss_family == AF_INET) && 109 (ldns_resolver_ip6(r) == LDNS_RESOLV_INET6)) { 110 /* not reachable */ 111 continue; 112 } 113 114 if ((ns->ss_family == AF_INET6) && 115 (ldns_resolver_ip6(r) == LDNS_RESOLV_INET)) { 116 /* not reachable */ 117 continue; 118 } 119 120 all_servers_rtt_inf = false; 121 122 gettimeofday(&tv_s, NULL); 123 124 send_status = LDNS_STATUS_ERR; 125 126 /* reply_bytes implicitly handles our error */ 127 if (1 == ldns_resolver_usevc(r)) { 128 for (retries = ldns_resolver_retry(r); retries > 0; retries--) { 129 send_status = 130 ldns_tcp_send(&reply_bytes, qb, ns, 131 (socklen_t)ns_len, ldns_resolver_timeout(r), 132 &reply_size); 133 if (send_status == LDNS_STATUS_OK) { 134 break; 135 } 136 } 137 } else { 138 for (retries = ldns_resolver_retry(r); retries > 0; retries--) { 139 /* ldns_rdf_print(stdout, ns_array[i]); */ 140 send_status = 141 ldns_udp_send(&reply_bytes, qb, ns, 142 (socklen_t)ns_len, ldns_resolver_timeout(r), 143 &reply_size); 144 145 if (send_status == LDNS_STATUS_OK) { 146 break; 147 } 148 } 149 } 150 151 if (send_status != LDNS_STATUS_OK) { 152 ldns_resolver_set_nameserver_rtt(r, i, LDNS_RESOLV_RTT_INF); 153 status = send_status; 154 } 155 156 /* obey the fail directive */ 157 if (!reply_bytes) { 158 /* the current nameserver seems to have a problem, blacklist it */ 159 if (ldns_resolver_fail(r)) { 160 LDNS_FREE(ns); 161 return LDNS_STATUS_ERR; 162 } else { 163 LDNS_FREE(ns); 164 continue; 165 } 166 } 167 168 status = ldns_wire2pkt(&reply, reply_bytes, reply_size); 169 if (status != LDNS_STATUS_OK) { 170 LDNS_FREE(reply_bytes); 171 LDNS_FREE(ns); 172 return status; 173 } 174 175 LDNS_FREE(ns); 176 gettimeofday(&tv_e, NULL); 177 178 if (reply) { 179 ldns_pkt_set_querytime(reply, (uint32_t) 180 ((tv_e.tv_sec - tv_s.tv_sec) * 1000) + 181 (tv_e.tv_usec - tv_s.tv_usec) / 1000); 182 ldns_pkt_set_answerfrom(reply, ns_array[i]); 183 ldns_pkt_set_timestamp(reply, tv_s); 184 ldns_pkt_set_size(reply, reply_size); 185 break; 186 } else { 187 if (ldns_resolver_fail(r)) { 188 /* if fail is set bail out, after the first 189 * one */ 190 break; 191 } 192 } 193 194 /* wait retrans seconds... */ 195 sleep((unsigned int) ldns_resolver_retrans(r)); 196 } 197 198 if (all_servers_rtt_inf) { 199 LDNS_FREE(reply_bytes); 200 return LDNS_STATUS_RES_NO_NS; 201 } 202 #ifdef HAVE_SSL 203 if (tsig_mac && reply_bytes) { 204 if (!ldns_pkt_tsig_verify(reply, 205 reply_bytes, 206 reply_size, 207 ldns_resolver_tsig_keyname(r), 208 ldns_resolver_tsig_keydata(r), tsig_mac)) { 209 status = LDNS_STATUS_CRYPTO_TSIG_BOGUS; 210 } 211 } 212 #else 213 (void)tsig_mac; 214 #endif /* HAVE_SSL */ 215 216 LDNS_FREE(reply_bytes); 217 if (result) { 218 *result = reply; 219 } 220 221 return status; 222 } 223 224 /** best effort to set nonblocking */ 225 static void 226 ldns_sock_nonblock(int sockfd) 227 { 228 #ifdef HAVE_FCNTL 229 int flag; 230 if((flag = fcntl(sockfd, F_GETFL)) != -1) { 231 flag |= O_NONBLOCK; 232 if(fcntl(sockfd, F_SETFL, flag) == -1) { 233 /* ignore error, continue blockingly */ 234 } 235 } 236 #elif defined(HAVE_IOCTLSOCKET) 237 unsigned long on = 1; 238 if(ioctlsocket(sockfd, FIONBIO, &on) != 0) { 239 /* ignore error, continue blockingly */ 240 } 241 #endif 242 } 243 244 /** best effort to set blocking */ 245 static void 246 ldns_sock_block(int sockfd) 247 { 248 #ifdef HAVE_FCNTL 249 int flag; 250 if((flag = fcntl(sockfd, F_GETFL)) != -1) { 251 flag &= ~O_NONBLOCK; 252 if(fcntl(sockfd, F_SETFL, flag) == -1) { 253 /* ignore error, continue */ 254 } 255 } 256 #elif defined(HAVE_IOCTLSOCKET) 257 unsigned long off = 0; 258 if(ioctlsocket(sockfd, FIONBIO, &off) != 0) { 259 /* ignore error, continue */ 260 } 261 #endif 262 } 263 264 /** wait for a socket to become ready */ 265 static int 266 ldns_sock_wait(int sockfd, struct timeval timeout, int write) 267 { 268 fd_set fds; 269 int ret; 270 #ifndef S_SPLINT_S 271 FD_ZERO(&fds); 272 FD_SET(FD_SET_T sockfd, &fds); 273 #endif 274 if(write) 275 ret = select(sockfd+1, NULL, &fds, NULL, &timeout); 276 else 277 ret = select(sockfd+1, &fds, NULL, NULL, &timeout); 278 if(ret == 0) 279 /* timeout expired */ 280 return 0; 281 else if(ret == -1) 282 /* error */ 283 return 0; 284 return 1; 285 } 286 287 ldns_status 288 ldns_udp_send(uint8_t **result, ldns_buffer *qbin, const struct sockaddr_storage *to, 289 socklen_t tolen, struct timeval timeout, size_t *answer_size) 290 { 291 int sockfd; 292 uint8_t *answer; 293 294 sockfd = ldns_udp_bgsend(qbin, to, tolen, timeout); 295 296 if (sockfd == 0) { 297 return LDNS_STATUS_SOCKET_ERROR; 298 } 299 300 /* wait for an response*/ 301 if(!ldns_sock_wait(sockfd, timeout, 0)) { 302 #ifndef USE_WINSOCK 303 close(sockfd); 304 #else 305 closesocket(sockfd); 306 #endif 307 return LDNS_STATUS_NETWORK_ERR; 308 } 309 310 /* set to nonblocking, so if the checksum is bad, it becomes 311 * an EGAIN error and the ldns_udp_send function does not block, 312 * but returns a 'NETWORK_ERROR' much like a timeout. */ 313 ldns_sock_nonblock(sockfd); 314 315 answer = ldns_udp_read_wire(sockfd, answer_size, NULL, NULL); 316 #ifndef USE_WINSOCK 317 close(sockfd); 318 #else 319 closesocket(sockfd); 320 #endif 321 322 if (*answer_size == 0) { 323 /* oops */ 324 return LDNS_STATUS_NETWORK_ERR; 325 } 326 327 *result = answer; 328 return LDNS_STATUS_OK; 329 } 330 331 int 332 ldns_udp_bgsend(ldns_buffer *qbin, const struct sockaddr_storage *to, socklen_t tolen, 333 struct timeval timeout) 334 { 335 int sockfd; 336 337 sockfd = ldns_udp_connect(to, timeout); 338 339 if (sockfd == 0) { 340 return 0; 341 } 342 343 if (ldns_udp_send_query(qbin, sockfd, to, tolen) == 0) { 344 return 0; 345 } 346 return sockfd; 347 } 348 349 int 350 ldns_udp_connect(const struct sockaddr_storage *to, struct timeval ATTR_UNUSED(timeout)) 351 { 352 int sockfd; 353 354 if ((sockfd = socket((int)((struct sockaddr*)to)->sa_family, SOCK_DGRAM, 355 IPPROTO_UDP)) 356 == -1) { 357 return 0; 358 } 359 return sockfd; 360 } 361 362 int 363 ldns_tcp_connect(const struct sockaddr_storage *to, socklen_t tolen, 364 struct timeval timeout) 365 { 366 int sockfd; 367 368 if ((sockfd = socket((int)((struct sockaddr*)to)->sa_family, SOCK_STREAM, 369 IPPROTO_TCP)) == -1) { 370 return 0; 371 } 372 373 /* perform nonblocking connect, to be able to wait with select() */ 374 ldns_sock_nonblock(sockfd); 375 if (connect(sockfd, (struct sockaddr*)to, tolen) == -1) { 376 #ifndef USE_WINSOCK 377 #ifdef EINPROGRESS 378 if(errno != EINPROGRESS) { 379 #else 380 if(1) { 381 #endif 382 close(sockfd); 383 return 0; 384 } 385 #else /* USE_WINSOCK */ 386 if(WSAGetLastError() != WSAEINPROGRESS && 387 WSAGetLastError() != WSAEWOULDBLOCK) { 388 closesocket(sockfd); 389 return 0; 390 } 391 #endif 392 /* error was only telling us that it would block */ 393 } 394 395 /* wait(write) until connected or error */ 396 while(1) { 397 int error = 0; 398 socklen_t len = (socklen_t)sizeof(error); 399 400 if(!ldns_sock_wait(sockfd, timeout, 1)) { 401 #ifndef USE_WINSOCK 402 close(sockfd); 403 #else 404 closesocket(sockfd); 405 #endif 406 return 0; 407 } 408 409 /* check if there is a pending error for nonblocking connect */ 410 if(getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void*)&error, 411 &len) < 0) { 412 #ifndef USE_WINSOCK 413 error = errno; /* on solaris errno is error */ 414 #else 415 error = WSAGetLastError(); 416 #endif 417 } 418 #ifndef USE_WINSOCK 419 #if defined(EINPROGRESS) && defined(EWOULDBLOCK) 420 if(error == EINPROGRESS || error == EWOULDBLOCK) 421 continue; /* try again */ 422 #endif 423 else if(error != 0) { 424 close(sockfd); 425 /* error in errno for our user */ 426 errno = error; 427 return 0; 428 } 429 #else /* USE_WINSOCK */ 430 if(error == WSAEINPROGRESS) 431 continue; 432 else if(error == WSAEWOULDBLOCK) 433 continue; 434 else if(error != 0) { 435 closesocket(sockfd); 436 errno = error; 437 return 0; 438 } 439 #endif /* USE_WINSOCK */ 440 /* connected */ 441 break; 442 } 443 444 /* set the socket blocking again */ 445 ldns_sock_block(sockfd); 446 447 return sockfd; 448 } 449 450 ssize_t 451 ldns_tcp_send_query(ldns_buffer *qbin, int sockfd, 452 const struct sockaddr_storage *to, socklen_t tolen) 453 { 454 uint8_t *sendbuf; 455 ssize_t bytes; 456 457 /* add length of packet */ 458 sendbuf = LDNS_XMALLOC(uint8_t, ldns_buffer_position(qbin) + 2); 459 if(!sendbuf) return 0; 460 ldns_write_uint16(sendbuf, ldns_buffer_position(qbin)); 461 memcpy(sendbuf + 2, ldns_buffer_export(qbin), ldns_buffer_position(qbin)); 462 463 bytes = sendto(sockfd, (void*)sendbuf, 464 ldns_buffer_position(qbin) + 2, 0, (struct sockaddr *)to, tolen); 465 466 LDNS_FREE(sendbuf); 467 468 if (bytes == -1 || (size_t) bytes != ldns_buffer_position(qbin) + 2 ) { 469 return 0; 470 } 471 return bytes; 472 } 473 474 /* don't wait for an answer */ 475 ssize_t 476 ldns_udp_send_query(ldns_buffer *qbin, int sockfd, const struct sockaddr_storage *to, 477 socklen_t tolen) 478 { 479 ssize_t bytes; 480 481 bytes = sendto(sockfd, (void*)ldns_buffer_begin(qbin), 482 ldns_buffer_position(qbin), 0, (struct sockaddr *)to, tolen); 483 484 if (bytes == -1 || (size_t)bytes != ldns_buffer_position(qbin)) { 485 return 0; 486 } 487 if ((size_t) bytes != ldns_buffer_position(qbin)) { 488 return 0; 489 } 490 return bytes; 491 } 492 493 uint8_t * 494 ldns_udp_read_wire(int sockfd, size_t *size, struct sockaddr_storage *from, 495 socklen_t *fromlen) 496 { 497 uint8_t *wire, *wireout; 498 ssize_t wire_size; 499 500 wire = LDNS_XMALLOC(uint8_t, LDNS_MAX_PACKETLEN); 501 if (!wire) { 502 *size = 0; 503 return NULL; 504 } 505 506 wire_size = recvfrom(sockfd, (void*)wire, LDNS_MAX_PACKETLEN, 0, 507 (struct sockaddr *)from, fromlen); 508 509 /* recvfrom can also return 0 */ 510 if (wire_size == -1 || wire_size == 0) { 511 *size = 0; 512 LDNS_FREE(wire); 513 return NULL; 514 } 515 516 *size = (size_t)wire_size; 517 wireout = LDNS_XREALLOC(wire, uint8_t, (size_t)wire_size); 518 if(!wireout) LDNS_FREE(wire); 519 520 return wireout; 521 } 522 523 uint8_t * 524 ldns_tcp_read_wire_timeout(int sockfd, size_t *size, struct timeval timeout) 525 { 526 uint8_t *wire; 527 uint16_t wire_size; 528 ssize_t bytes = 0, rc = 0; 529 530 wire = LDNS_XMALLOC(uint8_t, 2); 531 if (!wire) { 532 *size = 0; 533 return NULL; 534 } 535 536 while (bytes < 2) { 537 if(!ldns_sock_wait(sockfd, timeout, 0)) { 538 *size = 0; 539 LDNS_FREE(wire); 540 return NULL; 541 } 542 rc = recv(sockfd, (void*) (wire + bytes), 543 (size_t) (2 - bytes), 0); 544 if (rc == -1 || rc == 0) { 545 *size = 0; 546 LDNS_FREE(wire); 547 return NULL; 548 } 549 bytes += rc; 550 } 551 552 wire_size = ldns_read_uint16(wire); 553 554 LDNS_FREE(wire); 555 wire = LDNS_XMALLOC(uint8_t, wire_size); 556 if (!wire) { 557 *size = 0; 558 return NULL; 559 } 560 bytes = 0; 561 562 while (bytes < (ssize_t) wire_size) { 563 if(!ldns_sock_wait(sockfd, timeout, 0)) { 564 *size = 0; 565 LDNS_FREE(wire); 566 return NULL; 567 } 568 rc = recv(sockfd, (void*) (wire + bytes), 569 (size_t) (wire_size - bytes), 0); 570 if (rc == -1 || rc == 0) { 571 LDNS_FREE(wire); 572 *size = 0; 573 return NULL; 574 } 575 bytes += rc; 576 } 577 578 *size = (size_t) bytes; 579 return wire; 580 } 581 582 uint8_t * 583 ldns_tcp_read_wire(int sockfd, size_t *size) 584 { 585 uint8_t *wire; 586 uint16_t wire_size; 587 ssize_t bytes = 0, rc = 0; 588 589 wire = LDNS_XMALLOC(uint8_t, 2); 590 if (!wire) { 591 *size = 0; 592 return NULL; 593 } 594 595 while (bytes < 2) { 596 rc = recv(sockfd, (void*) (wire + bytes), 597 (size_t) (2 - bytes), 0); 598 if (rc == -1 || rc == 0) { 599 *size = 0; 600 LDNS_FREE(wire); 601 return NULL; 602 } 603 bytes += rc; 604 } 605 606 wire_size = ldns_read_uint16(wire); 607 608 LDNS_FREE(wire); 609 wire = LDNS_XMALLOC(uint8_t, wire_size); 610 if (!wire) { 611 *size = 0; 612 return NULL; 613 } 614 bytes = 0; 615 616 while (bytes < (ssize_t) wire_size) { 617 rc = recv(sockfd, (void*) (wire + bytes), 618 (size_t) (wire_size - bytes), 0); 619 if (rc == -1 || rc == 0) { 620 LDNS_FREE(wire); 621 *size = 0; 622 return NULL; 623 } 624 bytes += rc; 625 } 626 627 *size = (size_t) bytes; 628 return wire; 629 } 630 631 /* keep in mind that in DNS tcp messages the first 2 bytes signal the 632 * amount data to expect 633 */ 634 ldns_status 635 ldns_tcp_send(uint8_t **result, ldns_buffer *qbin, const struct sockaddr_storage *to, 636 socklen_t tolen, struct timeval timeout, size_t *answer_size) 637 { 638 int sockfd; 639 uint8_t *answer; 640 641 sockfd = ldns_tcp_bgsend(qbin, to, tolen, timeout); 642 643 if (sockfd == 0) { 644 return LDNS_STATUS_ERR; 645 } 646 647 answer = ldns_tcp_read_wire_timeout(sockfd, answer_size, timeout); 648 #ifndef USE_WINSOCK 649 close(sockfd); 650 #else 651 closesocket(sockfd); 652 #endif 653 654 if (*answer_size == 0) { 655 /* oops */ 656 return LDNS_STATUS_NETWORK_ERR; 657 } 658 659 /* resize accordingly */ 660 *result = (uint8_t*)LDNS_XREALLOC(answer, uint8_t *, (size_t)*answer_size); 661 if(!*result) { 662 LDNS_FREE(answer); 663 return LDNS_STATUS_MEM_ERR; 664 } 665 return LDNS_STATUS_OK; 666 } 667 668 int 669 ldns_tcp_bgsend(ldns_buffer *qbin, const struct sockaddr_storage *to, socklen_t tolen, 670 struct timeval timeout) 671 { 672 int sockfd; 673 674 sockfd = ldns_tcp_connect(to, tolen, timeout); 675 676 if (sockfd == 0) { 677 return 0; 678 } 679 680 if (ldns_tcp_send_query(qbin, sockfd, to, tolen) == 0) { 681 return 0; 682 } 683 684 return sockfd; 685 } 686 687 /* code from rdata.c */ 688 struct sockaddr_storage * 689 ldns_rdf2native_sockaddr_storage(const ldns_rdf *rd, uint16_t port, size_t *size) 690 { 691 struct sockaddr_storage *data; 692 struct sockaddr_in *data_in; 693 struct sockaddr_in6 *data_in6; 694 695 data = LDNS_MALLOC(struct sockaddr_storage); 696 if (!data) { 697 return NULL; 698 } 699 /* zero the structure for portability */ 700 memset(data, 0, sizeof(struct sockaddr_storage)); 701 if (port == 0) { 702 port = LDNS_PORT; 703 } 704 705 switch(ldns_rdf_get_type(rd)) { 706 case LDNS_RDF_TYPE_A: 707 data->ss_family = AF_INET; 708 data_in = (struct sockaddr_in*) data; 709 data_in->sin_port = (in_port_t)htons(port); 710 memcpy(&(data_in->sin_addr), ldns_rdf_data(rd), ldns_rdf_size(rd)); 711 *size = sizeof(struct sockaddr_in); 712 return data; 713 case LDNS_RDF_TYPE_AAAA: 714 data->ss_family = AF_INET6; 715 data_in6 = (struct sockaddr_in6*) data; 716 data_in6->sin6_port = (in_port_t)htons(port); 717 memcpy(&data_in6->sin6_addr, ldns_rdf_data(rd), ldns_rdf_size(rd)); 718 *size = sizeof(struct sockaddr_in6); 719 return data; 720 default: 721 LDNS_FREE(data); 722 return NULL; 723 } 724 } 725 726 ldns_rdf * 727 ldns_sockaddr_storage2rdf(struct sockaddr_storage *sock, uint16_t *port) 728 { 729 ldns_rdf *addr; 730 struct sockaddr_in *data_in; 731 struct sockaddr_in6 *data_in6; 732 733 switch(sock->ss_family) { 734 case AF_INET: 735 data_in = (struct sockaddr_in*)sock; 736 if (port) { 737 *port = ntohs((uint16_t)data_in->sin_port); 738 } 739 addr = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_A, 740 LDNS_IP4ADDRLEN, &data_in->sin_addr); 741 break; 742 case AF_INET6: 743 data_in6 = (struct sockaddr_in6*)sock; 744 if (port) { 745 *port = ntohs((uint16_t)data_in6->sin6_port); 746 } 747 addr = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_AAAA, 748 LDNS_IP6ADDRLEN, &data_in6->sin6_addr); 749 break; 750 default: 751 if (port) { 752 *port = 0; 753 } 754 return NULL; 755 } 756 return addr; 757 } 758 759 /* code from resolver.c */ 760 ldns_status 761 ldns_axfr_start(ldns_resolver *resolver, ldns_rdf *domain, ldns_rr_class class) 762 { 763 ldns_pkt *query; 764 ldns_buffer *query_wire; 765 766 struct sockaddr_storage *ns = NULL; 767 size_t ns_len = 0; 768 size_t ns_i; 769 ldns_status status; 770 771 if (!resolver || ldns_resolver_nameserver_count(resolver) < 1) { 772 return LDNS_STATUS_ERR; 773 } 774 775 query = ldns_pkt_query_new(ldns_rdf_clone(domain), LDNS_RR_TYPE_AXFR, class, 0); 776 777 if (!query) { 778 return LDNS_STATUS_ADDRESS_ERR; 779 } 780 /* For AXFR, we have to make the connection ourselves */ 781 /* try all nameservers (which usually would mean v4 fallback if 782 * @hostname is used */ 783 for (ns_i = 0; 784 ns_i < ldns_resolver_nameserver_count(resolver) && 785 resolver->_socket == 0; 786 ns_i++) { 787 ns = ldns_rdf2native_sockaddr_storage( 788 resolver->_nameservers[ns_i], 789 ldns_resolver_port(resolver), &ns_len); 790 791 resolver->_socket = ldns_tcp_connect(ns, (socklen_t)ns_len, 792 ldns_resolver_timeout(resolver)); 793 } 794 795 if (resolver->_socket == 0) { 796 ldns_pkt_free(query); 797 LDNS_FREE(ns); 798 return LDNS_STATUS_NETWORK_ERR; 799 } 800 801 #ifdef HAVE_SSL 802 if (ldns_resolver_tsig_keyname(resolver) && ldns_resolver_tsig_keydata(resolver)) { 803 status = ldns_pkt_tsig_sign(query, 804 ldns_resolver_tsig_keyname(resolver), 805 ldns_resolver_tsig_keydata(resolver), 806 300, ldns_resolver_tsig_algorithm(resolver), NULL); 807 if (status != LDNS_STATUS_OK) { 808 /* RoRi: to prevent problems on subsequent calls to ldns_axfr_start 809 we have to close the socket here! */ 810 #ifndef USE_WINSOCK 811 close(resolver->_socket); 812 #else 813 closesocket(resolver->_socket); 814 #endif 815 resolver->_socket = 0; 816 817 return LDNS_STATUS_CRYPTO_TSIG_ERR; 818 } 819 } 820 #endif /* HAVE_SSL */ 821 822 /* Convert the query to a buffer 823 * Is this necessary? 824 */ 825 query_wire = ldns_buffer_new(LDNS_MAX_PACKETLEN); 826 if(!query_wire) { 827 ldns_pkt_free(query); 828 LDNS_FREE(ns); 829 #ifndef USE_WINSOCK 830 close(resolver->_socket); 831 #else 832 closesocket(resolver->_socket); 833 #endif 834 resolver->_socket = 0; 835 836 return LDNS_STATUS_MEM_ERR; 837 } 838 status = ldns_pkt2buffer_wire(query_wire, query); 839 if (status != LDNS_STATUS_OK) { 840 ldns_pkt_free(query); 841 ldns_buffer_free(query_wire); 842 LDNS_FREE(ns); 843 844 /* RoRi: to prevent problems on subsequent calls to ldns_axfr_start 845 we have to close the socket here! */ 846 #ifndef USE_WINSOCK 847 close(resolver->_socket); 848 #else 849 closesocket(resolver->_socket); 850 #endif 851 resolver->_socket = 0; 852 853 return status; 854 } 855 /* Send the query */ 856 if (ldns_tcp_send_query(query_wire, resolver->_socket, ns, 857 (socklen_t)ns_len) == 0) { 858 ldns_pkt_free(query); 859 ldns_buffer_free(query_wire); 860 LDNS_FREE(ns); 861 862 /* RoRi: to prevent problems on subsequent calls to ldns_axfr_start 863 we have to close the socket here! */ 864 865 #ifndef USE_WINSOCK 866 close(resolver->_socket); 867 #else 868 closesocket(resolver->_socket); 869 #endif 870 resolver->_socket = 0; 871 872 return LDNS_STATUS_NETWORK_ERR; 873 } 874 875 ldns_pkt_free(query); 876 ldns_buffer_free(query_wire); 877 LDNS_FREE(ns); 878 879 /* 880 * The AXFR is done once the second SOA record is sent 881 */ 882 resolver->_axfr_soa_count = 0; 883 return LDNS_STATUS_OK; 884 } 885