1 /*
2 * Copyright (C) 2004, 2005, 2007-2009, 2012-2014 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 2000, 2001, 2003 Internet Software Consortium.
4 *
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15 * PERFORMANCE OF THIS SOFTWARE.
16 */
17
18 /* $Id: context.c,v 1.55 2009/09/02 23:48:03 tbox Exp $ */
19
20 /*! \file context.c
21 lwres_context_create() creates a #lwres_context_t structure for use in
22 lightweight resolver operations. It holds a socket and other data
23 needed for communicating with a resolver daemon. The new
24 lwres_context_t is returned through contextp, a pointer to a
25 lwres_context_t pointer. This lwres_context_t pointer must initially
26 be NULL, and is modified to point to the newly created
27 lwres_context_t.
28
29 When the lightweight resolver needs to perform dynamic memory
30 allocation, it will call malloc_function to allocate memory and
31 free_function to free it. If malloc_function and free_function are
32 NULL, memory is allocated using malloc and free. It is not
33 permitted to have a NULL malloc_function and a non-NULL free_function
34 or vice versa. arg is passed as the first parameter to the memory
35 allocation functions. If malloc_function and free_function are NULL,
36 arg is unused and should be passed as NULL.
37
38 Once memory for the structure has been allocated, it is initialized
39 using lwres_conf_init() and returned via *contextp.
40
41 lwres_context_destroy() destroys a #lwres_context_t, closing its
42 socket. contextp is a pointer to a pointer to the context that is to
43 be destroyed. The pointer will be set to NULL when the context has
44 been destroyed.
45
46 The context holds a serial number that is used to identify resolver
47 request packets and associate responses with the corresponding
48 requests. This serial number is controlled using
49 lwres_context_initserial() and lwres_context_nextserial().
50 lwres_context_initserial() sets the serial number for context *ctx to
51 serial. lwres_context_nextserial() increments the serial number and
52 returns the previous value.
53
54 Memory for a lightweight resolver context is allocated and freed using
55 lwres_context_allocmem() and lwres_context_freemem(). These use
56 whatever allocations were defined when the context was created with
57 lwres_context_create(). lwres_context_allocmem() allocates len bytes
58 of memory and if successful returns a pointer to the allocated
59 storage. lwres_context_freemem() frees len bytes of space starting at
60 location mem.
61
62 lwres_context_sendrecv() performs I/O for the context ctx. Data are
63 read and written from the context's socket. It writes data from
64 sendbase -- typically a lightweight resolver query packet -- and waits
65 for a reply which is copied to the receive buffer at recvbase. The
66 number of bytes that were written to this receive buffer is returned
67 in *recvd_len.
68
69 \section context_return Return Values
70
71 lwres_context_create() returns #LWRES_R_NOMEMORY if memory for the
72 struct lwres_context could not be allocated, #LWRES_R_SUCCESS
73 otherwise.
74
75 Successful calls to the memory allocator lwres_context_allocmem()
76 return a pointer to the start of the allocated space. It returns NULL
77 if memory could not be allocated.
78
79 #LWRES_R_SUCCESS is returned when lwres_context_sendrecv() completes
80 successfully. #LWRES_R_IOERROR is returned if an I/O error occurs and
81 #LWRES_R_TIMEOUT is returned if lwres_context_sendrecv() times out
82 waiting for a response.
83
84 \section context_see See Also
85
86 lwres_conf_init(), malloc, free.
87 */
88 #include <config.h>
89
90 #include <fcntl.h>
91 #include <limits.h>
92 #include <stdlib.h>
93 #include <string.h>
94 #include <time.h>
95 #include <unistd.h>
96
97 #include <lwres/lwres.h>
98 #include <lwres/net.h>
99 #include <lwres/platform.h>
100
101 #ifdef LWRES_PLATFORM_NEEDSYSSELECTH
102 #include <sys/select.h>
103 #endif
104
105 #include "context_p.h"
106 #include "assert_p.h"
107
108 /*!
109 * Some systems define the socket length argument as an int, some as size_t,
110 * some as socklen_t. The last is what the current POSIX standard mandates.
111 * This definition is here so it can be portable but easily changed if needed.
112 */
113 #ifndef LWRES_SOCKADDR_LEN_T
114 #define LWRES_SOCKADDR_LEN_T unsigned int
115 #endif
116
117 /*!
118 * Make a socket nonblocking.
119 */
120 #ifndef MAKE_NONBLOCKING
121 #define MAKE_NONBLOCKING(sd, retval) \
122 do { \
123 retval = fcntl(sd, F_GETFL, 0); \
124 if (retval != -1) { \
125 retval |= O_NONBLOCK; \
126 retval = fcntl(sd, F_SETFL, retval); \
127 } \
128 } while (0)
129 #endif
130
131 LIBLWRES_EXTERNAL_DATA lwres_uint16_t lwres_udp_port = LWRES_UDP_PORT;
132 LIBLWRES_EXTERNAL_DATA const char *lwres_resolv_conf = LWRES_RESOLV_CONF;
133
134 static void *
135 lwres_malloc(void *, size_t);
136
137 static void
138 lwres_free(void *, void *, size_t);
139
140 /*!
141 * lwres_result_t
142 */
143 static lwres_result_t
144 context_connect(lwres_context_t *);
145
146 /*%
147 * Creates a #lwres_context_t structure for use in
148 * lightweight resolver operations.
149 */
150 lwres_result_t
lwres_context_create(lwres_context_t ** contextp,void * arg,lwres_malloc_t malloc_function,lwres_free_t free_function,unsigned int flags)151 lwres_context_create(lwres_context_t **contextp, void *arg,
152 lwres_malloc_t malloc_function,
153 lwres_free_t free_function,
154 unsigned int flags)
155 {
156 lwres_context_t *ctx;
157
158 REQUIRE(contextp != NULL && *contextp == NULL);
159
160 /*
161 * If we were not given anything special to use, use our own
162 * functions. These are just wrappers around malloc() and free().
163 */
164 if (malloc_function == NULL || free_function == NULL) {
165 REQUIRE(malloc_function == NULL);
166 REQUIRE(free_function == NULL);
167 malloc_function = lwres_malloc;
168 free_function = lwres_free;
169 }
170
171 ctx = malloc_function(arg, sizeof(lwres_context_t));
172 if (ctx == NULL)
173 return (LWRES_R_NOMEMORY);
174
175 /*
176 * Set up the context.
177 */
178 ctx->malloc = malloc_function;
179 ctx->free = free_function;
180 ctx->arg = arg;
181 ctx->sock = -1;
182
183 ctx->timeout = LWRES_DEFAULT_TIMEOUT;
184 #ifndef WIN32
185 ctx->serial = time(NULL); /* XXXMLG or BEW */
186 #else
187 ctx->serial = _time32(NULL);
188 #endif
189
190 ctx->use_ipv4 = 1;
191 ctx->use_ipv6 = 1;
192 if ((flags & (LWRES_CONTEXT_USEIPV4 | LWRES_CONTEXT_USEIPV6)) ==
193 LWRES_CONTEXT_USEIPV6) {
194 ctx->use_ipv4 = 0;
195 }
196 if ((flags & (LWRES_CONTEXT_USEIPV4 | LWRES_CONTEXT_USEIPV6)) ==
197 LWRES_CONTEXT_USEIPV4) {
198 ctx->use_ipv6 = 0;
199 }
200
201 /*
202 * Init resolv.conf bits.
203 */
204 lwres_conf_init(ctx);
205
206 *contextp = ctx;
207 return (LWRES_R_SUCCESS);
208 }
209
210 /*%
211 Destroys a #lwres_context_t, closing its socket.
212 contextp is a pointer to a pointer to the context that is
213 to be destroyed. The pointer will be set to NULL
214 when the context has been destroyed.
215 */
216 void
lwres_context_destroy(lwres_context_t ** contextp)217 lwres_context_destroy(lwres_context_t **contextp) {
218 lwres_context_t *ctx;
219
220 REQUIRE(contextp != NULL && *contextp != NULL);
221
222 ctx = *contextp;
223 *contextp = NULL;
224
225 if (ctx->sock != -1) {
226 #ifdef WIN32
227 DestroySockets();
228 #endif
229 (void)close(ctx->sock);
230 ctx->sock = -1;
231 }
232
233 CTXFREE(ctx, sizeof(lwres_context_t));
234 }
235 /*% Increments the serial number and returns the previous value. */
236 lwres_uint32_t
lwres_context_nextserial(lwres_context_t * ctx)237 lwres_context_nextserial(lwres_context_t *ctx) {
238 REQUIRE(ctx != NULL);
239
240 return (ctx->serial++);
241 }
242
243 /*% Sets the serial number for context *ctx to serial. */
244 void
lwres_context_initserial(lwres_context_t * ctx,lwres_uint32_t serial)245 lwres_context_initserial(lwres_context_t *ctx, lwres_uint32_t serial) {
246 REQUIRE(ctx != NULL);
247
248 ctx->serial = serial;
249 }
250
251 /*% Frees len bytes of space starting at location mem. */
252 void
lwres_context_freemem(lwres_context_t * ctx,void * mem,size_t len)253 lwres_context_freemem(lwres_context_t *ctx, void *mem, size_t len) {
254 REQUIRE(mem != NULL);
255 REQUIRE(len != 0U);
256
257 CTXFREE(mem, len);
258 }
259
260 /*% Allocates len bytes of memory and if successful returns a pointer to the allocated storage. */
261 void *
lwres_context_allocmem(lwres_context_t * ctx,size_t len)262 lwres_context_allocmem(lwres_context_t *ctx, size_t len) {
263 REQUIRE(len != 0U);
264
265 return (CTXMALLOC(len));
266 }
267
268 static void *
lwres_malloc(void * arg,size_t len)269 lwres_malloc(void *arg, size_t len) {
270 void *mem;
271
272 UNUSED(arg);
273
274 mem = malloc(len);
275 if (mem == NULL)
276 return (NULL);
277
278 memset(mem, 0xe5, len);
279
280 return (mem);
281 }
282
283 static void
lwres_free(void * arg,void * mem,size_t len)284 lwres_free(void *arg, void *mem, size_t len) {
285 UNUSED(arg);
286
287 memset(mem, 0xa9, len);
288 free(mem);
289 }
290
291 static lwres_result_t
context_connect(lwres_context_t * ctx)292 context_connect(lwres_context_t *ctx) {
293 #ifndef WIN32
294 int s;
295 #else
296 SOCKET s;
297 #endif
298 int ret;
299 struct sockaddr_in sin;
300 struct sockaddr_in6 sin6;
301 struct sockaddr *sa;
302 LWRES_SOCKADDR_LEN_T salen;
303 int domain;
304
305 if (ctx->confdata.lwnext != 0) {
306 memmove(&ctx->address, &ctx->confdata.lwservers[0],
307 sizeof(lwres_addr_t));
308 LWRES_LINK_INIT(&ctx->address, link);
309 } else {
310 /* The default is the IPv4 loopback address 127.0.0.1. */
311 memset(&ctx->address, 0, sizeof(ctx->address));
312 ctx->address.family = LWRES_ADDRTYPE_V4;
313 ctx->address.length = 4;
314 ctx->address.address[0] = 127;
315 ctx->address.address[1] = 0;
316 ctx->address.address[2] = 0;
317 ctx->address.address[3] = 1;
318 }
319
320 if (ctx->address.family == LWRES_ADDRTYPE_V4) {
321 memmove(&sin.sin_addr, ctx->address.address,
322 sizeof(sin.sin_addr));
323 sin.sin_port = htons(lwres_udp_port);
324 sin.sin_family = AF_INET;
325 sa = (struct sockaddr *)&sin;
326 salen = sizeof(sin);
327 domain = PF_INET;
328 } else if (ctx->address.family == LWRES_ADDRTYPE_V6) {
329 memmove(&sin6.sin6_addr, ctx->address.address,
330 sizeof(sin6.sin6_addr));
331 sin6.sin6_port = htons(lwres_udp_port);
332 sin6.sin6_family = AF_INET6;
333 sa = (struct sockaddr *)&sin6;
334 salen = sizeof(sin6);
335 domain = PF_INET6;
336 } else
337 return (LWRES_R_IOERROR);
338
339 #ifdef WIN32
340 InitSockets();
341 #endif
342 s = socket(domain, SOCK_DGRAM, IPPROTO_UDP);
343 #ifndef WIN32
344 if (s < 0) {
345 return (LWRES_R_IOERROR);
346 }
347 #else
348 if (s == INVALID_SOCKET) {
349 DestroySockets();
350 return (LWRES_R_IOERROR);
351 }
352 #endif
353
354 ret = connect(s, sa, salen);
355 if (ret != 0) {
356 #ifdef WIN32
357 DestroySockets();
358 #endif
359 (void)close(s);
360 return (LWRES_R_IOERROR);
361 }
362
363 MAKE_NONBLOCKING(s, ret);
364 if (ret < 0) {
365 #ifdef WIN32
366 DestroySockets();
367 #endif
368 (void)close(s);
369 return (LWRES_R_IOERROR);
370 }
371
372 ctx->sock = (int)s;
373
374 return (LWRES_R_SUCCESS);
375 }
376
377 int
lwres_context_getsocket(lwres_context_t * ctx)378 lwres_context_getsocket(lwres_context_t *ctx) {
379 return (ctx->sock);
380 }
381
382 lwres_result_t
lwres_context_send(lwres_context_t * ctx,void * sendbase,int sendlen)383 lwres_context_send(lwres_context_t *ctx,
384 void *sendbase, int sendlen) {
385 int ret;
386 lwres_result_t lwresult;
387
388 if (ctx->sock == -1) {
389 lwresult = context_connect(ctx);
390 if (lwresult != LWRES_R_SUCCESS)
391 return (lwresult);
392 INSIST(ctx->sock >= 0);
393 }
394
395 ret = sendto(ctx->sock, sendbase, sendlen, 0, NULL, 0);
396 if (ret < 0)
397 return (LWRES_R_IOERROR);
398 if (ret != sendlen)
399 return (LWRES_R_IOERROR);
400
401 return (LWRES_R_SUCCESS);
402 }
403
404 lwres_result_t
lwres_context_recv(lwres_context_t * ctx,void * recvbase,int recvlen,int * recvd_len)405 lwres_context_recv(lwres_context_t *ctx,
406 void *recvbase, int recvlen,
407 int *recvd_len)
408 {
409 LWRES_SOCKADDR_LEN_T fromlen;
410 struct sockaddr_in sin;
411 struct sockaddr_in6 sin6;
412 struct sockaddr *sa;
413 int ret;
414
415 if (ctx->address.family == LWRES_ADDRTYPE_V4) {
416 sa = (struct sockaddr *)&sin;
417 fromlen = sizeof(sin);
418 } else {
419 sa = (struct sockaddr *)&sin6;
420 fromlen = sizeof(sin6);
421 }
422
423 /*
424 * The address of fromlen is cast to void * to shut up compiler
425 * warnings, namely on systems that have the sixth parameter
426 * prototyped as a signed int when LWRES_SOCKADDR_LEN_T is
427 * defined as unsigned.
428 */
429 ret = recvfrom(ctx->sock, recvbase, recvlen, 0, sa, (void *)&fromlen);
430
431 if (ret < 0)
432 return (LWRES_R_IOERROR);
433
434 if (ret == recvlen)
435 return (LWRES_R_TOOLARGE);
436
437 /*
438 * If we got something other than what we expect, have the caller
439 * wait for another packet. This can happen if an old result
440 * comes in, or if someone is sending us random stuff.
441 */
442 if (ctx->address.family == LWRES_ADDRTYPE_V4) {
443 if (fromlen != sizeof(sin)
444 || memcmp(&sin.sin_addr, ctx->address.address,
445 sizeof(sin.sin_addr)) != 0
446 || sin.sin_port != htons(lwres_udp_port))
447 return (LWRES_R_RETRY);
448 } else {
449 if (fromlen != sizeof(sin6)
450 || memcmp(&sin6.sin6_addr, ctx->address.address,
451 sizeof(sin6.sin6_addr)) != 0
452 || sin6.sin6_port != htons(lwres_udp_port))
453 return (LWRES_R_RETRY);
454 }
455
456 if (recvd_len != NULL)
457 *recvd_len = ret;
458
459 return (LWRES_R_SUCCESS);
460 }
461
462 /*% performs I/O for the context ctx. */
463 lwres_result_t
lwres_context_sendrecv(lwres_context_t * ctx,void * sendbase,int sendlen,void * recvbase,int recvlen,int * recvd_len)464 lwres_context_sendrecv(lwres_context_t *ctx,
465 void *sendbase, int sendlen,
466 void *recvbase, int recvlen,
467 int *recvd_len)
468 {
469 lwres_result_t result;
470 int ret2;
471 fd_set readfds;
472 struct timeval timeout;
473
474 /*
475 * Type of tv_sec is 32 bits long.
476 */
477 if (ctx->timeout <= 0x7FFFFFFFU)
478 timeout.tv_sec = (int)ctx->timeout;
479 else
480 timeout.tv_sec = 0x7FFFFFFF;
481
482 timeout.tv_usec = 0;
483
484 result = lwres_context_send(ctx, sendbase, sendlen);
485 if (result != LWRES_R_SUCCESS)
486 return (result);
487
488 /*
489 * If this is not checked, select() can overflow,
490 * causing corruption elsewhere.
491 */
492 if (ctx->sock >= (int)FD_SETSIZE) {
493 close(ctx->sock);
494 ctx->sock = -1;
495 return (LWRES_R_IOERROR);
496 }
497
498 again:
499 FD_ZERO(&readfds);
500 FD_SET(ctx->sock, &readfds);
501 ret2 = select(ctx->sock + 1, &readfds, NULL, NULL, &timeout);
502
503 /*
504 * What happened with select?
505 */
506 if (ret2 < 0)
507 return (LWRES_R_IOERROR);
508 if (ret2 == 0)
509 return (LWRES_R_TIMEOUT);
510
511 result = lwres_context_recv(ctx, recvbase, recvlen, recvd_len);
512 if (result == LWRES_R_RETRY)
513 goto again;
514
515 return (result);
516 }
517