4 * Network implementation
5 * All network related functions are grouped here
7 * a Net::DNS like library for C
9 * (c) NLnet Labs, 2004-2006
11 * See the file LICENSE for the license
14 #include <ldns/config.h>
16 #include <ldns/ldns.h>
18 #ifdef HAVE_NETINET_IN_H
19 #include <netinet/in.h>
21 #ifdef HAVE_SYS_SOCKET_H
22 #include <sys/socket.h>
27 #ifdef HAVE_ARPA_INET_H
28 #include <arpa/inet.h>
35 ldns_send(ldns_pkt **result_packet, ldns_resolver *r, const ldns_pkt *query_pkt)
39 ldns_rdf *tsig_mac = NULL;
41 qb = ldns_buffer_new(LDNS_MIN_BUFLEN);
43 if (query_pkt && ldns_pkt_tsig(query_pkt)) {
44 tsig_mac = ldns_rr_rdf(ldns_pkt_tsig(query_pkt), 3);
48 ldns_pkt2buffer_wire(qb, query_pkt) != LDNS_STATUS_OK) {
49 result = LDNS_STATUS_ERR;
51 result = ldns_send_buffer(result_packet, r, qb, tsig_mac);
60 ldns_send_buffer(ldns_pkt **result, ldns_resolver *r, ldns_buffer *qb, ldns_rdf *tsig_mac)
64 struct sockaddr_storage *ns;
72 bool all_servers_rtt_inf;
75 uint8_t *reply_bytes = NULL;
76 size_t reply_size = 0;
77 ldns_status status, send_status;
81 status = LDNS_STATUS_OK;
82 rtt = ldns_resolver_rtt(r);
83 ns_array = ldns_resolver_nameservers(r);
87 all_servers_rtt_inf = true;
89 if (ldns_resolver_random(r)) {
90 ldns_resolver_nameservers_randomize(r);
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! */
100 /* maybe verbosity setting?
101 printf("Sending to ");
102 ldns_rdf_print(stdout, ns_array[i]);
105 ns = ldns_rdf2native_sockaddr_storage(ns_array[i],
106 ldns_resolver_port(r), &ns_len);
108 if ((ns->ss_family == AF_INET) &&
109 (ldns_resolver_ip6(r) == LDNS_RESOLV_INET6)) {
114 if ((ns->ss_family == AF_INET6) &&
115 (ldns_resolver_ip6(r) == LDNS_RESOLV_INET)) {
120 all_servers_rtt_inf = false;
122 gettimeofday(&tv_s, NULL);
124 send_status = LDNS_STATUS_ERR;
126 /* reply_bytes implicitly handles our error */
127 if (1 == ldns_resolver_usevc(r)) {
128 for (retries = ldns_resolver_retry(r); retries > 0; retries--) {
130 ldns_tcp_send(&reply_bytes, qb, ns,
131 (socklen_t)ns_len, ldns_resolver_timeout(r),
133 if (send_status == LDNS_STATUS_OK) {
138 for (retries = ldns_resolver_retry(r); retries > 0; retries--) {
139 /* ldns_rdf_print(stdout, ns_array[i]); */
141 ldns_udp_send(&reply_bytes, qb, ns,
142 (socklen_t)ns_len, ldns_resolver_timeout(r),
145 if (send_status == LDNS_STATUS_OK) {
151 if (send_status != LDNS_STATUS_OK) {
152 ldns_resolver_set_nameserver_rtt(r, i, LDNS_RESOLV_RTT_INF);
153 status = send_status;
156 /* obey the fail directive */
158 /* the current nameserver seems to have a problem, blacklist it */
159 if (ldns_resolver_fail(r)) {
161 return LDNS_STATUS_ERR;
168 status = ldns_wire2pkt(&reply, reply_bytes, reply_size);
169 if (status != LDNS_STATUS_OK) {
170 LDNS_FREE(reply_bytes);
176 gettimeofday(&tv_e, NULL);
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);
187 if (ldns_resolver_fail(r)) {
188 /* if fail is set bail out, after the first
194 /* wait retrans seconds... */
195 sleep((unsigned int) ldns_resolver_retrans(r));
198 if (all_servers_rtt_inf) {
199 LDNS_FREE(reply_bytes);
200 return LDNS_STATUS_RES_NO_NS;
203 if (tsig_mac && reply_bytes) {
204 if (!ldns_pkt_tsig_verify(reply,
207 ldns_resolver_tsig_keyname(r),
208 ldns_resolver_tsig_keydata(r), tsig_mac)) {
209 status = LDNS_STATUS_CRYPTO_TSIG_BOGUS;
214 #endif /* HAVE_SSL */
216 LDNS_FREE(reply_bytes);
224 /** best effort to set nonblocking */
226 ldns_sock_nonblock(int sockfd)
230 if((flag = fcntl(sockfd, F_GETFL)) != -1) {
232 if(fcntl(sockfd, F_SETFL, flag) == -1) {
233 /* ignore error, continue blockingly */
236 #elif defined(HAVE_IOCTLSOCKET)
237 unsigned long on = 1;
238 if(ioctlsocket(sockfd, FIONBIO, &on) != 0) {
239 /* ignore error, continue blockingly */
244 /** best effort to set blocking */
246 ldns_sock_block(int sockfd)
250 if((flag = fcntl(sockfd, F_GETFL)) != -1) {
252 if(fcntl(sockfd, F_SETFL, flag) == -1) {
253 /* ignore error, continue */
256 #elif defined(HAVE_IOCTLSOCKET)
257 unsigned long off = 0;
258 if(ioctlsocket(sockfd, FIONBIO, &off) != 0) {
259 /* ignore error, continue */
264 /** wait for a socket to become ready */
266 ldns_sock_wait(int sockfd, struct timeval timeout, int write)
272 FD_SET(FD_SET_T sockfd, &fds);
275 ret = select(sockfd+1, NULL, &fds, NULL, &timeout);
277 ret = select(sockfd+1, &fds, NULL, NULL, &timeout);
279 /* timeout expired */
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)
294 sockfd = ldns_udp_bgsend(qbin, to, tolen, timeout);
297 return LDNS_STATUS_SOCKET_ERROR;
300 /* wait for an response*/
301 if(!ldns_sock_wait(sockfd, timeout, 0)) {
307 return LDNS_STATUS_NETWORK_ERR;
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);
315 answer = ldns_udp_read_wire(sockfd, answer_size, NULL, NULL);
322 if (*answer_size == 0) {
324 return LDNS_STATUS_NETWORK_ERR;
328 return LDNS_STATUS_OK;
332 ldns_udp_bgsend(ldns_buffer *qbin, const struct sockaddr_storage *to, socklen_t tolen,
333 struct timeval timeout)
337 sockfd = ldns_udp_connect(to, timeout);
343 if (ldns_udp_send_query(qbin, sockfd, to, tolen) == 0) {
355 ldns_udp_connect(const struct sockaddr_storage *to, struct timeval ATTR_UNUSED(timeout))
359 if ((sockfd = socket((int)((struct sockaddr*)to)->sa_family, SOCK_DGRAM,
368 ldns_tcp_connect(const struct sockaddr_storage *to, socklen_t tolen,
369 struct timeval timeout)
373 if ((sockfd = socket((int)((struct sockaddr*)to)->sa_family, SOCK_STREAM,
374 IPPROTO_TCP)) == -1) {
378 /* perform nonblocking connect, to be able to wait with select() */
379 ldns_sock_nonblock(sockfd);
380 if (connect(sockfd, (struct sockaddr*)to, tolen) == -1) {
383 if(errno != EINPROGRESS) {
390 #else /* USE_WINSOCK */
391 if(WSAGetLastError() != WSAEINPROGRESS &&
392 WSAGetLastError() != WSAEWOULDBLOCK) {
397 /* error was only telling us that it would block */
400 /* wait(write) until connected or error */
403 socklen_t len = (socklen_t)sizeof(error);
405 if(!ldns_sock_wait(sockfd, timeout, 1)) {
414 /* check if there is a pending error for nonblocking connect */
415 if(getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void*)&error,
418 error = errno; /* on solaris errno is error */
420 error = WSAGetLastError();
424 #if defined(EINPROGRESS) && defined(EWOULDBLOCK)
425 if(error == EINPROGRESS || error == EWOULDBLOCK)
426 continue; /* try again */
428 else if(error != 0) {
430 /* error in errno for our user */
434 #else /* USE_WINSOCK */
435 if(error == WSAEINPROGRESS)
437 else if(error == WSAEWOULDBLOCK)
439 else if(error != 0) {
444 #endif /* USE_WINSOCK */
449 /* set the socket blocking again */
450 ldns_sock_block(sockfd);
456 ldns_tcp_send_query(ldns_buffer *qbin, int sockfd,
457 const struct sockaddr_storage *to, socklen_t tolen)
462 /* add length of packet */
463 sendbuf = LDNS_XMALLOC(uint8_t, ldns_buffer_position(qbin) + 2);
464 if(!sendbuf) return 0;
465 ldns_write_uint16(sendbuf, ldns_buffer_position(qbin));
466 memcpy(sendbuf + 2, ldns_buffer_export(qbin), ldns_buffer_position(qbin));
468 bytes = sendto(sockfd, (void*)sendbuf,
469 ldns_buffer_position(qbin) + 2, 0, (struct sockaddr *)to, tolen);
473 if (bytes == -1 || (size_t) bytes != ldns_buffer_position(qbin) + 2 ) {
479 /* don't wait for an answer */
481 ldns_udp_send_query(ldns_buffer *qbin, int sockfd, const struct sockaddr_storage *to,
486 bytes = sendto(sockfd, (void*)ldns_buffer_begin(qbin),
487 ldns_buffer_position(qbin), 0, (struct sockaddr *)to, tolen);
489 if (bytes == -1 || (size_t)bytes != ldns_buffer_position(qbin)) {
492 if ((size_t) bytes != ldns_buffer_position(qbin)) {
499 ldns_udp_read_wire(int sockfd, size_t *size, struct sockaddr_storage *from,
502 uint8_t *wire, *wireout;
505 wire = LDNS_XMALLOC(uint8_t, LDNS_MAX_PACKETLEN);
511 wire_size = recvfrom(sockfd, (void*)wire, LDNS_MAX_PACKETLEN, 0,
512 (struct sockaddr *)from, fromlen);
514 /* recvfrom can also return 0 */
515 if (wire_size == -1 || wire_size == 0) {
521 *size = (size_t)wire_size;
522 wireout = LDNS_XREALLOC(wire, uint8_t, (size_t)wire_size);
523 if(!wireout) LDNS_FREE(wire);
529 ldns_tcp_read_wire_timeout(int sockfd, size_t *size, struct timeval timeout)
533 ssize_t bytes = 0, rc = 0;
535 wire = LDNS_XMALLOC(uint8_t, 2);
542 if(!ldns_sock_wait(sockfd, timeout, 0)) {
547 rc = recv(sockfd, (void*) (wire + bytes),
548 (size_t) (2 - bytes), 0);
549 if (rc == -1 || rc == 0) {
557 wire_size = ldns_read_uint16(wire);
560 wire = LDNS_XMALLOC(uint8_t, wire_size);
567 while (bytes < (ssize_t) wire_size) {
568 if(!ldns_sock_wait(sockfd, timeout, 0)) {
573 rc = recv(sockfd, (void*) (wire + bytes),
574 (size_t) (wire_size - bytes), 0);
575 if (rc == -1 || rc == 0) {
583 *size = (size_t) bytes;
588 ldns_tcp_read_wire(int sockfd, size_t *size)
592 ssize_t bytes = 0, rc = 0;
594 wire = LDNS_XMALLOC(uint8_t, 2);
601 rc = recv(sockfd, (void*) (wire + bytes),
602 (size_t) (2 - bytes), 0);
603 if (rc == -1 || rc == 0) {
611 wire_size = ldns_read_uint16(wire);
614 wire = LDNS_XMALLOC(uint8_t, wire_size);
621 while (bytes < (ssize_t) wire_size) {
622 rc = recv(sockfd, (void*) (wire + bytes),
623 (size_t) (wire_size - bytes), 0);
624 if (rc == -1 || rc == 0) {
632 *size = (size_t) bytes;
636 /* keep in mind that in DNS tcp messages the first 2 bytes signal the
637 * amount data to expect
640 ldns_tcp_send(uint8_t **result, ldns_buffer *qbin, const struct sockaddr_storage *to,
641 socklen_t tolen, struct timeval timeout, size_t *answer_size)
646 sockfd = ldns_tcp_bgsend(qbin, to, tolen, timeout);
649 return LDNS_STATUS_ERR;
652 answer = ldns_tcp_read_wire_timeout(sockfd, answer_size, timeout);
659 if (*answer_size == 0) {
661 return LDNS_STATUS_NETWORK_ERR;
664 /* resize accordingly */
665 *result = (uint8_t*)LDNS_XREALLOC(answer, uint8_t *, (size_t)*answer_size);
668 return LDNS_STATUS_MEM_ERR;
670 return LDNS_STATUS_OK;
674 ldns_tcp_bgsend(ldns_buffer *qbin, const struct sockaddr_storage *to, socklen_t tolen,
675 struct timeval timeout)
679 sockfd = ldns_tcp_connect(to, tolen, timeout);
685 if (ldns_tcp_send_query(qbin, sockfd, to, tolen) == 0) {
697 /* code from rdata.c */
698 struct sockaddr_storage *
699 ldns_rdf2native_sockaddr_storage(const ldns_rdf *rd, uint16_t port, size_t *size)
701 struct sockaddr_storage *data;
702 struct sockaddr_in *data_in;
703 struct sockaddr_in6 *data_in6;
705 data = LDNS_MALLOC(struct sockaddr_storage);
709 /* zero the structure for portability */
710 memset(data, 0, sizeof(struct sockaddr_storage));
715 switch(ldns_rdf_get_type(rd)) {
716 case LDNS_RDF_TYPE_A:
717 data->ss_family = AF_INET;
718 data_in = (struct sockaddr_in*) data;
719 data_in->sin_port = (in_port_t)htons(port);
720 memcpy(&(data_in->sin_addr), ldns_rdf_data(rd), ldns_rdf_size(rd));
721 *size = sizeof(struct sockaddr_in);
723 case LDNS_RDF_TYPE_AAAA:
724 data->ss_family = AF_INET6;
725 data_in6 = (struct sockaddr_in6*) data;
726 data_in6->sin6_port = (in_port_t)htons(port);
727 memcpy(&data_in6->sin6_addr, ldns_rdf_data(rd), ldns_rdf_size(rd));
728 *size = sizeof(struct sockaddr_in6);
737 ldns_sockaddr_storage2rdf(struct sockaddr_storage *sock, uint16_t *port)
740 struct sockaddr_in *data_in;
741 struct sockaddr_in6 *data_in6;
743 switch(sock->ss_family) {
745 data_in = (struct sockaddr_in*)sock;
747 *port = ntohs((uint16_t)data_in->sin_port);
749 addr = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_A,
750 LDNS_IP4ADDRLEN, &data_in->sin_addr);
753 data_in6 = (struct sockaddr_in6*)sock;
755 *port = ntohs((uint16_t)data_in6->sin6_port);
757 addr = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_AAAA,
758 LDNS_IP6ADDRLEN, &data_in6->sin6_addr);
769 /* code from resolver.c */
771 ldns_axfr_start(ldns_resolver *resolver, ldns_rdf *domain, ldns_rr_class class)
774 ldns_buffer *query_wire;
776 struct sockaddr_storage *ns = NULL;
781 if (!resolver || ldns_resolver_nameserver_count(resolver) < 1) {
782 return LDNS_STATUS_ERR;
785 query = ldns_pkt_query_new(ldns_rdf_clone(domain), LDNS_RR_TYPE_AXFR, class, 0);
788 return LDNS_STATUS_ADDRESS_ERR;
790 /* For AXFR, we have to make the connection ourselves */
791 /* try all nameservers (which usually would mean v4 fallback if
792 * @hostname is used */
794 ns_i < ldns_resolver_nameserver_count(resolver) &&
795 resolver->_socket == 0;
797 ns = ldns_rdf2native_sockaddr_storage(
798 resolver->_nameservers[ns_i],
799 ldns_resolver_port(resolver), &ns_len);
801 resolver->_socket = ldns_tcp_connect(ns, (socklen_t)ns_len,
802 ldns_resolver_timeout(resolver));
805 if (resolver->_socket == 0) {
806 ldns_pkt_free(query);
808 return LDNS_STATUS_NETWORK_ERR;
812 if (ldns_resolver_tsig_keyname(resolver) && ldns_resolver_tsig_keydata(resolver)) {
813 status = ldns_pkt_tsig_sign(query,
814 ldns_resolver_tsig_keyname(resolver),
815 ldns_resolver_tsig_keydata(resolver),
816 300, ldns_resolver_tsig_algorithm(resolver), NULL);
817 if (status != LDNS_STATUS_OK) {
818 /* RoRi: to prevent problems on subsequent calls to ldns_axfr_start
819 we have to close the socket here! */
821 close(resolver->_socket);
823 closesocket(resolver->_socket);
825 resolver->_socket = 0;
827 return LDNS_STATUS_CRYPTO_TSIG_ERR;
830 #endif /* HAVE_SSL */
832 /* Convert the query to a buffer
835 query_wire = ldns_buffer_new(LDNS_MAX_PACKETLEN);
837 ldns_pkt_free(query);
840 close(resolver->_socket);
842 closesocket(resolver->_socket);
844 resolver->_socket = 0;
846 return LDNS_STATUS_MEM_ERR;
848 status = ldns_pkt2buffer_wire(query_wire, query);
849 if (status != LDNS_STATUS_OK) {
850 ldns_pkt_free(query);
851 ldns_buffer_free(query_wire);
854 /* RoRi: to prevent problems on subsequent calls to ldns_axfr_start
855 we have to close the socket here! */
857 close(resolver->_socket);
859 closesocket(resolver->_socket);
861 resolver->_socket = 0;
866 if (ldns_tcp_send_query(query_wire, resolver->_socket, ns,
867 (socklen_t)ns_len) == 0) {
868 ldns_pkt_free(query);
869 ldns_buffer_free(query_wire);
872 /* RoRi: to prevent problems on subsequent calls to ldns_axfr_start
873 we have to close the socket here! */
876 close(resolver->_socket);
878 closesocket(resolver->_socket);
880 resolver->_socket = 0;
882 return LDNS_STATUS_NETWORK_ERR;
885 ldns_pkt_free(query);
886 ldns_buffer_free(query_wire);
890 * The AXFR is done once the second SOA record is sent
892 resolver->_axfr_soa_count = 0;
893 return LDNS_STATUS_OK;