PageRenderTime 57ms CodeModel.GetById 14ms app.highlight 38ms RepoModel.GetById 1ms app.codeStats 0ms

/contrib/bind9/lib/lwres/context.c

https://bitbucket.org/freebsd/freebsd-head/
C | 503 lines | 290 code | 70 blank | 143 comment | 79 complexity | a8ae65d17a81b8878a6f9469c1e443b9 MD5 | raw file
  1/*
  2 * Copyright (C) 2004, 2005, 2007-2009  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) \
122do { \
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
131LIBLWRES_EXTERNAL_DATA lwres_uint16_t lwres_udp_port = LWRES_UDP_PORT;
132LIBLWRES_EXTERNAL_DATA const char *lwres_resolv_conf = LWRES_RESOLV_CONF;
133
134static void *
135lwres_malloc(void *, size_t);
136
137static void
138lwres_free(void *, void *, size_t);
139
140/*!
141 * lwres_result_t
142 */
143static lwres_result_t
144context_connect(lwres_context_t *);
145
146/*%
147 * Creates a #lwres_context_t structure for use in
148 *  lightweight resolver operations.
149 */
150lwres_result_t
151lwres_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	ctx->serial = time(NULL); /* XXXMLG or BEW */
185
186	ctx->use_ipv4 = 1;
187	ctx->use_ipv6 = 1;
188	if ((flags & (LWRES_CONTEXT_USEIPV4 | LWRES_CONTEXT_USEIPV6)) ==
189	    LWRES_CONTEXT_USEIPV6) {
190		ctx->use_ipv4 = 0;
191	}
192	if ((flags & (LWRES_CONTEXT_USEIPV4 | LWRES_CONTEXT_USEIPV6)) ==
193	    LWRES_CONTEXT_USEIPV4) {
194		ctx->use_ipv6 = 0;
195	}
196
197	/*
198	 * Init resolv.conf bits.
199	 */
200	lwres_conf_init(ctx);
201
202	*contextp = ctx;
203	return (LWRES_R_SUCCESS);
204}
205
206/*%
207Destroys a #lwres_context_t, closing its socket.
208contextp is a pointer to a pointer to the context that is
209to be destroyed. The pointer will be set to NULL
210when the context has been destroyed.
211 */
212void
213lwres_context_destroy(lwres_context_t **contextp) {
214	lwres_context_t *ctx;
215
216	REQUIRE(contextp != NULL && *contextp != NULL);
217
218	ctx = *contextp;
219	*contextp = NULL;
220
221	if (ctx->sock != -1) {
222#ifdef WIN32
223		DestroySockets();
224#endif
225		(void)close(ctx->sock);
226		ctx->sock = -1;
227	}
228
229	CTXFREE(ctx, sizeof(lwres_context_t));
230}
231/*% Increments the serial number and returns the previous value. */
232lwres_uint32_t
233lwres_context_nextserial(lwres_context_t *ctx) {
234	REQUIRE(ctx != NULL);
235
236	return (ctx->serial++);
237}
238
239/*% Sets the serial number for context *ctx to serial. */
240void
241lwres_context_initserial(lwres_context_t *ctx, lwres_uint32_t serial) {
242	REQUIRE(ctx != NULL);
243
244	ctx->serial = serial;
245}
246
247/*% Frees len bytes of space starting at location mem. */
248void
249lwres_context_freemem(lwres_context_t *ctx, void *mem, size_t len) {
250	REQUIRE(mem != NULL);
251	REQUIRE(len != 0U);
252
253	CTXFREE(mem, len);
254}
255
256/*% Allocates len bytes of memory and if successful returns a pointer to the allocated storage. */
257void *
258lwres_context_allocmem(lwres_context_t *ctx, size_t len) {
259	REQUIRE(len != 0U);
260
261	return (CTXMALLOC(len));
262}
263
264static void *
265lwres_malloc(void *arg, size_t len) {
266	void *mem;
267
268	UNUSED(arg);
269
270	mem = malloc(len);
271	if (mem == NULL)
272		return (NULL);
273
274	memset(mem, 0xe5, len);
275
276	return (mem);
277}
278
279static void
280lwres_free(void *arg, void *mem, size_t len) {
281	UNUSED(arg);
282
283	memset(mem, 0xa9, len);
284	free(mem);
285}
286
287static lwres_result_t
288context_connect(lwres_context_t *ctx) {
289	int s;
290	int ret;
291	struct sockaddr_in sin;
292	struct sockaddr_in6 sin6;
293	struct sockaddr *sa;
294	LWRES_SOCKADDR_LEN_T salen;
295	int domain;
296
297	if (ctx->confdata.lwnext != 0) {
298		memcpy(&ctx->address, &ctx->confdata.lwservers[0],
299		       sizeof(lwres_addr_t));
300		LWRES_LINK_INIT(&ctx->address, link);
301	} else {
302		/* The default is the IPv4 loopback address 127.0.0.1. */
303		memset(&ctx->address, 0, sizeof(ctx->address));
304		ctx->address.family = LWRES_ADDRTYPE_V4;
305		ctx->address.length = 4;
306		ctx->address.address[0] = 127;
307		ctx->address.address[1] = 0;
308		ctx->address.address[2] = 0;
309		ctx->address.address[3] = 1;
310	}
311
312	if (ctx->address.family == LWRES_ADDRTYPE_V4) {
313		memcpy(&sin.sin_addr, ctx->address.address,
314		       sizeof(sin.sin_addr));
315		sin.sin_port = htons(lwres_udp_port);
316		sin.sin_family = AF_INET;
317		sa = (struct sockaddr *)&sin;
318		salen = sizeof(sin);
319		domain = PF_INET;
320	} else if (ctx->address.family == LWRES_ADDRTYPE_V6) {
321		memcpy(&sin6.sin6_addr, ctx->address.address,
322		       sizeof(sin6.sin6_addr));
323		sin6.sin6_port = htons(lwres_udp_port);
324		sin6.sin6_family = AF_INET6;
325		sa = (struct sockaddr *)&sin6;
326		salen = sizeof(sin6);
327		domain = PF_INET6;
328	} else
329		return (LWRES_R_IOERROR);
330
331#ifdef WIN32
332	InitSockets();
333#endif
334	s = socket(domain, SOCK_DGRAM, IPPROTO_UDP);
335	if (s < 0) {
336#ifdef WIN32
337		DestroySockets();
338#endif
339		return (LWRES_R_IOERROR);
340	}
341
342	ret = connect(s, sa, salen);
343	if (ret != 0) {
344#ifdef WIN32
345		DestroySockets();
346#endif
347		(void)close(s);
348		return (LWRES_R_IOERROR);
349	}
350
351	MAKE_NONBLOCKING(s, ret);
352	if (ret < 0) {
353#ifdef WIN32
354		DestroySockets();
355#endif
356		(void)close(s);
357		return (LWRES_R_IOERROR);
358	}
359
360	ctx->sock = s;
361
362	return (LWRES_R_SUCCESS);
363}
364
365int
366lwres_context_getsocket(lwres_context_t *ctx) {
367	return (ctx->sock);
368}
369
370lwres_result_t
371lwres_context_send(lwres_context_t *ctx,
372		   void *sendbase, int sendlen) {
373	int ret;
374	lwres_result_t lwresult;
375
376	if (ctx->sock == -1) {
377		lwresult = context_connect(ctx);
378		if (lwresult != LWRES_R_SUCCESS)
379			return (lwresult);
380	}
381
382	ret = sendto(ctx->sock, sendbase, sendlen, 0, NULL, 0);
383	if (ret < 0)
384		return (LWRES_R_IOERROR);
385	if (ret != sendlen)
386		return (LWRES_R_IOERROR);
387
388	return (LWRES_R_SUCCESS);
389}
390
391lwres_result_t
392lwres_context_recv(lwres_context_t *ctx,
393		   void *recvbase, int recvlen,
394		   int *recvd_len)
395{
396	LWRES_SOCKADDR_LEN_T fromlen;
397	struct sockaddr_in sin;
398	struct sockaddr_in6 sin6;
399	struct sockaddr *sa;
400	int ret;
401
402	if (ctx->address.family == LWRES_ADDRTYPE_V4) {
403		sa = (struct sockaddr *)&sin;
404		fromlen = sizeof(sin);
405	} else {
406		sa = (struct sockaddr *)&sin6;
407		fromlen = sizeof(sin6);
408	}
409
410	/*
411	 * The address of fromlen is cast to void * to shut up compiler
412	 * warnings, namely on systems that have the sixth parameter
413	 * prototyped as a signed int when LWRES_SOCKADDR_LEN_T is
414	 * defined as unsigned.
415	 */
416	ret = recvfrom(ctx->sock, recvbase, recvlen, 0, sa, (void *)&fromlen);
417
418	if (ret < 0)
419		return (LWRES_R_IOERROR);
420
421	if (ret == recvlen)
422		return (LWRES_R_TOOLARGE);
423
424	/*
425	 * If we got something other than what we expect, have the caller
426	 * wait for another packet.  This can happen if an old result
427	 * comes in, or if someone is sending us random stuff.
428	 */
429	if (ctx->address.family == LWRES_ADDRTYPE_V4) {
430		if (fromlen != sizeof(sin)
431		    || memcmp(&sin.sin_addr, ctx->address.address,
432			      sizeof(sin.sin_addr)) != 0
433		    || sin.sin_port != htons(lwres_udp_port))
434			return (LWRES_R_RETRY);
435	} else {
436		if (fromlen != sizeof(sin6)
437		    || memcmp(&sin6.sin6_addr, ctx->address.address,
438			      sizeof(sin6.sin6_addr)) != 0
439		    || sin6.sin6_port != htons(lwres_udp_port))
440			return (LWRES_R_RETRY);
441	}
442
443	if (recvd_len != NULL)
444		*recvd_len = ret;
445
446	return (LWRES_R_SUCCESS);
447}
448
449/*% performs I/O for the context ctx. */
450lwres_result_t
451lwres_context_sendrecv(lwres_context_t *ctx,
452		       void *sendbase, int sendlen,
453		       void *recvbase, int recvlen,
454		       int *recvd_len)
455{
456	lwres_result_t result;
457	int ret2;
458	fd_set readfds;
459	struct timeval timeout;
460
461	/*
462	 * Type of tv_sec is 32 bits long.
463	 */
464	if (ctx->timeout <= 0x7FFFFFFFU)
465		timeout.tv_sec = (int)ctx->timeout;
466	else
467		timeout.tv_sec = 0x7FFFFFFF;
468
469	timeout.tv_usec = 0;
470
471	result = lwres_context_send(ctx, sendbase, sendlen);
472	if (result != LWRES_R_SUCCESS)
473		return (result);
474
475	/*
476	 * If this is not checked, select() can overflow,
477	 * causing corruption elsewhere.
478	 */
479	if (ctx->sock >= (int)FD_SETSIZE) {
480		close(ctx->sock);
481		ctx->sock = -1;
482		return (LWRES_R_IOERROR);
483	}
484
485 again:
486	FD_ZERO(&readfds);
487	FD_SET(ctx->sock, &readfds);
488	ret2 = select(ctx->sock + 1, &readfds, NULL, NULL, &timeout);
489
490	/*
491	 * What happened with select?
492	 */
493	if (ret2 < 0)
494		return (LWRES_R_IOERROR);
495	if (ret2 == 0)
496		return (LWRES_R_TIMEOUT);
497
498	result = lwres_context_recv(ctx, recvbase, recvlen, recvd_len);
499	if (result == LWRES_R_RETRY)
500		goto again;
501
502	return (result);
503}