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