2 Linux DNS client library implementation
4 Copyright (C) 2006 Krishna Ganugapati <krishnag@centeris.com>
5 Copyright (C) 2006 Gerald Carter <jerry@samba.org>
7 ** NOTE! The following LGPL license applies to the libaddns
8 ** library. This does NOT imply that all of Samba is released
11 This library is free software; you can redistribute it and/or
12 modify it under the terms of the GNU Lesser General Public
13 License as published by the Free Software Foundation; either
14 version 2.1 of the License, or (at your option) any later version.
16 This library is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 Lesser General Public License for more details.
21 You should have received a copy of the GNU Lesser General Public
22 License along with this library; if not, see <http://www.gnu.org/licenses/>.
29 #include "system/select.h"
30 #include "../lib/util/debug.h"
32 static int destroy_dns_connection(struct dns_connection
*conn
)
34 return close(conn
->s
);
37 /********************************************************************
38 ********************************************************************/
40 static DNS_ERROR
dns_open_helper(const char *nameserver
,
42 struct addrinfo
*hints
,
44 struct dns_connection
**ret_conn
)
48 struct addrinfo
*ai_result
= NULL
;
49 struct dns_connection
*conn
= NULL
;
51 if (!(conn
= talloc(mem_ctx
, struct dns_connection
))) {
52 return ERROR_DNS_NO_MEMORY
;
55 ret
= getaddrinfo(nameserver
, service
, hints
, &ai_result
);
57 DEBUG(1,("dns_tcp_open: getaddrinfo: %s\n", gai_strerror(ret
)));
59 return ERROR_DNS_INVALID_NAME_SERVER
;
62 for (rp
= ai_result
; rp
!= NULL
; rp
= rp
->ai_next
) {
63 conn
->s
= socket(rp
->ai_family
,
70 ret
= connect(conn
->s
, rp
->ai_addr
, rp
->ai_addrlen
);
71 } while ((ret
== -1) && (errno
== EINTR
));
73 /* Successful connect */
79 freeaddrinfo(ai_result
);
83 return ERROR_DNS_CONNECTION_FAILED
;
86 talloc_set_destructor(conn
, destroy_dns_connection
);
89 return ERROR_DNS_SUCCESS
;
92 static DNS_ERROR
dns_tcp_open( const char *nameserver
,
94 struct dns_connection
**result
)
96 struct addrinfo hints
;
97 struct dns_connection
*conn
;
101 snprintf(service
, sizeof(service
), "%d", DNS_TCP_PORT
);
103 memset(&hints
, 0, sizeof(struct addrinfo
));
104 hints
.ai_family
= AF_UNSPEC
;
105 hints
.ai_socktype
= SOCK_STREAM
;
107 hints
.ai_protocol
= IPPROTO_TCP
;
109 dns_ret
= dns_open_helper(nameserver
, service
, &hints
, mem_ctx
, &conn
);
110 if (!ERR_DNS_IS_OK(dns_ret
)) {
114 conn
->hType
= DNS_TCP
;
116 return ERROR_DNS_SUCCESS
;
119 /********************************************************************
120 * ********************************************************************/
122 static DNS_ERROR
dns_udp_open( const char *nameserver
,
124 struct dns_connection
**result
)
126 struct addrinfo hints
;
127 struct sockaddr_storage RecvAddr
;
128 struct dns_connection
*conn
;
130 socklen_t RecvAddrLen
;
133 snprintf(service
, sizeof(service
), "%d", DNS_UDP_PORT
);
135 memset(&hints
, 0, sizeof(struct addrinfo
));
136 hints
.ai_family
= AF_UNSPEC
;
137 hints
.ai_socktype
= SOCK_DGRAM
;
139 hints
.ai_protocol
= IPPROTO_UDP
;
141 dns_ret
= dns_open_helper(nameserver
, service
, &hints
, mem_ctx
, &conn
);
142 if (!ERR_DNS_IS_OK(dns_ret
)) {
147 /* Set up the RecvAddr structure with the IP address of
148 the receiver and the specified port number. */
150 RecvAddrLen
= sizeof(RecvAddr
);
151 if (getpeername(conn
->s
,
152 (struct sockaddr
*)&RecvAddr
,
153 &RecvAddrLen
) == -1) {
154 return ERROR_DNS_CONNECTION_FAILED
;
157 conn
->hType
= DNS_UDP
;
158 memcpy(&conn
->RecvAddr
, &RecvAddr
, sizeof(struct sockaddr_storage
));
161 return ERROR_DNS_SUCCESS
;
164 /********************************************************************
165 ********************************************************************/
167 DNS_ERROR
dns_open_connection( const char *nameserver
, int32_t dwType
,
169 struct dns_connection
**conn
)
173 return dns_tcp_open( nameserver
, mem_ctx
, conn
);
175 return dns_udp_open( nameserver
, mem_ctx
, conn
);
178 return ERROR_DNS_INVALID_PARAMETER
;
181 static DNS_ERROR
write_all(int fd
, uint8_t *data
, size_t len
)
185 while (total
< len
) {
190 ret
= write(fd
, data
+ total
, len
- total
);
191 } while ((ret
== -1) && (errno
== EINTR
));
197 return ERROR_DNS_SOCKET_ERROR
;
203 return ERROR_DNS_SUCCESS
;
206 static DNS_ERROR
dns_send_tcp(struct dns_connection
*conn
,
207 const struct dns_buffer
*buf
)
209 uint16_t len
= htons(buf
->offset
);
212 err
= write_all(conn
->s
, (uint8_t *)&len
, sizeof(len
));
213 if (!ERR_DNS_IS_OK(err
)) return err
;
215 return write_all(conn
->s
, buf
->data
, buf
->offset
);
218 static DNS_ERROR
dns_send_udp(struct dns_connection
*conn
,
219 const struct dns_buffer
*buf
)
224 ret
= sendto(conn
->s
, buf
->data
, buf
->offset
, 0,
225 (struct sockaddr
*)&conn
->RecvAddr
,
226 sizeof(conn
->RecvAddr
));
227 } while ((ret
== -1) && (errno
== EINTR
));
229 if (ret
!= buf
->offset
) {
230 return ERROR_DNS_SOCKET_ERROR
;
233 return ERROR_DNS_SUCCESS
;
236 DNS_ERROR
dns_send(struct dns_connection
*conn
, const struct dns_buffer
*buf
)
238 if (conn
->hType
== DNS_TCP
) {
239 return dns_send_tcp(conn
, buf
);
242 if (conn
->hType
== DNS_UDP
) {
243 return dns_send_udp(conn
, buf
);
246 return ERROR_DNS_INVALID_PARAMETER
;
249 static DNS_ERROR
read_all(int fd
, uint8_t *data
, size_t len
)
253 while (total
< len
) {
260 pfd
.events
= POLLIN
|POLLHUP
;
262 fd_ready
= poll(&pfd
, 1, 10000);
263 if (fd_ready
== -1) {
264 if (errno
== EINTR
) {
267 return ERROR_DNS_SOCKET_ERROR
;
269 if ( fd_ready
== 0 ) {
271 return ERROR_DNS_SOCKET_ERROR
;
275 ret
= read(fd
, data
+ total
, len
- total
);
276 } while ((ret
== -1) && (errno
== EINTR
));
280 return ERROR_DNS_SOCKET_ERROR
;
286 return ERROR_DNS_SUCCESS
;
289 static DNS_ERROR
dns_receive_tcp(TALLOC_CTX
*mem_ctx
,
290 struct dns_connection
*conn
,
291 struct dns_buffer
**presult
)
293 struct dns_buffer
*buf
;
297 if (!(buf
= talloc_zero(mem_ctx
, struct dns_buffer
))) {
298 return ERROR_DNS_NO_MEMORY
;
301 err
= read_all(conn
->s
, (uint8_t *)&len
, sizeof(len
));
302 if (!ERR_DNS_IS_OK(err
)) {
306 buf
->size
= ntohs(len
);
308 if (buf
->size
== 0) {
310 return ERROR_DNS_SUCCESS
;
313 if (!(buf
->data
= talloc_array(buf
, uint8_t, buf
->size
))) {
315 return ERROR_DNS_NO_MEMORY
;
318 err
= read_all(conn
->s
, buf
->data
, talloc_get_size(buf
->data
));
319 if (!ERR_DNS_IS_OK(err
)) {
325 return ERROR_DNS_SUCCESS
;
328 static DNS_ERROR
dns_receive_udp(TALLOC_CTX
*mem_ctx
,
329 struct dns_connection
*conn
,
330 struct dns_buffer
**presult
)
332 struct dns_buffer
*buf
;
335 if (!(buf
= talloc_zero(mem_ctx
, struct dns_buffer
))) {
336 return ERROR_DNS_NO_MEMORY
;
340 * UDP based DNS can only be 512 bytes
343 if (!(buf
->data
= talloc_array(buf
, uint8_t, 512))) {
345 return ERROR_DNS_NO_MEMORY
;
349 received
= recv(conn
->s
, (void *)buf
->data
, 512, 0);
350 } while ((received
== -1) && (errno
== EINTR
));
352 if (received
== -1) {
354 return ERROR_DNS_SOCKET_ERROR
;
357 if (received
> 512) {
359 return ERROR_DNS_BAD_RESPONSE
;
362 buf
->size
= received
;
366 return ERROR_DNS_SUCCESS
;
369 DNS_ERROR
dns_receive(TALLOC_CTX
*mem_ctx
, struct dns_connection
*conn
,
370 struct dns_buffer
**presult
)
372 if (conn
->hType
== DNS_TCP
) {
373 return dns_receive_tcp(mem_ctx
, conn
, presult
);
376 if (conn
->hType
== DNS_UDP
) {
377 return dns_receive_udp(mem_ctx
, conn
, presult
);
380 return ERROR_DNS_INVALID_PARAMETER
;
383 DNS_ERROR
dns_transaction(TALLOC_CTX
*mem_ctx
, struct dns_connection
*conn
,
384 const struct dns_request
*req
,
385 struct dns_request
**resp
)
387 struct dns_buffer
*buf
= NULL
;
390 err
= dns_marshall_request(mem_ctx
, req
, &buf
);
391 if (!ERR_DNS_IS_OK(err
)) goto error
;
393 err
= dns_send(conn
, buf
);
394 if (!ERR_DNS_IS_OK(err
)) goto error
;
397 err
= dns_receive(mem_ctx
, conn
, &buf
);
398 if (!ERR_DNS_IS_OK(err
)) goto error
;
400 err
= dns_unmarshall_request(mem_ctx
, buf
, resp
);
407 DNS_ERROR
dns_update_transaction(TALLOC_CTX
*mem_ctx
,
408 struct dns_connection
*conn
,
409 struct dns_update_request
*up_req
,
410 struct dns_update_request
**up_resp
)
412 struct dns_request
*resp
;
415 err
= dns_transaction(mem_ctx
, conn
, dns_update2request(up_req
),
418 if (!ERR_DNS_IS_OK(err
)) return err
;
420 *up_resp
= dns_request2update(resp
);
421 return ERROR_DNS_SUCCESS
;