contrib/bind9/lib/lwres/context.c

   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
 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
 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
 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
 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
 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 *
 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 *
 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
 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
 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
 378 lwres_context_getsocket(lwres_context_t *ctx) {
 379         return (ctx->sock);
 380 }
 381
 382 lwres_result_t
 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
 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
 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 }