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 FD_ZERO(&fds); 271 FD_SET(FD_SET_T sockfd, &fds); 272 if(write) 273 ret = select(sockfd+1, NULL, &fds, NULL, &timeout); 274 else 275 ret = select(sockfd+1, &fds, NULL, NULL, &timeout); 276 if(ret == 0) 277 /* timeout expired */ 278 return 0; 279 else if(ret == -1) 280 /* error */ 281 return 0; 282 return 1; 283 } 284 285 ldns_status 286 ldns_udp_send(uint8_t **result, ldns_buffer *qbin, const struct sockaddr_storage *to, 287 socklen_t tolen, struct timeval timeout, size_t *answer_size) 288 { 289 int sockfd; 290 uint8_t *answer; 291 292 sockfd = ldns_udp_bgsend(qbin, to, tolen, timeout); 293 294 if (sockfd == 0) { 295 return LDNS_STATUS_SOCKET_ERROR; 296 } 297 298 /* wait for an response*/ 299 if(!ldns_sock_wait(sockfd, timeout, 0)) { 300 #ifndef USE_WINSOCK 301 close(sockfd); 302 #else 303 closesocket(sockfd); 304 #endif 305 return LDNS_STATUS_NETWORK_ERR; 306 } 307 308 answer = ldns_udp_read_wire(sockfd, answer_size, NULL, NULL); 309 #ifndef USE_WINSOCK 310 close(sockfd); 311 #else 312 closesocket(sockfd); 313 #endif 314 315 if (*answer_size == 0) { 316 /* oops */ 317 return LDNS_STATUS_NETWORK_ERR; 318 } 319 320 *result = answer; 321 return LDNS_STATUS_OK; 322 } 323 324 int 325 ldns_udp_bgsend(ldns_buffer *qbin, const struct sockaddr_storage *to, socklen_t tolen, 326 struct timeval timeout) 327 { 328 int sockfd; 329 330 sockfd = ldns_udp_connect(to, timeout); 331 332 if (sockfd == 0) { 333 return 0; 334 } 335 336 if (ldns_udp_send_query(qbin, sockfd, to, tolen) == 0) { 337 return 0; 338 } 339 return sockfd; 340 } 341 342 int 343 ldns_udp_connect(const struct sockaddr_storage *to, struct timeval ATTR_UNUSED(timeout)) 344 { 345 int sockfd; 346 347 if ((sockfd = socket((int)((struct sockaddr*)to)->sa_family, SOCK_DGRAM, 348 IPPROTO_UDP)) 349 == -1) { 350 return 0; 351 } 352 return sockfd; 353 } 354 355 int 356 ldns_tcp_connect(const struct sockaddr_storage *to, socklen_t tolen, 357 struct timeval timeout) 358 { 359 int sockfd; 360 361 if ((sockfd = socket((int)((struct sockaddr*)to)->sa_family, SOCK_STREAM, 362 IPPROTO_TCP)) == -1) { 363 return 0; 364 } 365 366 /* perform nonblocking connect, to be able to wait with select() */ 367 ldns_sock_nonblock(sockfd); 368 if (connect(sockfd, (struct sockaddr*)to, tolen) == -1) { 369 #ifndef USE_WINSOCK 370 #ifdef EINPROGRESS 371 if(errno != EINPROGRESS) { 372 #else 373 if(1) { 374 #endif 375 close(sockfd); 376 return 0; 377 } 378 #else /* USE_WINSOCK */ 379 if(WSAGetLastError() != WSAEINPROGRESS && 380 WSAGetLastError() != WSAEWOULDBLOCK) { 381 closesocket(sockfd); 382 return 0; 383 } 384 #endif 385 /* error was only telling us that it would block */ 386 } 387 388 /* wait(write) until connected or error */ 389 while(1) { 390 int error = 0; 391 socklen_t len = (socklen_t)sizeof(error); 392 393 if(!ldns_sock_wait(sockfd, timeout, 1)) { 394 #ifndef USE_WINSOCK 395 close(sockfd); 396 #else 397 closesocket(sockfd); 398 #endif 399 return 0; 400 } 401 402 /* check if there is a pending error for nonblocking connect */ 403 if(getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void*)&error, 404 &len) < 0) { 405 #ifndef USE_WINSOCK 406 error = errno; /* on solaris errno is error */ 407 #else 408 error = WSAGetLastError(); 409 #endif 410 } 411 #ifndef USE_WINSOCK 412 #if defined(EINPROGRESS) && defined(EWOULDBLOCK) 413 if(error == EINPROGRESS || error == EWOULDBLOCK) 414 continue; /* try again */ 415 #endif 416 else if(error != 0) { 417 close(sockfd); 418 /* error in errno for our user */ 419 errno = error; 420 return 0; 421 } 422 #else /* USE_WINSOCK */ 423 if(error == WSAEINPROGRESS) 424 continue; 425 else if(error == WSAEWOULDBLOCK) 426 continue; 427 else if(error != 0) { 428 closesocket(sockfd); 429 errno = error; 430 return 0; 431 } 432 #endif /* USE_WINSOCK */ 433 /* connected */ 434 break; 435 } 436 437 /* set the socket blocking again */ 438 ldns_sock_block(sockfd); 439 440 return sockfd; 441 } 442 443 ssize_t 444 ldns_tcp_send_query(ldns_buffer *qbin, int sockfd, 445 const struct sockaddr_storage *to, socklen_t tolen) 446 { 447 uint8_t *sendbuf; 448 ssize_t bytes; 449 450 /* add length of packet */ 451 sendbuf = LDNS_XMALLOC(uint8_t, ldns_buffer_position(qbin) + 2); 452 if(!sendbuf) return 0; 453 ldns_write_uint16(sendbuf, ldns_buffer_position(qbin)); 454 memcpy(sendbuf + 2, ldns_buffer_export(qbin), ldns_buffer_position(qbin)); 455 456 bytes = sendto(sockfd, (void*)sendbuf, 457 ldns_buffer_position(qbin) + 2, 0, (struct sockaddr *)to, tolen); 458 459 LDNS_FREE(sendbuf); 460 461 if (bytes == -1 || (size_t) bytes != ldns_buffer_position(qbin) + 2 ) { 462 return 0; 463 } 464 return bytes; 465 } 466 467 /* don't wait for an answer */ 468 ssize_t 469 ldns_udp_send_query(ldns_buffer *qbin, int sockfd, const struct sockaddr_storage *to, 470 socklen_t tolen) 471 { 472 ssize_t bytes; 473 474 bytes = sendto(sockfd, (void*)ldns_buffer_begin(qbin), 475 ldns_buffer_position(qbin), 0, (struct sockaddr *)to, tolen); 476 477 if (bytes == -1 || (size_t)bytes != ldns_buffer_position(qbin)) { 478 return 0; 479 } 480 if ((size_t) bytes != ldns_buffer_position(qbin)) { 481 return 0; 482 } 483 return bytes; 484 } 485 486 uint8_t * 487 ldns_udp_read_wire(int sockfd, size_t *size, struct sockaddr_storage *from, 488 socklen_t *fromlen) 489 { 490 uint8_t *wire, *wireout; 491 ssize_t wire_size; 492 493 wire = LDNS_XMALLOC(uint8_t, LDNS_MAX_PACKETLEN); 494 if (!wire) { 495 *size = 0; 496 return NULL; 497 } 498 499 wire_size = recvfrom(sockfd, (void*)wire, LDNS_MAX_PACKETLEN, 0, 500 (struct sockaddr *)from, fromlen); 501 502 /* recvfrom can also return 0 */ 503 if (wire_size == -1 || wire_size == 0) { 504 *size = 0; 505 LDNS_FREE(wire); 506 return NULL; 507 } 508 509 *size = (size_t)wire_size; 510 wireout = LDNS_XREALLOC(wire, uint8_t, (size_t)wire_size); 511 if(!wireout) LDNS_FREE(wire); 512 513 return wireout; 514 } 515 516 uint8_t * 517 ldns_tcp_read_wire_timeout(int sockfd, size_t *size, struct timeval timeout) 518 { 519 uint8_t *wire; 520 uint16_t wire_size; 521 ssize_t bytes = 0, rc = 0; 522 523 wire = LDNS_XMALLOC(uint8_t, 2); 524 if (!wire) { 525 *size = 0; 526 return NULL; 527 } 528 529 while (bytes < 2) { 530 if(!ldns_sock_wait(sockfd, timeout, 0)) { 531 *size = 0; 532 LDNS_FREE(wire); 533 return NULL; 534 } 535 rc = recv(sockfd, (void*) (wire + bytes), 536 (size_t) (2 - bytes), 0); 537 if (rc == -1 || rc == 0) { 538 *size = 0; 539 LDNS_FREE(wire); 540 return NULL; 541 } 542 bytes += rc; 543 } 544 545 wire_size = ldns_read_uint16(wire); 546 547 LDNS_FREE(wire); 548 wire = LDNS_XMALLOC(uint8_t, wire_size); 549 bytes = 0; 550 551 while (bytes < (ssize_t) wire_size) { 552 if(!ldns_sock_wait(sockfd, timeout, 0)) { 553 *size = 0; 554 LDNS_FREE(wire); 555 return NULL; 556 } 557 rc = recv(sockfd, (void*) (wire + bytes), 558 (size_t) (wire_size - bytes), 0); 559 if (rc == -1 || rc == 0) { 560 LDNS_FREE(wire); 561 *size = 0; 562 return NULL; 563 } 564 bytes += rc; 565 } 566 567 *size = (size_t) bytes; 568 return wire; 569 } 570 571 uint8_t * 572 ldns_tcp_read_wire(int sockfd, size_t *size) 573 { 574 uint8_t *wire; 575 uint16_t wire_size; 576 ssize_t bytes = 0, rc = 0; 577 578 wire = LDNS_XMALLOC(uint8_t, 2); 579 if (!wire) { 580 *size = 0; 581 return NULL; 582 } 583 584 while (bytes < 2) { 585 rc = recv(sockfd, (void*) (wire + bytes), 586 (size_t) (2 - bytes), 0); 587 if (rc == -1 || rc == 0) { 588 *size = 0; 589 LDNS_FREE(wire); 590 return NULL; 591 } 592 bytes += rc; 593 } 594 595 wire_size = ldns_read_uint16(wire); 596 597 LDNS_FREE(wire); 598 wire = LDNS_XMALLOC(uint8_t, wire_size); 599 bytes = 0; 600 601 while (bytes < (ssize_t) wire_size) { 602 rc = recv(sockfd, (void*) (wire + bytes), 603 (size_t) (wire_size - bytes), 0); 604 if (rc == -1 || rc == 0) { 605 LDNS_FREE(wire); 606 *size = 0; 607 return NULL; 608 } 609 bytes += rc; 610 } 611 612 *size = (size_t) bytes; 613 return wire; 614 } 615 616 /* keep in mind that in DNS tcp messages the first 2 bytes signal the 617 * amount data to expect 618 */ 619 ldns_status 620 ldns_tcp_send(uint8_t **result, ldns_buffer *qbin, const struct sockaddr_storage *to, 621 socklen_t tolen, struct timeval timeout, size_t *answer_size) 622 { 623 int sockfd; 624 uint8_t *answer; 625 626 sockfd = ldns_tcp_bgsend(qbin, to, tolen, timeout); 627 628 if (sockfd == 0) { 629 return LDNS_STATUS_ERR; 630 } 631 632 answer = ldns_tcp_read_wire_timeout(sockfd, answer_size, timeout); 633 #ifndef USE_WINSOCK 634 close(sockfd); 635 #else 636 closesocket(sockfd); 637 #endif 638 639 if (*answer_size == 0) { 640 /* oops */ 641 return LDNS_STATUS_NETWORK_ERR; 642 } 643 644 /* resize accordingly */ 645 answer = (uint8_t*)LDNS_XREALLOC(answer, uint8_t *, (size_t)*answer_size); 646 *result = answer; 647 return LDNS_STATUS_OK; 648 } 649 650 int 651 ldns_tcp_bgsend(ldns_buffer *qbin, const struct sockaddr_storage *to, socklen_t tolen, 652 struct timeval timeout) 653 { 654 int sockfd; 655 656 sockfd = ldns_tcp_connect(to, tolen, timeout); 657 658 if (sockfd == 0) { 659 return 0; 660 } 661 662 if (ldns_tcp_send_query(qbin, sockfd, to, tolen) == 0) { 663 return 0; 664 } 665 666 return sockfd; 667 } 668 669 /* code from rdata.c */ 670 struct sockaddr_storage * 671 ldns_rdf2native_sockaddr_storage(const ldns_rdf *rd, uint16_t port, size_t *size) 672 { 673 struct sockaddr_storage *data; 674 struct sockaddr_in *data_in; 675 struct sockaddr_in6 *data_in6; 676 677 data = LDNS_MALLOC(struct sockaddr_storage); 678 if (!data) { 679 return NULL; 680 } 681 /* zero the structure for portability */ 682 memset(data, 0, sizeof(struct sockaddr_storage)); 683 if (port == 0) { 684 port = LDNS_PORT; 685 } 686 687 switch(ldns_rdf_get_type(rd)) { 688 case LDNS_RDF_TYPE_A: 689 data->ss_family = AF_INET; 690 data_in = (struct sockaddr_in*) data; 691 data_in->sin_port = (in_port_t)htons(port); 692 memcpy(&(data_in->sin_addr), ldns_rdf_data(rd), ldns_rdf_size(rd)); 693 *size = sizeof(struct sockaddr_in); 694 return data; 695 case LDNS_RDF_TYPE_AAAA: 696 data->ss_family = AF_INET6; 697 data_in6 = (struct sockaddr_in6*) data; 698 data_in6->sin6_port = (in_port_t)htons(port); 699 memcpy(&data_in6->sin6_addr, ldns_rdf_data(rd), ldns_rdf_size(rd)); 700 *size = sizeof(struct sockaddr_in6); 701 return data; 702 default: 703 LDNS_FREE(data); 704 return NULL; 705 } 706 } 707 708 ldns_rdf * 709 ldns_sockaddr_storage2rdf(struct sockaddr_storage *sock, uint16_t *port) 710 { 711 ldns_rdf *addr; 712 struct sockaddr_in *data_in; 713 struct sockaddr_in6 *data_in6; 714 715 switch(sock->ss_family) { 716 case AF_INET: 717 data_in = (struct sockaddr_in*)sock; 718 if (port) { 719 *port = ntohs((uint16_t)data_in->sin_port); 720 } 721 addr = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_A, 722 LDNS_IP4ADDRLEN, &data_in->sin_addr); 723 break; 724 case AF_INET6: 725 data_in6 = (struct sockaddr_in6*)sock; 726 if (port) { 727 *port = ntohs((uint16_t)data_in6->sin6_port); 728 } 729 addr = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_AAAA, 730 LDNS_IP6ADDRLEN, &data_in6->sin6_addr); 731 break; 732 default: 733 if (port) { 734 *port = 0; 735 } 736 return NULL; 737 } 738 return addr; 739 } 740 741 /* code from resolver.c */ 742 ldns_status 743 ldns_axfr_start(ldns_resolver *resolver, ldns_rdf *domain, ldns_rr_class class) 744 { 745 ldns_pkt *query; 746 ldns_buffer *query_wire; 747 748 struct sockaddr_storage *ns = NULL; 749 size_t ns_len = 0; 750 size_t ns_i; 751 ldns_status status; 752 753 if (!resolver || ldns_resolver_nameserver_count(resolver) < 1) { 754 return LDNS_STATUS_ERR; 755 } 756 757 query = ldns_pkt_query_new(ldns_rdf_clone(domain), LDNS_RR_TYPE_AXFR, class, 0); 758 759 if (!query) { 760 return LDNS_STATUS_ADDRESS_ERR; 761 } 762 /* For AXFR, we have to make the connection ourselves */ 763 /* try all nameservers (which usually would mean v4 fallback if 764 * @hostname is used */ 765 for (ns_i = 0; 766 ns_i < ldns_resolver_nameserver_count(resolver) && 767 resolver->_socket == 0; 768 ns_i++) { 769 ns = ldns_rdf2native_sockaddr_storage( 770 resolver->_nameservers[ns_i], 771 ldns_resolver_port(resolver), &ns_len); 772 773 resolver->_socket = ldns_tcp_connect(ns, (socklen_t)ns_len, 774 ldns_resolver_timeout(resolver)); 775 } 776 777 if (resolver->_socket == 0) { 778 ldns_pkt_free(query); 779 LDNS_FREE(ns); 780 return LDNS_STATUS_NETWORK_ERR; 781 } 782 783 #ifdef HAVE_SSL 784 if (ldns_resolver_tsig_keyname(resolver) && ldns_resolver_tsig_keydata(resolver)) { 785 status = ldns_pkt_tsig_sign(query, 786 ldns_resolver_tsig_keyname(resolver), 787 ldns_resolver_tsig_keydata(resolver), 788 300, ldns_resolver_tsig_algorithm(resolver), NULL); 789 if (status != LDNS_STATUS_OK) { 790 /* RoRi: to prevent problems on subsequent calls to ldns_axfr_start 791 we have to close the socket here! */ 792 #ifndef USE_WINSOCK 793 close(resolver->_socket); 794 #else 795 closesocket(resolver->_socket); 796 #endif 797 resolver->_socket = 0; 798 799 return LDNS_STATUS_CRYPTO_TSIG_ERR; 800 } 801 } 802 #endif /* HAVE_SSL */ 803 804 /* Convert the query to a buffer 805 * Is this necessary? 806 */ 807 query_wire = ldns_buffer_new(LDNS_MAX_PACKETLEN); 808 status = ldns_pkt2buffer_wire(query_wire, query); 809 if (status != LDNS_STATUS_OK) { 810 ldns_pkt_free(query); 811 ldns_buffer_free(query_wire); 812 LDNS_FREE(ns); 813 814 /* RoRi: to prevent problems on subsequent calls to ldns_axfr_start 815 we have to close the socket here! */ 816 #ifndef USE_WINSOCK 817 close(resolver->_socket); 818 #else 819 closesocket(resolver->_socket); 820 #endif 821 resolver->_socket = 0; 822 823 return status; 824 } 825 /* Send the query */ 826 if (ldns_tcp_send_query(query_wire, resolver->_socket, ns, 827 (socklen_t)ns_len) == 0) { 828 ldns_pkt_free(query); 829 ldns_buffer_free(query_wire); 830 LDNS_FREE(ns); 831 832 /* RoRi: to prevent problems on subsequent calls to ldns_axfr_start 833 we have to close the socket here! */ 834 835 #ifndef USE_WINSOCK 836 close(resolver->_socket); 837 #else 838 closesocket(resolver->_socket); 839 #endif 840 resolver->_socket = 0; 841 842 return LDNS_STATUS_NETWORK_ERR; 843 } 844 845 ldns_pkt_free(query); 846 ldns_buffer_free(query_wire); 847 LDNS_FREE(ns); 848 849 /* 850 * The AXFR is done once the second SOA record is sent 851 */ 852 resolver->_axfr_soa_count = 0; 853 return LDNS_STATUS_OK; 854 } 855