diff options
Diffstat (limited to 'resolv/resolv_context.h')
| -rw-r--r-- | resolv/resolv_context.h | 182 |
1 files changed, 182 insertions, 0 deletions
diff --git a/resolv/resolv_context.h b/resolv/resolv_context.h new file mode 100644 index 0000000000..c1dff76cb9 --- /dev/null +++ b/resolv/resolv_context.h @@ -0,0 +1,182 @@ +/* Temporary, thread-local resolver state. + Copyright (C) 2017-2018 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + <http://www.gnu.org/licenses/>. */ + +/* struct resolv_context objects are allocated on the heap, + initialized by __resolv_context_get (and its variants), and + destroyed by __resolv_context_put. + + A nested call to __resolv_context_get (after another call to + __resolv_context_get without a matching __resolv_context_put call, + on the same thread) returns the original pointer, instead of + allocating a new context. This prevents unexpected reloading of + the resolver configuration. Care is taken to keep the context in + sync with the thread-local _res object. (This does not happen with + __resolv_context_get_override, and __resolv_context_get_no_inet6 may + also interpose another context object if RES_USE_INET6 needs to be + disabled.) + + In contrast to struct __res_state, struct resolv_context is not + affected by ABI compatibility concerns. + + For the benefit of the res_n* functions, a struct __res_state + pointer is included in the context object, and a separate + initialization function is provided. */ + +#ifndef _RESOLV_CONTEXT_H +#define _RESOLV_CONTEXT_H + +#include <bits/types/res_state.h> +#include <resolv/resolv_conf.h> +#include <stdbool.h> +#include <stddef.h> + +/* Temporary resolver state. */ +struct resolv_context +{ + struct __res_state *resp; /* Backing resolver state. */ + + /* Extended resolver state. This is set to NULL if the + __resolv_context_get functions are unable to locate an associated + extended state. In this case, the configuration data in *resp + has to be used; otherwise, the data from *conf should be + preferred (because it is a superset). */ + struct resolv_conf *conf; + + /* The following fields are for internal use within the + resolv_context module. */ + size_t __refcount; /* Count of reusages by the get functions. */ + bool __from_res; /* True if created from _res. */ + + /* If RES_USE_INET6 was disabled at this level, this field points to + the previous context. */ + struct resolv_context *__next; +}; + +/* Return the current temporary resolver context, or NULL if there was + an error (indicated by errno). A call to this function must be + paired with a call to __resolv_context_put. */ +struct resolv_context *__resolv_context_get (void) + __attribute__ ((warn_unused_result)); +libc_hidden_proto (__resolv_context_get) + +/* Deallocate the temporary resolver context. Converse of + __resolv_context_get. Restore the RES_USE_INET6 flag if necessary. + Do nothing if CTX is NULL. */ +void __resolv_context_put (struct resolv_context *ctx); +libc_hidden_proto (__resolv_context_put) + +/* Like __resolv_context_get, but the _res structure can be partially + initialzed and those changes will not be overwritten. */ +struct resolv_context *__resolv_context_get_preinit (void) + __attribute__ ((warn_unused_result)); +libc_hidden_proto (__resolv_context_get_preinit) + +/* Wrap a struct __res_state object in a struct resolv_context object. + A call to this function must be paired with a call to + __resolv_context_put. */ +struct resolv_context *__resolv_context_get_override (struct __res_state *) + __attribute__ ((nonnull (1), warn_unused_result)); +libc_hidden_proto (__resolv_context_get_override) + +/* Return the search path entry at INDEX, or NULL if there are fewer + than INDEX entries. */ +static __attribute__ ((nonnull (1), unused)) const char * +__resolv_context_search_list (const struct resolv_context *ctx, size_t index) +{ + if (ctx->conf != NULL) + { + if (index < ctx->conf->search_list_size) + return ctx->conf->search_list[index]; + else + return NULL; + } + /* Fallback. ctx->resp->dnsrch is a NULL-terminated array. */ + for (size_t i = 0; ctx->resp->dnsrch[i] != NULL && i < MAXDNSRCH; ++i) + if (i == index) + return ctx->resp->dnsrch[i]; + return NULL; +} + +/* Return the number of name servers. */ +static __attribute__ ((nonnull (1), unused)) size_t +__resolv_context_nameserver_count (const struct resolv_context *ctx) +{ + if (ctx->conf != NULL) + return ctx->conf->nameserver_list_size; + else + return ctx->resp->nscount; +} + +/* Return a pointer to the socket address of the name server INDEX, or + NULL if the index is out of bounds. */ +static __attribute__ ((nonnull (1), unused)) const struct sockaddr * +__resolv_context_nameserver (const struct resolv_context *ctx, size_t index) +{ + if (ctx->conf != NULL) + { + if (index < ctx->conf->nameserver_list_size) + return ctx->conf->nameserver_list[index]; + } + else + if (index < ctx->resp->nscount) + { + if (ctx->resp->nsaddr_list[index].sin_family != 0) + return (const struct sockaddr *) &ctx->resp->nsaddr_list[index]; + else + return (const struct sockaddr *) &ctx->resp->_u._ext.nsaddrs[index]; + } + return NULL; +} + +/* Return the number of sort list entries. */ +static __attribute__ ((nonnull (1), unused)) size_t +__resolv_context_sort_count (const struct resolv_context *ctx) +{ + if (ctx->conf != NULL) + return ctx->conf->sort_list_size; + else + return ctx->resp->nsort; +} + +/* Return the sort list entry at INDEX. */ +static __attribute__ ((nonnull (1), unused)) struct resolv_sortlist_entry +__resolv_context_sort_entry (const struct resolv_context *ctx, size_t index) +{ + if (ctx->conf != NULL) + { + if (index < ctx->conf->sort_list_size) + return ctx->conf->sort_list[index]; + /* Fall through. */ + } + else if (index < ctx->resp->nsort) + return (struct resolv_sortlist_entry) + { + .addr = ctx->resp->sort_list[index].addr, + .mask = ctx->resp->sort_list[index].mask, + }; + + return (struct resolv_sortlist_entry) { .mask = 0, }; +} + +/* Called during thread shutdown to free the associated resolver + context (mostly in response to cancellation, otherwise the + __resolv_context_get/__resolv_context_put pairing will already have + deallocated the context object). */ +void __resolv_context_freeres (void) attribute_hidden; + +#endif /* _RESOLV_CONTEXT_H */ |