contrib/ldns/net.c

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