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) \ 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#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/*% 211Destroys a #lwres_context_t, closing its socket. 212contextp is a pointer to a pointer to the context that is 213to be destroyed. The pointer will be set to NULL 214when the context has been destroyed. 215 */ 216void 217lwres_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. */ 236lwres_uint32_t 237lwres_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. */ 244void 245lwres_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. */ 252void 253lwres_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. */ 261void * 262lwres_context_allocmem(lwres_context_t *ctx, size_t len) { 263 REQUIRE(len != 0U); 264 265 return (CTXMALLOC(len)); 266} 267 268static void * 269lwres_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 283static void 284lwres_free(void *arg, void *mem, size_t len) { 285 UNUSED(arg); 286 287 memset(mem, 0xa9, len); 288 free(mem); 289} 290 291static lwres_result_t 292context_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 377int 378lwres_context_getsocket(lwres_context_t *ctx) { 379 return (ctx->sock); 380} 381 382lwres_result_t 383lwres_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 404lwres_result_t 405lwres_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. */ 463lwres_result_t 464lwres_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