mir/bind
2
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/bind9 synced 2025-08-23 18:49:54 +00:00
Code Issues Releases Wiki Activity
bind/lib/dns/request.c

1241 lines
31 KiB
C
Raw Normal View History

checkpoint
2000-02-24 14:31:43 +00:00
/*
Update license headers to not include years in copyright in all applicable files
2018-02-23 09:53:12 +01:00
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
Trailing whitespace trimmed. Perhaps running "perl util/spacewhack.pl in your own CVS tree will help minimize CVS conflicts. Maybe not. Blame Graff for getting me to trim all trailing whitespace.
2000-08-01 01:33:37 +00:00
*
4401. [misc] Change LICENSE to MPL 2.0.
2016-06-27 14:56:38 +10:00
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
update all copyright headers to eliminate the typo
2020-09-14 16:20:40 -07:00
* file, you can obtain one at https://mozilla.org/MPL/2.0/.
Update license headers to not include years in copyright in all applicable files
2018-02-23 09:53:12 +01:00
*
* See the COPYRIGHT file distributed with this work for additional
* information regarding copyright ownership.
checkpoint
2000-02-24 14:31:43 +00:00
*/
1851. [doc] Doxygen comment markup. [RT #11398]
2005-04-27 04:57:32 +00:00
/*! \file */
add RCS id string
2000-06-22 22:00:42 +00:00
Replace custom isc_u?intNN_t types with C99 u?intNN_t types
2018-03-28 14:19:37 +02:00
#include <inttypes.h>
Replace custom isc_boolean_t with C standard bool type
2018-04-17 08:29:14 -07:00
#include <stdbool.h>
Replace custom isc_u?intNN_t types with C99 u?intNN_t types
2018-03-28 14:19:37 +02:00
use ISC_MAGIC for all magic numbers, for our friends in EBCDIC land
2001-06-04 19:33:39 +00:00
#include <isc/magic.h>
Megacommit of dozens of files. Cleanup of redundant/useless header file inclusion. ISC style lint, primarily for function declarations and standalone comments -- ie, those that appear on a line without any code, which should be written as follows: /* * This is a comment. */
2000-05-08 14:38:29 +00:00
#include <isc/mem.h>
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
#include <isc/netmgr.h>
checkpoint
2000-03-13 20:43:39 +00:00
#include <isc/task.h>
#include <isc/util.h>
539. [func] Support the blackhole option.
2000-11-03 02:45:55 +00:00
#include <dns/acl.h>
move compression context create/delete into the caller of the message rendering functions. This reduces the size of the message object.
2001-03-05 21:15:47 +00:00
#include <dns/compress.h>
checkpoint
2000-03-13 20:43:39 +00:00
#include <dns/dispatch.h>
#include <dns/events.h>
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
#include <dns/log.h>
checkpoint
2000-03-13 20:43:39 +00:00
#include <dns/message.h>
notify and zone soa queries are now tsig signed when appropriate.
2000-05-24 17:30:41 +00:00
#include <dns/rdata.h>
#include <dns/rdatastruct.h>
checkpoint
2000-02-24 14:31:43 +00:00
#include <dns/request.h>
Redundant header work, mostly removing <dns/result.h> from installed headers and adding it to source files that need it.
2000-05-02 03:54:17 +00:00
#include <dns/result.h>
notify and zone soa queries are now tsig signed when appropriate.
2000-05-24 17:30:41 +00:00
#include <dns/tsig.h>
checkpoint
2000-02-24 14:31:43 +00:00
apply the modified style
2020-02-13 14:44:37 -08:00
#define REQUESTMGR_MAGIC ISC_MAGIC('R', 'q', 'u', 'M')
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
#define VALID_REQUESTMGR(mgr) ISC_MAGIC_VALID(mgr, REQUESTMGR_MAGIC)
checkpoint
2000-02-24 14:31:43 +00:00
apply the modified style
2020-02-13 14:44:37 -08:00
#define REQUEST_MAGIC ISC_MAGIC('R', 'q', 'u', '!')
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
#define VALID_REQUEST(request) ISC_MAGIC_VALID(request, REQUEST_MAGIC)
checkpoint
2000-02-24 14:31:43 +00:00
checkpoint
2000-03-20 12:22:02 +00:00
typedef ISC_LIST(dns_request_t) dns_requestlist_t;
add request locking. dns_request_create() failed to detach from requestmgr under certain conditions.
2000-03-22 07:00:39 +00:00
#define DNS_REQUEST_NLOCKS 7
checkpoint
2000-02-24 14:31:43 +00:00
struct dns_requestmgr {
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
unsigned int magic;
apply the modified style
2020-02-13 14:44:37 -08:00
isc_mutex_t lock;
isc_mem_t *mctx;
checkpoint
2000-02-24 14:31:43 +00:00
/* locked */
apply the modified style
2020-02-13 14:44:37 -08:00
int32_t eref;
int32_t iref;
isc_taskmgr_t *taskmgr;
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
dns_dispatchmgr_t *dispatchmgr;
apply the modified style
2020-02-13 14:44:37 -08:00
dns_dispatch_t *dispatchv4;
dns_dispatch_t *dispatchv6;
bool exiting;
isc_eventlist_t whenshutdown;
unsigned int hash;
isc_mutex_t locks[DNS_REQUEST_NLOCKS];
dns_requestlist_t requests;
checkpoint
2000-02-24 14:31:43 +00:00
};
struct dns_request {
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
unsigned int magic;
unsigned int hash;
apply the modified style
2020-02-13 14:44:37 -08:00
isc_mem_t *mctx;
int32_t flags;
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
ISC_LINK(dns_request_t) link;
apply the modified style
2020-02-13 14:44:37 -08:00
isc_buffer_t *query;
isc_buffer_t *answer;
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
dns_requestevent_t *event;
apply the modified style
2020-02-13 14:44:37 -08:00
dns_dispatch_t *dispatch;
dns_dispentry_t *dispentry;
dns_requestmgr_t *requestmgr;
isc_buffer_t *tsig;
dns_tsigkey_t *tsigkey;
Move isc_socket_sendto2() calls into dispatch We now use dns_dispatch_send() for this purpose.
2021-01-04 23:03:50 -08:00
isc_socketevent_t sendevent;
apply the modified style
2020-02-13 14:44:37 -08:00
isc_sockaddr_t destaddr;
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
unsigned int timeout;
apply the modified style
2020-02-13 14:44:37 -08:00
unsigned int udpcount;
isc_dscp_t dscp;
checkpoint
2000-03-13 20:43:39 +00:00
};
checkpoint
2000-02-24 14:31:43 +00:00
checkpoint
2000-03-20 12:22:02 +00:00
#define DNS_REQUEST_F_CONNECTING 0x0001
apply the modified style
2020-02-13 14:44:37 -08:00
#define DNS_REQUEST_F_SENDING 0x0002
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
#define DNS_REQUEST_F_CANCELED 0x0004
#define DNS_REQUEST_F_TCP 0x0010
apply the modified style
2020-02-13 14:44:37 -08:00
#define DNS_REQUEST_CANCELED(r) (((r)->flags & DNS_REQUEST_F_CANCELED) != 0)
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
#define DNS_REQUEST_CONNECTING(r) (((r)->flags & DNS_REQUEST_F_CONNECTING) != 0)
apply the modified style
2020-02-13 14:44:37 -08:00
#define DNS_REQUEST_SENDING(r) (((r)->flags & DNS_REQUEST_F_SENDING) != 0)
checkpoint
2000-03-20 12:22:02 +00:00
checkpoint
2000-02-24 14:31:43 +00:00
/***
*** Forward
***/
Reformat using the new rules
2020-02-14 08:14:03 +01:00
static void
mgr_destroy(dns_requestmgr_t *requestmgr);
static void
mgr_shutdown(dns_requestmgr_t *requestmgr);
static unsigned int
mgr_gethash(dns_requestmgr_t *requestmgr);
static void
send_shutdown_events(dns_requestmgr_t *requestmgr);
static isc_result_t
req_render(dns_message_t *message, isc_buffer_t **buffer, unsigned int options,
isc_mem_t *mctx);
static void
req_response(isc_task_t *task, isc_event_t *event);
static void
Convert dispatch to netmgr The flow of operations in dispatch is changing and will now be similar for both UDP and TCP queries: 1) Call dns_dispatch_addresponse() to assign a query ID and register that we'll be listening for a response with that ID soon. the parameters for this function include callback functions to inform the caller when the socket is connected and when the message has been sent, as well as a task action that will be sent when the response arrives. (later this could become a netmgr callback, but at this stage to minimize disruption to the calling code, we continue to use isc_task for the response event.) on successful completion of this function, a dispatch entry object will be instantiated. 2) Call dns_dispatch_connect() on the dispatch entry. this runs isc_nm_udpconnect() or isc_nm_tcpdnsconnect(), as needed, and begins listening for responses. the caller is informed via a callback function when the connection is established. 3) Call dns_dispatch_send() on the dispatch entry. this runs isc_nm_send() to send a request. 4) Call dns_dispatch_removeresponse() to terminate listening and close the connection. Implementation comments below: - As we will be using netmgr buffers now. code to send the length in TCP queries has also been removed as that is handled by the netmgr. - TCP dispatches can be used by multiple simultaneous queries, so dns_dispatch_connect() now checks whether the dispatch is already connected before calling isc_nm_tcpdnsconnect() again. - Running dns_dispatch_getnext() from a non-network thread caused a crash due to assertions in the netmgr read functions that appear to be unnecessary now. the assertions have been removed. - fctx->nqueries was formerly incremented when the connection was successful, but is now incremented when the query is started and decremented if the connection fails. - It's no longer necessary for each dispatch to have a pool of tasks, so there's now a single task per dispatch. - Dispatch code to avoid UDP ports already in use has been removed. - dns_resolver and dns_request have been modified to use netmgr callback functions instead of task events. some additional changes were needed to handle shutdown processing correctly. - Timeout processing is not yet fully converted to use netmgr timeouts. - Fixed a lock order cycle reported by TSAN (view -> zone-> adb -> view) by by calling dns_zt functions without holding the view lock.
2021-01-14 13:02:57 -08:00
req_senddone(isc_nmhandle_t *handle, isc_result_t eresult, void *arg);
Reformat using the new rules
2020-02-14 08:14:03 +01:00
static void
req_sendevent(dns_request_t *request, isc_result_t result);
static void
Convert dispatch to netmgr The flow of operations in dispatch is changing and will now be similar for both UDP and TCP queries: 1) Call dns_dispatch_addresponse() to assign a query ID and register that we'll be listening for a response with that ID soon. the parameters for this function include callback functions to inform the caller when the socket is connected and when the message has been sent, as well as a task action that will be sent when the response arrives. (later this could become a netmgr callback, but at this stage to minimize disruption to the calling code, we continue to use isc_task for the response event.) on successful completion of this function, a dispatch entry object will be instantiated. 2) Call dns_dispatch_connect() on the dispatch entry. this runs isc_nm_udpconnect() or isc_nm_tcpdnsconnect(), as needed, and begins listening for responses. the caller is informed via a callback function when the connection is established. 3) Call dns_dispatch_send() on the dispatch entry. this runs isc_nm_send() to send a request. 4) Call dns_dispatch_removeresponse() to terminate listening and close the connection. Implementation comments below: - As we will be using netmgr buffers now. code to send the length in TCP queries has also been removed as that is handled by the netmgr. - TCP dispatches can be used by multiple simultaneous queries, so dns_dispatch_connect() now checks whether the dispatch is already connected before calling isc_nm_tcpdnsconnect() again. - Running dns_dispatch_getnext() from a non-network thread caused a crash due to assertions in the netmgr read functions that appear to be unnecessary now. the assertions have been removed. - fctx->nqueries was formerly incremented when the connection was successful, but is now incremented when the query is started and decremented if the connection fails. - It's no longer necessary for each dispatch to have a pool of tasks, so there's now a single task per dispatch. - Dispatch code to avoid UDP ports already in use has been removed. - dns_resolver and dns_request have been modified to use netmgr callback functions instead of task events. some additional changes were needed to handle shutdown processing correctly. - Timeout processing is not yet fully converted to use netmgr timeouts. - Fixed a lock order cycle reported by TSAN (view -> zone-> adb -> view) by by calling dns_zt functions without holding the view lock.
2021-01-14 13:02:57 -08:00
req_connected(isc_nmhandle_t *handle, isc_result_t eresult, void *arg);
static void
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
req_timeout(isc_nmhandle_t *handle, isc_result_t eresult, void *arg);
Reformat using the new rules
2020-02-14 08:14:03 +01:00
static void
req_destroy(dns_request_t *request);
static void
req_log(int level, const char *fmt, ...) ISC_FORMAT_PRINTF(2, 3);
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
void
request_cancel(dns_request_t *request);
checkpoint
2000-02-24 14:31:43 +00:00
/***
*** Public
***/
isc_result_t
Convert dispatch to netmgr The flow of operations in dispatch is changing and will now be similar for both UDP and TCP queries: 1) Call dns_dispatch_addresponse() to assign a query ID and register that we'll be listening for a response with that ID soon. the parameters for this function include callback functions to inform the caller when the socket is connected and when the message has been sent, as well as a task action that will be sent when the response arrives. (later this could become a netmgr callback, but at this stage to minimize disruption to the calling code, we continue to use isc_task for the response event.) on successful completion of this function, a dispatch entry object will be instantiated. 2) Call dns_dispatch_connect() on the dispatch entry. this runs isc_nm_udpconnect() or isc_nm_tcpdnsconnect(), as needed, and begins listening for responses. the caller is informed via a callback function when the connection is established. 3) Call dns_dispatch_send() on the dispatch entry. this runs isc_nm_send() to send a request. 4) Call dns_dispatch_removeresponse() to terminate listening and close the connection. Implementation comments below: - As we will be using netmgr buffers now. code to send the length in TCP queries has also been removed as that is handled by the netmgr. - TCP dispatches can be used by multiple simultaneous queries, so dns_dispatch_connect() now checks whether the dispatch is already connected before calling isc_nm_tcpdnsconnect() again. - Running dns_dispatch_getnext() from a non-network thread caused a crash due to assertions in the netmgr read functions that appear to be unnecessary now. the assertions have been removed. - fctx->nqueries was formerly incremented when the connection was successful, but is now incremented when the query is started and decremented if the connection fails. - It's no longer necessary for each dispatch to have a pool of tasks, so there's now a single task per dispatch. - Dispatch code to avoid UDP ports already in use has been removed. - dns_resolver and dns_request have been modified to use netmgr callback functions instead of task events. some additional changes were needed to handle shutdown processing correctly. - Timeout processing is not yet fully converted to use netmgr timeouts. - Fixed a lock order cycle reported by TSAN (view -> zone-> adb -> view) by by calling dns_zt functions without holding the view lock.
2021-01-14 13:02:57 -08:00
dns_requestmgr_create(isc_mem_t *mctx, isc_taskmgr_t *taskmgr,
implement dns_dispatchmgr_t, replacing dns_dispatchlist_t. Use it throughout the library/server.
2000-05-10 21:34:50 +00:00
dns_dispatchmgr_t *dispatchmgr,
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
dns_dispatch_t *dispatchv4, dns_dispatch_t *dispatchv6,
apply the modified style
2020-02-13 14:44:37 -08:00
dns_requestmgr_t **requestmgrp) {
checkpoint
2000-02-24 14:31:43 +00:00
dns_requestmgr_t *requestmgr;
apply the modified style
2020-02-13 14:44:37 -08:00
int i;
unsigned int dispattr;
checkpoint
2000-02-24 14:31:43 +00:00
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
req_log(ISC_LOG_DEBUG(3), "dns_requestmgr_create");
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
checkpoint
2000-02-24 14:31:43 +00:00
REQUIRE(requestmgrp != NULL && *requestmgrp == NULL);
Merge the mlg-20000518 branch onto the mainline. Change summary: dns_dispatch_create() no longer exists. dns_dispatch_createtcp() and dns_dispatch_getudp() are the replacements. _createtcp() takes a bound, connected TCP socket, while _getudp() will search for a sharable UDP socket, and if found, attach to it and return a pointer to it. If one is not found, it will create a udp socket, bind it to a supplied local address, and create a new dispatcher around it. dns_dispatch_remove{request,response}() no longer take the dispatch as an argument. query-source can now be set per view. The dispatch manager holds onto three memory pools, one for allocating dispatchers from, one for events, and one for requests/replies. The free list on these pools is hard-coded, but set to 1024. This keeps us from having to dig into the isc_mem_t the pools draw from as often. dns_resolver_create() and dns_view_createresolver() require that valid dispatchers be passed in; dispatchers are no longer created for the caller.
2000-05-19 21:46:46 +00:00
REQUIRE(taskmgr != NULL);
implement dns_dispatchmgr_t, replacing dns_dispatchlist_t. Use it throughout the library/server.
2000-05-10 21:34:50 +00:00
REQUIRE(dispatchmgr != NULL);
remove unused variable sock
2020-08-06 12:21:50 +10:00
checkpoint
2000-02-24 14:31:43 +00:00
if (dispatchv4 != NULL) {
2375. [security] Fully randomize UDP query ports to improve forgery resilience. [RT #17949, #18098]
2008-06-23 19:41:20 +00:00
dispattr = dns_dispatch_getattributes(dispatchv4);
REQUIRE((dispattr & DNS_DISPATCHATTR_UDP) != 0);
checkpoint
2000-02-24 14:31:43 +00:00
}
if (dispatchv6 != NULL) {
2375. [security] Fully randomize UDP query ports to improve forgery resilience. [RT #17949, #18098]
2008-06-23 19:41:20 +00:00
dispattr = dns_dispatch_getattributes(dispatchv6);
REQUIRE((dispattr & DNS_DISPATCHATTR_UDP) != 0);
checkpoint
2000-02-24 14:31:43 +00:00
}
requestmgr = isc_mem_get(mctx, sizeof(*requestmgr));
isc_mutex_init returns 'void'
2018-11-16 15:33:22 +01:00
isc_mutex_init(&requestmgr->lock);
add request locking. dns_request_create() failed to detach from requestmgr under certain conditions.
2000-03-22 07:00:39 +00:00
for (i = 0; i < DNS_REQUEST_NLOCKS; i++) {
isc_mutex_init returns 'void'
2018-11-16 15:33:22 +01:00
isc_mutex_init(&requestmgr->locks[i]);
add request locking. dns_request_create() failed to detach from requestmgr under certain conditions.
2000-03-22 07:00:39 +00:00
}
Merge the mlg-20000518 branch onto the mainline. Change summary: dns_dispatch_create() no longer exists. dns_dispatch_createtcp() and dns_dispatch_getudp() are the replacements. _createtcp() takes a bound, connected TCP socket, while _getudp() will search for a sharable UDP socket, and if found, attach to it and return a pointer to it. If one is not found, it will create a udp socket, bind it to a supplied local address, and create a new dispatcher around it. dns_dispatch_remove{request,response}() no longer take the dispatch as an argument. query-source can now be set per view. The dispatch manager holds onto three memory pools, one for allocating dispatchers from, one for events, and one for requests/replies. The free list on these pools is hard-coded, but set to 1024. This keeps us from having to dig into the isc_mem_t the pools draw from as often. dns_resolver_create() and dns_view_createresolver() require that valid dispatchers be passed in; dispatchers are no longer created for the caller.
2000-05-19 21:46:46 +00:00
requestmgr->taskmgr = taskmgr;
implement dns_dispatchmgr_t, replacing dns_dispatchlist_t. Use it throughout the library/server.
2000-05-10 21:34:50 +00:00
requestmgr->dispatchmgr = dispatchmgr;
checkpoint
2000-02-24 14:31:43 +00:00
requestmgr->dispatchv4 = NULL;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (dispatchv4 != NULL) {
checkpoint
2000-03-13 20:43:39 +00:00
dns_dispatch_attach(dispatchv4, &requestmgr->dispatchv4);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
checkpoint
2000-02-24 14:31:43 +00:00
requestmgr->dispatchv6 = NULL;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (dispatchv6 != NULL) {
checkpoint
2000-03-13 20:43:39 +00:00
dns_dispatch_attach(dispatchv6, &requestmgr->dispatchv6);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
requestmgr->mctx = NULL;
isc_mem_attach(mctx, &requestmgr->mctx);
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
requestmgr->eref = 1; /* implicit attach */
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
requestmgr->iref = 0;
checkpoint
2000-02-24 14:31:43 +00:00
ISC_LIST_INIT(requestmgr->whenshutdown);
checkpoint
2000-03-20 12:22:02 +00:00
ISC_LIST_INIT(requestmgr->requests);
Replace custom isc_boolean_t with C standard bool type
2018-04-17 08:29:14 -07:00
requestmgr->exiting = false;
add request locking. dns_request_create() failed to detach from requestmgr under certain conditions.
2000-03-22 07:00:39 +00:00
requestmgr->hash = 0;
checkpoint
2000-02-24 14:31:43 +00:00
requestmgr->magic = REQUESTMGR_MAGIC;
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
req_log(ISC_LOG_DEBUG(3), "dns_requestmgr_create: %p", requestmgr);
*requestmgrp = requestmgr;
checkpoint
2000-02-24 14:31:43 +00:00
return (ISC_R_SUCCESS);
}
void
dns_requestmgr_whenshutdown(dns_requestmgr_t *requestmgr, isc_task_t *task,
apply the modified style
2020-02-13 14:44:37 -08:00
isc_event_t **eventp) {
isc_task_t *tclone;
8 space -> tab conversion
2000-12-11 19:24:30 +00:00
isc_event_t *event;
checkpoint
2000-02-24 14:31:43 +00:00
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
req_log(ISC_LOG_DEBUG(3), "dns_requestmgr_whenshutdown");
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
8 space -> tab conversion
2000-12-11 19:24:30 +00:00
REQUIRE(VALID_REQUESTMGR(requestmgr));
REQUIRE(eventp != NULL);
event = *eventp;
*eventp = NULL;
LOCK(&requestmgr->lock);
if (requestmgr->exiting) {
/*
* We're already shutdown. Send the event.
*/
event->ev_sender = requestmgr;
isc_task_send(task, &event);
} else {
4403. [bug] Rename variables and arguments that shadow: basename, clone and gai_error.
2016-06-28 21:25:30 -04:00
tclone = NULL;
isc_task_attach(task, &tclone);
event->ev_sender = tclone;
8 space -> tab conversion
2000-12-11 19:24:30 +00:00
ISC_LIST_APPEND(requestmgr->whenshutdown, event, ev_link);
checkpoint
2000-02-24 14:31:43 +00:00
}
UNLOCK(&requestmgr->lock);
}
void
apply the modified style
2020-02-13 14:44:37 -08:00
dns_requestmgr_shutdown(dns_requestmgr_t *requestmgr) {
8 space -> tab conversion
2000-12-11 19:24:30 +00:00
REQUIRE(VALID_REQUESTMGR(requestmgr));
checkpoint
2000-02-24 14:31:43 +00:00
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
req_log(ISC_LOG_DEBUG(3), "dns_requestmgr_shutdown: %p", requestmgr);
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
checkpoint
2000-02-24 14:31:43 +00:00
LOCK(&requestmgr->lock);
checkpoint
2000-03-20 12:22:02 +00:00
mgr_shutdown(requestmgr);
UNLOCK(&requestmgr->lock);
}
Trailing whitespace trimmed. Perhaps running "perl util/spacewhack.pl in your own CVS tree will help minimize CVS conflicts. Maybe not. Blame Graff for getting me to trim all trailing whitespace.
2000-08-01 01:33:37 +00:00
static void
apply the modified style
2020-02-13 14:44:37 -08:00
mgr_shutdown(dns_requestmgr_t *requestmgr) {
checkpoint
2000-03-20 12:22:02 +00:00
dns_request_t *request;
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
checkpoint
2000-02-24 14:31:43 +00:00
if (!requestmgr->exiting) {
Replace custom isc_boolean_t with C standard bool type
2018-04-17 08:29:14 -07:00
requestmgr->exiting = true;
checkpoint
2000-03-20 12:22:02 +00:00
for (request = ISC_LIST_HEAD(requestmgr->requests);
apply the modified style
2020-02-13 14:44:37 -08:00
request != NULL; request = ISC_LIST_NEXT(request, link))
{
checkpoint
2000-03-20 12:22:02 +00:00
dns_request_cancel(request);
}
Send shutdown events when irefs -> 0 and exiting.
2000-04-20 13:45:36 +00:00
if (requestmgr->iref == 0) {
INSIST(ISC_LIST_EMPTY(requestmgr->requests));
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
send_shutdown_events(requestmgr);
Send shutdown events when irefs -> 0 and exiting.
2000-04-20 13:45:36 +00:00
}
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
}
}
static void
apply the modified style
2020-02-13 14:44:37 -08:00
requestmgr_attach(dns_requestmgr_t *source, dns_requestmgr_t **targetp) {
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
/*
* Locked by caller.
*/
8 space -> tab conversion
2000-12-11 19:24:30 +00:00
REQUIRE(VALID_REQUESTMGR(source));
REQUIRE(targetp != NULL && *targetp == NULL);
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
REQUIRE(!source->exiting);
source->iref++;
*targetp = source;
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
req_log(ISC_LOG_DEBUG(3), "requestmgr_attach: %p: eref %d iref %d",
source, source->eref, source->iref);
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
}
static void
apply the modified style
2020-02-13 14:44:37 -08:00
requestmgr_detach(dns_requestmgr_t **requestmgrp) {
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
dns_requestmgr_t *requestmgr;
apply the modified style
2020-02-13 14:44:37 -08:00
bool need_destroy = false;
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
REQUIRE(requestmgrp != NULL);
requestmgr = *requestmgrp;
Clear the pointer to destroyed object early using the semantic patch Also disable the semantic patch as the code needs tweaks here and there because some destroy functions might not destroy the object and return early if the object is still in use.
2020-02-08 04:37:54 -08:00
*requestmgrp = NULL;
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
REQUIRE(VALID_REQUESTMGR(requestmgr));
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
LOCK(&requestmgr->lock);
INSIST(requestmgr->iref > 0);
requestmgr->iref--;
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
req_log(ISC_LOG_DEBUG(3), "requestmgr_detach: %p: eref %d iref %d",
requestmgr, requestmgr->eref, requestmgr->iref);
Send shutdown events when irefs -> 0 and exiting.
2000-04-20 13:45:36 +00:00
if (requestmgr->iref == 0 && requestmgr->exiting) {
INSIST(ISC_LIST_HEAD(requestmgr->requests) == NULL);
checkpoint
2000-02-24 14:31:43 +00:00
send_shutdown_events(requestmgr);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (requestmgr->eref == 0) {
Replace custom isc_boolean_t with C standard bool type
2018-04-17 08:29:14 -07:00
need_destroy = true;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
checkpoint
2000-02-24 14:31:43 +00:00
}
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
UNLOCK(&requestmgr->lock);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (need_destroy) {
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
mgr_destroy(requestmgr);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
checkpoint
2000-02-24 14:31:43 +00:00
}
void
apply the modified style
2020-02-13 14:44:37 -08:00
dns_requestmgr_attach(dns_requestmgr_t *source, dns_requestmgr_t **targetp) {
8 space -> tab conversion
2000-12-11 19:24:30 +00:00
REQUIRE(VALID_REQUESTMGR(source));
REQUIRE(targetp != NULL && *targetp == NULL);
checkpoint
2000-03-13 20:43:39 +00:00
REQUIRE(!source->exiting);
checkpoint
2000-02-24 14:31:43 +00:00
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
LOCK(&source->lock);
source->eref++;
checkpoint
2000-02-24 14:31:43 +00:00
*targetp = source;
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
UNLOCK(&source->lock);
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
req_log(ISC_LOG_DEBUG(3), "dns_requestmgr_attach: %p: eref %d iref %d",
source, source->eref, source->iref);
checkpoint
2000-02-24 14:31:43 +00:00
}
void
apply the modified style
2020-02-13 14:44:37 -08:00
dns_requestmgr_detach(dns_requestmgr_t **requestmgrp) {
checkpoint
2000-02-24 14:31:43 +00:00
dns_requestmgr_t *requestmgr;
apply the modified style
2020-02-13 14:44:37 -08:00
bool need_destroy = false;
checkpoint
2000-02-24 14:31:43 +00:00
REQUIRE(requestmgrp != NULL);
checkpoint
2000-03-13 20:43:39 +00:00
requestmgr = *requestmgrp;
Clear the pointer to destroyed object early using the semantic patch Also disable the semantic patch as the code needs tweaks here and there because some destroy functions might not destroy the object and return early if the object is still in use.
2020-02-08 04:37:54 -08:00
*requestmgrp = NULL;
checkpoint
2000-02-24 14:31:43 +00:00
REQUIRE(VALID_REQUESTMGR(requestmgr));
LOCK(&requestmgr->lock);
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
INSIST(requestmgr->eref > 0);
requestmgr->eref--;
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
req_log(ISC_LOG_DEBUG(3), "dns_requestmgr_detach: %p: eref %d iref %d",
requestmgr, requestmgr->eref, requestmgr->iref);
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
if (requestmgr->eref == 0 && requestmgr->iref == 0) {
checkpoint
2000-03-20 12:22:02 +00:00
INSIST(requestmgr->exiting &&
ISC_LIST_HEAD(requestmgr->requests) == NULL);
Replace custom isc_boolean_t with C standard bool type
2018-04-17 08:29:14 -07:00
need_destroy = true;
checkpoint
2000-02-24 14:31:43 +00:00
}
checkpoint
2000-03-13 20:43:39 +00:00
UNLOCK(&requestmgr->lock);
checkpoint
2000-02-24 14:31:43 +00:00
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (need_destroy) {
checkpoint
2000-03-20 12:22:02 +00:00
mgr_destroy(requestmgr);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
checkpoint
2000-02-24 14:31:43 +00:00
}
static void
apply the modified style
2020-02-13 14:44:37 -08:00
send_shutdown_events(dns_requestmgr_t *requestmgr) {
checkpoint
2000-02-24 14:31:43 +00:00
isc_event_t *event, *next_event;
apply the modified style
2020-02-13 14:44:37 -08:00
isc_task_t *etask;
checkpoint
2000-02-24 14:31:43 +00:00
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
req_log(ISC_LOG_DEBUG(3), "send_shutdown_events: %p", requestmgr);
checkpoint
2000-02-24 14:31:43 +00:00
/*
* Caller must be holding the manager lock.
*/
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
for (event = ISC_LIST_HEAD(requestmgr->whenshutdown); event != NULL;
apply the modified style
2020-02-13 14:44:37 -08:00
event = next_event)
{
convert sender, arg, action, etc. to ev_sender, ev_arg, ev_action, etc.
2000-04-17 19:22:44 +00:00
next_event = ISC_LIST_NEXT(event, ev_link);
ISC_LIST_UNLINK(requestmgr->whenshutdown, event, ev_link);
etask = event->ev_sender;
event->ev_sender = requestmgr;
checkpoint
2000-02-24 14:31:43 +00:00
isc_task_sendanddetach(&etask, &event);
}
}
static void
apply the modified style
2020-02-13 14:44:37 -08:00
mgr_destroy(dns_requestmgr_t *requestmgr) {
add request locking. dns_request_create() failed to detach from requestmgr under certain conditions.
2000-03-22 07:00:39 +00:00
int i;
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
req_log(ISC_LOG_DEBUG(3), "mgr_destroy");
add request locking. dns_request_create() failed to detach from requestmgr under certain conditions.
2000-03-22 07:00:39 +00:00
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
REQUIRE(requestmgr->eref == 0);
REQUIRE(requestmgr->iref == 0);
checkpoint
2000-03-20 12:22:02 +00:00
- Make isc_mutex_destroy return void - Make isc_mutexblock_init/destroy return void - Minor cleanups
2018-11-19 10:31:09 +00:00
isc_mutex_destroy(&requestmgr->lock);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
for (i = 0; i < DNS_REQUEST_NLOCKS; i++) {
- Make isc_mutex_destroy return void - Make isc_mutexblock_init/destroy return void - Minor cleanups
2018-11-19 10:31:09 +00:00
isc_mutex_destroy(&requestmgr->locks[i]);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
if (requestmgr->dispatchv4 != NULL) {
checkpoint
2000-02-24 14:31:43 +00:00
dns_dispatch_detach(&requestmgr->dispatchv4);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
if (requestmgr->dispatchv6 != NULL) {
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
dns_dispatch_detach(&requestmgr->dispatchv6);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
checkpoint
2000-03-13 20:43:39 +00:00
requestmgr->magic = 0;
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
isc_mem_putanddetach(&requestmgr->mctx, requestmgr,
sizeof(*requestmgr));
checkpoint
2000-02-24 14:31:43 +00:00
}
add request locking. dns_request_create() failed to detach from requestmgr under certain conditions.
2000-03-22 07:00:39 +00:00
static unsigned int
apply the modified style
2020-02-13 14:44:37 -08:00
mgr_gethash(dns_requestmgr_t *requestmgr) {
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
req_log(ISC_LOG_DEBUG(3), "mgr_gethash");
add request locking. dns_request_create() failed to detach from requestmgr under certain conditions.
2000-03-22 07:00:39 +00:00
/*
* Locked by caller.
*/
requestmgr->hash++;
spacing
2001-01-23 02:00:56 +00:00
return (requestmgr->hash % DNS_REQUEST_NLOCKS);
add request locking. dns_request_create() failed to detach from requestmgr under certain conditions.
2000-03-22 07:00:39 +00:00
}
Convert dispatch to netmgr The flow of operations in dispatch is changing and will now be similar for both UDP and TCP queries: 1) Call dns_dispatch_addresponse() to assign a query ID and register that we'll be listening for a response with that ID soon. the parameters for this function include callback functions to inform the caller when the socket is connected and when the message has been sent, as well as a task action that will be sent when the response arrives. (later this could become a netmgr callback, but at this stage to minimize disruption to the calling code, we continue to use isc_task for the response event.) on successful completion of this function, a dispatch entry object will be instantiated. 2) Call dns_dispatch_connect() on the dispatch entry. this runs isc_nm_udpconnect() or isc_nm_tcpdnsconnect(), as needed, and begins listening for responses. the caller is informed via a callback function when the connection is established. 3) Call dns_dispatch_send() on the dispatch entry. this runs isc_nm_send() to send a request. 4) Call dns_dispatch_removeresponse() to terminate listening and close the connection. Implementation comments below: - As we will be using netmgr buffers now. code to send the length in TCP queries has also been removed as that is handled by the netmgr. - TCP dispatches can be used by multiple simultaneous queries, so dns_dispatch_connect() now checks whether the dispatch is already connected before calling isc_nm_tcpdnsconnect() again. - Running dns_dispatch_getnext() from a non-network thread caused a crash due to assertions in the netmgr read functions that appear to be unnecessary now. the assertions have been removed. - fctx->nqueries was formerly incremented when the connection was successful, but is now incremented when the query is started and decremented if the connection fails. - It's no longer necessary for each dispatch to have a pool of tasks, so there's now a single task per dispatch. - Dispatch code to avoid UDP ports already in use has been removed. - dns_resolver and dns_request have been modified to use netmgr callback functions instead of task events. some additional changes were needed to handle shutdown processing correctly. - Timeout processing is not yet fully converted to use netmgr timeouts. - Fixed a lock order cycle reported by TSAN (view -> zone-> adb -> view) by by calling dns_zt functions without holding the view lock.
2021-01-14 13:02:57 -08:00
static inline void
req_send(dns_request_t *request) {
Move isc_socket_sendto2() calls into dispatch We now use dns_dispatch_send() for this purpose.
2021-01-04 23:03:50 -08:00
isc_region_t r;
checkpoint
2000-03-20 12:22:02 +00:00
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
req_log(ISC_LOG_DEBUG(3), "req_send: request %p", request);
Added REQUIRE's
2000-04-28 22:07:29 +00:00
REQUIRE(VALID_REQUEST(request));
Remove support for shared UDP dispatch sockets Currently the netmgr doesn't support unconnected, shared UDP sockets, so there's no reason to retain that functionality in the dispatcher prior to porting to the netmgr. In this commit, the DNS_DISPATCHATTR_EXCLUSIVE attribute has been removed as it is now non-optional; UDP dispatches are alwasy exclusive. Code implementing non-exclusive UDP dispatches has been removed. dns_dispatch_getentrysocket() now always returns the dispsocket for UDP dispatches and the dispatch socket for TCP dispatches. There is no longer any need to search for existing dispatches from dns_dispatch_getudp(), so the 'mask' option has been removed, and the function renamed to the more descriptive dns_dispatch_createudp().
2020-12-16 01:32:06 -08:00
103. [func] libisc buffer API changes for <isc/buffer.h>: Added: isc_buffer_base(b) (pointer) isc_buffer_current(b) (pointer) isc_buffer_active(b) (pointer) isc_buffer_used(b) (pointer) isc_buffer_length(b) (int) isc_buffer_usedlength(b) (int) isc_buffer_consumedlength(b) (int) isc_buffer_remaininglength(b) (int) isc_buffer_activelength(b) (int) isc_buffer_availablelength(b) (int) Removed: ISC_BUFFER_USEDCOUNT(b) ISC_BUFFER_AVAILABLECOUNT(b) isc_buffer_type(b) Changed names: isc_buffer_used(b, r) -> isc_buffer_usedregion(b, r) isc_buffer_available(b, r) -> isc_buffer_available_region(b, r) isc_buffer_consumed(b, r) -> isc_buffer_consumedregion(b, r) isc_buffer_active(b, r) -> isc_buffer_activeregion(b, r) isc_buffer_remaining(b, r) -> isc_buffer_remainingregion(b, r) Buffer types were removed, so the ISC_BUFFERTYPE_* macros are no more, and the type argument to isc_buffer_init and isc_buffer_allocate were removed. isc_buffer_putstr is now void (instead of isc_result_t) and requires that the caller ensure that there is enough available buffer space for the string.
2000-04-27 00:03:12 +00:00
isc_buffer_usedregion(request->query, &r);
Dispatch API simplification - Many dispatch attributes can be set implicitly instead of being passed in. we can infer whether to set DNS_DISPATCHATTR_TCP or _UDP from whether we're calling dns_dispatch_createtcp() or _createudp(). we can also infer DNS_DISPATCHATTR_IPV4 or _IPV6 from the addresses or the socket that were passed in. - We no longer use dup'd sockets in UDP dispatches, so the 'dup_socket' parameter has been removed from dns_dispatch_createudp(), along with the code implementing it. also removed isc_socket_dup() since it no longer has any callers. - The 'buffersize' parameter was ignored and has now been removed; buffersize is now fixed at 4096. - Maxbuffers and maxrequests don't need to be passed in on every call to dns_dispatch_createtcp() and _createudp(). In all current uses, the value for mgr->maxbuffers will either be raised once from its default of 20000 to 32768, or else left alone. (passing in a value lower than 20000 does not lower it.) there isn't enough difference between these values for there to be any need to configure this. The value for disp->maxrequests controls both the quota of concurrent requests for a dispatch and also the size of the dispatch socket memory pool. it's not clear that this quota is necessary at all. the memory pool size currently starts at 32768, but is sometimes lowered to 4096, which is definitely unnecessary. This commit sets both values permanently to 32768. - Previously TCP dispatches allocated their own separate QID table, which didn't incorporate a port table. this commit removes per-dispatch QID tables and shares the same table between all dispatches. since dispatches are created for each TCP socket, this may speed up the dispatch allocation process. there may be a slight increase in lock contention since all dispatches are sharing a single QID table, but since TCP sockets are used less often than UDP sockets (which were already sharing a QID table), it should not be a substantial change. - The dispatch port table was being used to determine whether a port was already in use; if so, then a UDP socket would be bound with REUSEADDR. this commit removes the port table, and always binds UDP sockets that way.
2020-12-17 00:43:00 -08:00
4535. [bug] Address race condition in setting / testing of DNS_REQUEST_F_SENDING. [RT #43889]
2016-12-14 10:31:26 +11:00
request->flags |= DNS_REQUEST_F_SENDING;
Convert dispatch to netmgr The flow of operations in dispatch is changing and will now be similar for both UDP and TCP queries: 1) Call dns_dispatch_addresponse() to assign a query ID and register that we'll be listening for a response with that ID soon. the parameters for this function include callback functions to inform the caller when the socket is connected and when the message has been sent, as well as a task action that will be sent when the response arrives. (later this could become a netmgr callback, but at this stage to minimize disruption to the calling code, we continue to use isc_task for the response event.) on successful completion of this function, a dispatch entry object will be instantiated. 2) Call dns_dispatch_connect() on the dispatch entry. this runs isc_nm_udpconnect() or isc_nm_tcpdnsconnect(), as needed, and begins listening for responses. the caller is informed via a callback function when the connection is established. 3) Call dns_dispatch_send() on the dispatch entry. this runs isc_nm_send() to send a request. 4) Call dns_dispatch_removeresponse() to terminate listening and close the connection. Implementation comments below: - As we will be using netmgr buffers now. code to send the length in TCP queries has also been removed as that is handled by the netmgr. - TCP dispatches can be used by multiple simultaneous queries, so dns_dispatch_connect() now checks whether the dispatch is already connected before calling isc_nm_tcpdnsconnect() again. - Running dns_dispatch_getnext() from a non-network thread caused a crash due to assertions in the netmgr read functions that appear to be unnecessary now. the assertions have been removed. - fctx->nqueries was formerly incremented when the connection was successful, but is now incremented when the query is started and decremented if the connection fails. - It's no longer necessary for each dispatch to have a pool of tasks, so there's now a single task per dispatch. - Dispatch code to avoid UDP ports already in use has been removed. - dns_resolver and dns_request have been modified to use netmgr callback functions instead of task events. some additional changes were needed to handle shutdown processing correctly. - Timeout processing is not yet fully converted to use netmgr timeouts. - Fixed a lock order cycle reported by TSAN (view -> zone-> adb -> view) by by calling dns_zt functions without holding the view lock.
2021-01-14 13:02:57 -08:00
dns_dispatch_send(request->dispentry, &r, request->dscp);
checkpoint
2000-03-20 12:22:02 +00:00
}
remove more duplicated code
2001-01-23 19:50:10 +00:00
static isc_result_t
apply the modified style
2020-02-13 14:44:37 -08:00
new_request(isc_mem_t *mctx, dns_request_t **requestp) {
remove more duplicated code
2001-01-23 19:50:10 +00:00
dns_request_t *request;
request = isc_mem_get(mctx, sizeof(*request));
Dispatch API simplification - Many dispatch attributes can be set implicitly instead of being passed in. we can infer whether to set DNS_DISPATCHATTR_TCP or _UDP from whether we're calling dns_dispatch_createtcp() or _createudp(). we can also infer DNS_DISPATCHATTR_IPV4 or _IPV6 from the addresses or the socket that were passed in. - We no longer use dup'd sockets in UDP dispatches, so the 'dup_socket' parameter has been removed from dns_dispatch_createudp(), along with the code implementing it. also removed isc_socket_dup() since it no longer has any callers. - The 'buffersize' parameter was ignored and has now been removed; buffersize is now fixed at 4096. - Maxbuffers and maxrequests don't need to be passed in on every call to dns_dispatch_createtcp() and _createudp(). In all current uses, the value for mgr->maxbuffers will either be raised once from its default of 20000 to 32768, or else left alone. (passing in a value lower than 20000 does not lower it.) there isn't enough difference between these values for there to be any need to configure this. The value for disp->maxrequests controls both the quota of concurrent requests for a dispatch and also the size of the dispatch socket memory pool. it's not clear that this quota is necessary at all. the memory pool size currently starts at 32768, but is sometimes lowered to 4096, which is definitely unnecessary. This commit sets both values permanently to 32768. - Previously TCP dispatches allocated their own separate QID table, which didn't incorporate a port table. this commit removes per-dispatch QID tables and shares the same table between all dispatches. since dispatches are created for each TCP socket, this may speed up the dispatch allocation process. there may be a slight increase in lock contention since all dispatches are sharing a single QID table, but since TCP sockets are used less often than UDP sockets (which were already sharing a QID table), it should not be a substantial change. - The dispatch port table was being used to determine whether a port was already in use; if so, then a UDP socket would be bound with REUSEADDR. this commit removes the port table, and always binds UDP sockets that way.
2020-12-17 00:43:00 -08:00
*request = (dns_request_t){ .dscp = -1 };
remove more duplicated code
2001-01-23 19:50:10 +00:00
ISC_LINK_INIT(request, link);
isc_mem_attach(mctx, &request->mctx);
809. [bug] Configuring a non-local address as a transfer-source could cause an assertion failure during load.
2001-04-16 18:50:32 +00:00
request->magic = REQUEST_MAGIC;
remove more duplicated code
2001-01-23 19:50:10 +00:00
*requestp = request;
return (ISC_R_SUCCESS);
}
Replace custom isc_boolean_t with C standard bool type
2018-04-17 08:29:14 -07:00
static bool
apply the modified style
2020-02-13 14:44:37 -08:00
isblackholed(dns_dispatchmgr_t *dispatchmgr, const isc_sockaddr_t *destaddr) {
dns_acl_t *blackhole;
common code elimination
2001-01-23 07:36:06 +00:00
isc_netaddr_t netaddr;
apply the modified style
2020-02-13 14:44:37 -08:00
int match;
bool drop = false;
char netaddrstr[ISC_NETADDR_FORMATSIZE];
common code elimination
2001-01-23 07:36:06 +00:00
removed more needless attaching and detaching of the blackhole ACL
2001-02-09 00:23:16 +00:00
blackhole = dns_dispatchmgr_getblackhole(dispatchmgr);
common code elimination
2001-01-23 07:36:06 +00:00
if (blackhole != NULL) {
isc_netaddr_fromsockaddr(&netaddr, destaddr);
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
if (dns_acl_match(&netaddr, NULL, blackhole, NULL, &match,
NULL) == ISC_R_SUCCESS &&
apply the modified style
2020-02-13 14:44:37 -08:00
match > 0)
{
Replace custom isc_boolean_t with C standard bool type
2018-04-17 08:29:14 -07:00
drop = true;
remove the experimental authoritative ECS support from named - mark the 'geoip-use-ecs' option obsolete; warn when it is used in named.conf - prohibit 'ecs' ACL tags in named.conf; note that this is a fatal error since simply ignoring the tags could make ACLs behave unpredictably - re-simplify the radix and iptable code - clean up dns_acl_match(), dns_aclelement_match(), dns_acl_allowed() and dns_geoip_match() so they no longer take ecs options - remove the ECS-specific unit and system test cases - remove references to ECS from the ARM
2018-04-26 20:57:41 -07:00
}
common code elimination
2001-01-23 07:36:06 +00:00
}
if (drop) {
isc_netaddr_format(&netaddr, netaddrstr, sizeof(netaddrstr));
req_log(ISC_LOG_DEBUG(10), "blackholed address %s", netaddrstr);
}
return (drop);
}
static isc_result_t
Dispatch API simplification - Many dispatch attributes can be set implicitly instead of being passed in. we can infer whether to set DNS_DISPATCHATTR_TCP or _UDP from whether we're calling dns_dispatch_createtcp() or _createudp(). we can also infer DNS_DISPATCHATTR_IPV4 or _IPV6 from the addresses or the socket that were passed in. - We no longer use dup'd sockets in UDP dispatches, so the 'dup_socket' parameter has been removed from dns_dispatch_createudp(), along with the code implementing it. also removed isc_socket_dup() since it no longer has any callers. - The 'buffersize' parameter was ignored and has now been removed; buffersize is now fixed at 4096. - Maxbuffers and maxrequests don't need to be passed in on every call to dns_dispatch_createtcp() and _createudp(). In all current uses, the value for mgr->maxbuffers will either be raised once from its default of 20000 to 32768, or else left alone. (passing in a value lower than 20000 does not lower it.) there isn't enough difference between these values for there to be any need to configure this. The value for disp->maxrequests controls both the quota of concurrent requests for a dispatch and also the size of the dispatch socket memory pool. it's not clear that this quota is necessary at all. the memory pool size currently starts at 32768, but is sometimes lowered to 4096, which is definitely unnecessary. This commit sets both values permanently to 32768. - Previously TCP dispatches allocated their own separate QID table, which didn't incorporate a port table. this commit removes per-dispatch QID tables and shares the same table between all dispatches. since dispatches are created for each TCP socket, this may speed up the dispatch allocation process. there may be a slight increase in lock contention since all dispatches are sharing a single QID table, but since TCP sockets are used less often than UDP sockets (which were already sharing a QID table), it should not be a substantial change. - The dispatch port table was being used to determine whether a port was already in use; if so, then a UDP socket would be bound with REUSEADDR. this commit removes the port table, and always binds UDP sockets that way.
2020-12-17 00:43:00 -08:00
tcp_dispatch(bool newtcp, dns_requestmgr_t *requestmgr,
const isc_sockaddr_t *srcaddr, const isc_sockaddr_t *destaddr,
isc_dscp_t dscp, bool *connected, dns_dispatch_t **dispatchp) {
apply the modified style
2020-02-13 14:44:37 -08:00
isc_result_t result;
common code elimination
2001-01-23 07:36:06 +00:00
Make sharing of pending TCP dispatches nonoptional The DNS_REQUESTOPT_SHARE flag was added when client-side pipelining of TCP queries was implemented. there was no need to make it optional; forcing it to be in effect for all requests simplfiies the code.
2020-12-11 15:20:33 -08:00
if (!newtcp) {
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
result = dns_dispatch_gettcp(requestmgr->dispatchmgr, destaddr,
srcaddr, connected, dispatchp);
[master] allow shared TCP sockets when connecting 4041. [func] TCP sockets can now be shared while connecting. (This will be used to enable client-side support of pipelined queries.) [RT #38231]
2015-01-20 17:22:31 -08:00
if (result == ISC_R_SUCCESS) {
char peer[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_format(destaddr, peer, sizeof(peer));
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
req_log(ISC_LOG_DEBUG(1),
"attached to %s TCP "
[master] allow shared TCP sockets when connecting 4041. [func] TCP sockets can now be shared while connecting. (This will be used to enable client-side support of pipelined queries.) [RT #38231]
2015-01-20 17:22:31 -08:00
"connection to %s",
*connected ? "existing" : "pending", peer);
return (result);
}
3939. [func] Improve UPDATE forwarding performance by allowing TCP connections to be shared. [RT #37039]
2014-09-04 10:37:45 +10:00
}
Convert dispatch to netmgr The flow of operations in dispatch is changing and will now be similar for both UDP and TCP queries: 1) Call dns_dispatch_addresponse() to assign a query ID and register that we'll be listening for a response with that ID soon. the parameters for this function include callback functions to inform the caller when the socket is connected and when the message has been sent, as well as a task action that will be sent when the response arrives. (later this could become a netmgr callback, but at this stage to minimize disruption to the calling code, we continue to use isc_task for the response event.) on successful completion of this function, a dispatch entry object will be instantiated. 2) Call dns_dispatch_connect() on the dispatch entry. this runs isc_nm_udpconnect() or isc_nm_tcpdnsconnect(), as needed, and begins listening for responses. the caller is informed via a callback function when the connection is established. 3) Call dns_dispatch_send() on the dispatch entry. this runs isc_nm_send() to send a request. 4) Call dns_dispatch_removeresponse() to terminate listening and close the connection. Implementation comments below: - As we will be using netmgr buffers now. code to send the length in TCP queries has also been removed as that is handled by the netmgr. - TCP dispatches can be used by multiple simultaneous queries, so dns_dispatch_connect() now checks whether the dispatch is already connected before calling isc_nm_tcpdnsconnect() again. - Running dns_dispatch_getnext() from a non-network thread caused a crash due to assertions in the netmgr read functions that appear to be unnecessary now. the assertions have been removed. - fctx->nqueries was formerly incremented when the connection was successful, but is now incremented when the query is started and decremented if the connection fails. - It's no longer necessary for each dispatch to have a pool of tasks, so there's now a single task per dispatch. - Dispatch code to avoid UDP ports already in use has been removed. - dns_resolver and dns_request have been modified to use netmgr callback functions instead of task events. some additional changes were needed to handle shutdown processing correctly. - Timeout processing is not yet fully converted to use netmgr timeouts. - Fixed a lock order cycle reported by TSAN (view -> zone-> adb -> view) by by calling dns_zt functions without holding the view lock.
2021-01-14 13:02:57 -08:00
result = dns_dispatch_createtcp(requestmgr->dispatchmgr,
requestmgr->taskmgr, srcaddr, destaddr,
0, dscp, dispatchp);
common code elimination
2001-01-23 07:36:06 +00:00
return (result);
}
static isc_result_t
Dispatch API simplification - Many dispatch attributes can be set implicitly instead of being passed in. we can infer whether to set DNS_DISPATCHATTR_TCP or _UDP from whether we're calling dns_dispatch_createtcp() or _createudp(). we can also infer DNS_DISPATCHATTR_IPV4 or _IPV6 from the addresses or the socket that were passed in. - We no longer use dup'd sockets in UDP dispatches, so the 'dup_socket' parameter has been removed from dns_dispatch_createudp(), along with the code implementing it. also removed isc_socket_dup() since it no longer has any callers. - The 'buffersize' parameter was ignored and has now been removed; buffersize is now fixed at 4096. - Maxbuffers and maxrequests don't need to be passed in on every call to dns_dispatch_createtcp() and _createudp(). In all current uses, the value for mgr->maxbuffers will either be raised once from its default of 20000 to 32768, or else left alone. (passing in a value lower than 20000 does not lower it.) there isn't enough difference between these values for there to be any need to configure this. The value for disp->maxrequests controls both the quota of concurrent requests for a dispatch and also the size of the dispatch socket memory pool. it's not clear that this quota is necessary at all. the memory pool size currently starts at 32768, but is sometimes lowered to 4096, which is definitely unnecessary. This commit sets both values permanently to 32768. - Previously TCP dispatches allocated their own separate QID table, which didn't incorporate a port table. this commit removes per-dispatch QID tables and shares the same table between all dispatches. since dispatches are created for each TCP socket, this may speed up the dispatch allocation process. there may be a slight increase in lock contention since all dispatches are sharing a single QID table, but since TCP sockets are used less often than UDP sockets (which were already sharing a QID table), it should not be a substantial change. - The dispatch port table was being used to determine whether a port was already in use; if so, then a UDP socket would be bound with REUSEADDR. this commit removes the port table, and always binds UDP sockets that way.
2020-12-17 00:43:00 -08:00
udp_dispatch(dns_requestmgr_t *requestmgr, const isc_sockaddr_t *srcaddr,
const isc_sockaddr_t *destaddr, dns_dispatch_t **dispatchp) {
common code elimination
2001-01-23 07:36:06 +00:00
dns_dispatch_t *disp = NULL;
if (srcaddr == NULL) {
switch (isc_sockaddr_pf(destaddr)) {
case PF_INET:
disp = requestmgr->dispatchv4;
break;
case PF_INET6:
disp = requestmgr->dispatchv6;
break;
default:
return (ISC_R_NOTIMPLEMENTED);
}
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (disp == NULL) {
common code elimination
2001-01-23 07:36:06 +00:00
return (ISC_R_FAMILYNOSUPPORT);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
common code elimination
2001-01-23 07:36:06 +00:00
dns_dispatch_attach(disp, dispatchp);
return (ISC_R_SUCCESS);
}
Remove support for shared UDP dispatch sockets Currently the netmgr doesn't support unconnected, shared UDP sockets, so there's no reason to retain that functionality in the dispatcher prior to porting to the netmgr. In this commit, the DNS_DISPATCHATTR_EXCLUSIVE attribute has been removed as it is now non-optional; UDP dispatches are alwasy exclusive. Code implementing non-exclusive UDP dispatches has been removed. dns_dispatch_getentrysocket() now always returns the dispsocket for UDP dispatches and the dispatch socket for TCP dispatches. There is no longer any need to search for existing dispatches from dns_dispatch_getudp(), so the 'mask' option has been removed, and the function renamed to the more descriptive dns_dispatch_createudp().
2020-12-16 01:32:06 -08:00
Convert dispatch to netmgr The flow of operations in dispatch is changing and will now be similar for both UDP and TCP queries: 1) Call dns_dispatch_addresponse() to assign a query ID and register that we'll be listening for a response with that ID soon. the parameters for this function include callback functions to inform the caller when the socket is connected and when the message has been sent, as well as a task action that will be sent when the response arrives. (later this could become a netmgr callback, but at this stage to minimize disruption to the calling code, we continue to use isc_task for the response event.) on successful completion of this function, a dispatch entry object will be instantiated. 2) Call dns_dispatch_connect() on the dispatch entry. this runs isc_nm_udpconnect() or isc_nm_tcpdnsconnect(), as needed, and begins listening for responses. the caller is informed via a callback function when the connection is established. 3) Call dns_dispatch_send() on the dispatch entry. this runs isc_nm_send() to send a request. 4) Call dns_dispatch_removeresponse() to terminate listening and close the connection. Implementation comments below: - As we will be using netmgr buffers now. code to send the length in TCP queries has also been removed as that is handled by the netmgr. - TCP dispatches can be used by multiple simultaneous queries, so dns_dispatch_connect() now checks whether the dispatch is already connected before calling isc_nm_tcpdnsconnect() again. - Running dns_dispatch_getnext() from a non-network thread caused a crash due to assertions in the netmgr read functions that appear to be unnecessary now. the assertions have been removed. - fctx->nqueries was formerly incremented when the connection was successful, but is now incremented when the query is started and decremented if the connection fails. - It's no longer necessary for each dispatch to have a pool of tasks, so there's now a single task per dispatch. - Dispatch code to avoid UDP ports already in use has been removed. - dns_resolver and dns_request have been modified to use netmgr callback functions instead of task events. some additional changes were needed to handle shutdown processing correctly. - Timeout processing is not yet fully converted to use netmgr timeouts. - Fixed a lock order cycle reported by TSAN (view -> zone-> adb -> view) by by calling dns_zt functions without holding the view lock.
2021-01-14 13:02:57 -08:00
return (dns_dispatch_createudp(requestmgr->dispatchmgr,
requestmgr->taskmgr, srcaddr, 0,
dispatchp));
common code elimination
2001-01-23 07:36:06 +00:00
}
static isc_result_t
Make sharing of pending TCP dispatches nonoptional The DNS_REQUESTOPT_SHARE flag was added when client-side pipelining of TCP queries was implemented. there was no need to make it optional; forcing it to be in effect for all requests simplfiies the code.
2020-12-11 15:20:33 -08:00
get_dispatch(bool tcp, bool newtcp, dns_requestmgr_t *requestmgr,
4546. [func] Extend the use of const declarations. [RT #43379]
2016-12-30 15:45:08 +11:00
const isc_sockaddr_t *srcaddr, const isc_sockaddr_t *destaddr,
apply the modified style
2020-02-13 14:44:37 -08:00
isc_dscp_t dscp, bool *connected, dns_dispatch_t **dispatchp) {
common code elimination
2001-01-23 07:36:06 +00:00
isc_result_t result;
3939. [func] Improve UPDATE forwarding performance by allowing TCP connections to be shared. [RT #37039]
2014-09-04 10:37:45 +10:00
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (tcp) {
Dispatch API simplification - Many dispatch attributes can be set implicitly instead of being passed in. we can infer whether to set DNS_DISPATCHATTR_TCP or _UDP from whether we're calling dns_dispatch_createtcp() or _createudp(). we can also infer DNS_DISPATCHATTR_IPV4 or _IPV6 from the addresses or the socket that were passed in. - We no longer use dup'd sockets in UDP dispatches, so the 'dup_socket' parameter has been removed from dns_dispatch_createudp(), along with the code implementing it. also removed isc_socket_dup() since it no longer has any callers. - The 'buffersize' parameter was ignored and has now been removed; buffersize is now fixed at 4096. - Maxbuffers and maxrequests don't need to be passed in on every call to dns_dispatch_createtcp() and _createudp(). In all current uses, the value for mgr->maxbuffers will either be raised once from its default of 20000 to 32768, or else left alone. (passing in a value lower than 20000 does not lower it.) there isn't enough difference between these values for there to be any need to configure this. The value for disp->maxrequests controls both the quota of concurrent requests for a dispatch and also the size of the dispatch socket memory pool. it's not clear that this quota is necessary at all. the memory pool size currently starts at 32768, but is sometimes lowered to 4096, which is definitely unnecessary. This commit sets both values permanently to 32768. - Previously TCP dispatches allocated their own separate QID table, which didn't incorporate a port table. this commit removes per-dispatch QID tables and shares the same table between all dispatches. since dispatches are created for each TCP socket, this may speed up the dispatch allocation process. there may be a slight increase in lock contention since all dispatches are sharing a single QID table, but since TCP sockets are used less often than UDP sockets (which were already sharing a QID table), it should not be a substantial change. - The dispatch port table was being used to determine whether a port was already in use; if so, then a UDP socket would be bound with REUSEADDR. this commit removes the port table, and always binds UDP sockets that way.
2020-12-17 00:43:00 -08:00
result = tcp_dispatch(newtcp, requestmgr, srcaddr, destaddr,
dscp, connected, dispatchp);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
} else {
Dispatch API simplification - Many dispatch attributes can be set implicitly instead of being passed in. we can infer whether to set DNS_DISPATCHATTR_TCP or _UDP from whether we're calling dns_dispatch_createtcp() or _createudp(). we can also infer DNS_DISPATCHATTR_IPV4 or _IPV6 from the addresses or the socket that were passed in. - We no longer use dup'd sockets in UDP dispatches, so the 'dup_socket' parameter has been removed from dns_dispatch_createudp(), along with the code implementing it. also removed isc_socket_dup() since it no longer has any callers. - The 'buffersize' parameter was ignored and has now been removed; buffersize is now fixed at 4096. - Maxbuffers and maxrequests don't need to be passed in on every call to dns_dispatch_createtcp() and _createudp(). In all current uses, the value for mgr->maxbuffers will either be raised once from its default of 20000 to 32768, or else left alone. (passing in a value lower than 20000 does not lower it.) there isn't enough difference between these values for there to be any need to configure this. The value for disp->maxrequests controls both the quota of concurrent requests for a dispatch and also the size of the dispatch socket memory pool. it's not clear that this quota is necessary at all. the memory pool size currently starts at 32768, but is sometimes lowered to 4096, which is definitely unnecessary. This commit sets both values permanently to 32768. - Previously TCP dispatches allocated their own separate QID table, which didn't incorporate a port table. this commit removes per-dispatch QID tables and shares the same table between all dispatches. since dispatches are created for each TCP socket, this may speed up the dispatch allocation process. there may be a slight increase in lock contention since all dispatches are sharing a single QID table, but since TCP sockets are used less often than UDP sockets (which were already sharing a QID table), it should not be a substantial change. - The dispatch port table was being used to determine whether a port was already in use; if so, then a UDP socket would be bound with REUSEADDR. this commit removes the port table, and always binds UDP sockets that way.
2020-12-17 00:43:00 -08:00
result = udp_dispatch(requestmgr, srcaddr, destaddr, dispatchp);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
common code elimination
2001-01-23 07:36:06 +00:00
return (result);
}
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
isc_result_t
dns_request_createraw(dns_requestmgr_t *requestmgr, isc_buffer_t *msgbuf,
4546. [func] Extend the use of const declarations. [RT #43379]
2016-12-30 15:45:08 +11:00
const isc_sockaddr_t *srcaddr,
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
const isc_sockaddr_t *destaddr, isc_dscp_t dscp,
unsigned int options, unsigned int timeout,
unsigned int udptimeout, unsigned int udpretries,
isc_task_t *task, isc_taskaction_t action, void *arg,
apply the modified style
2020-02-13 14:44:37 -08:00
dns_request_t **requestp) {
dns_request_t *request = NULL;
isc_task_t *tclone = NULL;
isc_result_t result;
isc_mem_t *mctx;
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
dns_messageid_t id;
apply the modified style
2020-02-13 14:44:37 -08:00
bool tcp = false;
bool newtcp = false;
isc_region_t r;
bool connected = false;
unsigned int dispopt = 0;
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
REQUIRE(VALID_REQUESTMGR(requestmgr));
REQUIRE(msgbuf != NULL);
REQUIRE(destaddr != NULL);
REQUIRE(task != NULL);
REQUIRE(action != NULL);
REQUIRE(requestp != NULL && *requestp == NULL);
REQUIRE(timeout > 0);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (srcaddr != NULL) {
535. [func] Use xfrsource[46] when forwarding update requests.
2000-10-30 05:08:07 +00:00
REQUIRE(isc_sockaddr_pf(srcaddr) == isc_sockaddr_pf(destaddr));
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
mctx = requestmgr->mctx;
req_log(ISC_LOG_DEBUG(3), "dns_request_createraw");
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (isblackholed(requestmgr->dispatchmgr, destaddr)) {
common code elimination
2001-01-23 07:36:06 +00:00
return (DNS_R_BLACKHOLED);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
539. [func] Support the blackhole option.
2000-11-03 02:45:55 +00:00
remove more duplicated code
2001-01-23 19:50:10 +00:00
request = NULL;
result = new_request(mctx, &request);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
remove more duplicated code
2001-01-23 19:50:10 +00:00
return (result);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
2074. [bug] dns_request_create2(), dns_request_create3(), dns_request_createraw2() and dns_request_createraw3() failed to send multiple UDP requests. [RT #16349]
2006-08-21 00:35:36 +00:00
request->udpcount = udpretries;
[master] add DSCP support 3535. [func] Add support for setting Differentiated Services Code Point (DSCP) values in named. Most configuration options which take a "port" option (e.g., listen-on, forwarders, also-notify, masters, notify-source, etc) can now also take a "dscp" option specifying a code point for use with outgoing traffic, if supported by the underlying OS. [RT #27596]
2013-03-22 12:27:54 -07:00
request->dscp = dscp;
merge 4319
2002-11-12 23:58:14 +00:00
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
request->event = (dns_requestevent_t *)isc_event_allocate(
mctx, task, DNS_EVENT_REQUESTDONE, action, arg,
sizeof(dns_requestevent_t));
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
isc_task_attach(task, &tclone);
request->event->ev_sender = task;
request->event->request = request;
request->event->result = ISC_R_FAILURE;
isc_buffer_usedregion(msgbuf, &r);
if (r.length < DNS_MESSAGE_HEADERLEN || r.length > 65535) {
result = DNS_R_FORMERR;
goto cleanup;
}
update copyright notice
2008-06-23 23:47:11 +00:00
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if ((options & DNS_REQUESTOPT_TCP) != 0 || r.length > 512) {
Replace custom isc_boolean_t with C standard bool type
2018-04-17 08:29:14 -07:00
tcp = true;
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
request->timeout = timeout * 1000;
} else {
if (udptimeout == 0 && udpretries != 0) {
udptimeout = timeout / (udpretries + 1);
}
if (udptimeout == 0) {
udptimeout = 1;
}
request->timeout = udptimeout * 1000;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
again:
Make sharing of pending TCP dispatches nonoptional The DNS_REQUESTOPT_SHARE flag was added when client-side pipelining of TCP queries was implemented. there was no need to make it optional; forcing it to be in effect for all requests simplfiies the code.
2020-12-11 15:20:33 -08:00
result = get_dispatch(tcp, newtcp, requestmgr, srcaddr, destaddr, dscp,
&connected, &request->dispatch);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
common code elimination
2001-01-23 07:36:06 +00:00
goto cleanup;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
common code elimination
2001-01-23 07:36:06 +00:00
3961. [bug] Forwarding of SIG(0) signed UPDATE messages failed with BADSIG. [RT #37216]
2014-10-01 07:24:16 +10:00
if ((options & DNS_REQUESTOPT_FIXEDID) != 0) {
id = (r.base[0] << 8) | r.base[1];
dispopt |= DNS_DISPATCHOPT_FIXEDID;
}
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
result = dns_dispatch_addresponse(
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
request->dispatch, dispopt, request->timeout, destaddr, task,
req_connected, req_senddone, req_response, req_timeout, request,
&id, &request->dispentry);
3961. [bug] Forwarding of SIG(0) signed UPDATE messages failed with BADSIG. [RT #37216]
2014-10-01 07:24:16 +10:00
if (result != ISC_R_SUCCESS) {
if ((options & DNS_REQUESTOPT_FIXEDID) != 0 && !newtcp) {
Replace custom isc_boolean_t with C standard bool type
2018-04-17 08:29:14 -07:00
newtcp = true;
connected = false;
3961. [bug] Forwarding of SIG(0) signed UPDATE messages failed with BADSIG. [RT #37216]
2014-10-01 07:24:16 +10:00
dns_dispatch_detach(&request->dispatch);
goto again;
}
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
goto cleanup;
3961. [bug] Forwarding of SIG(0) signed UPDATE messages failed with BADSIG. [RT #37216]
2014-10-01 07:24:16 +10:00
}
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
Refactor the isc_buffer_allocate() usage using the semantic patch The isc_buffer_allocate() function now cannot fail with ISC_R_MEMORY. This commit removes all the checks on the return code using the semantic patch from previous commit, as isc_buffer_allocate() now returns void.
2020-02-02 08:35:46 +01:00
isc_buffer_allocate(mctx, &request->query, r.length + (tcp ? 2 : 0));
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
result = isc_buffer_copyregion(request->query, &r);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
goto cleanup;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
/* Add message ID. */
isc_buffer_usedregion(request->query, &r);
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
r.base[0] = (id >> 8) & 0xff;
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
r.base[1] = id & 0xff;
LOCK(&requestmgr->lock);
if (requestmgr->exiting) {
UNLOCK(&requestmgr->lock);
result = ISC_R_SHUTTINGDOWN;
goto cleanup;
}
requestmgr_attach(requestmgr, &request->requestmgr);
request->hash = mgr_gethash(requestmgr);
ISC_LIST_APPEND(requestmgr->requests, request, link);
UNLOCK(&requestmgr->lock);
1059. [func] dns_request now support will now retry UDP queries, dns_request_createvia2() and dns_request_createraw2().
2001-10-18 06:09:39 +00:00
request->destaddr = *destaddr;
Convert dispatch to netmgr The flow of operations in dispatch is changing and will now be similar for both UDP and TCP queries: 1) Call dns_dispatch_addresponse() to assign a query ID and register that we'll be listening for a response with that ID soon. the parameters for this function include callback functions to inform the caller when the socket is connected and when the message has been sent, as well as a task action that will be sent when the response arrives. (later this could become a netmgr callback, but at this stage to minimize disruption to the calling code, we continue to use isc_task for the response event.) on successful completion of this function, a dispatch entry object will be instantiated. 2) Call dns_dispatch_connect() on the dispatch entry. this runs isc_nm_udpconnect() or isc_nm_tcpdnsconnect(), as needed, and begins listening for responses. the caller is informed via a callback function when the connection is established. 3) Call dns_dispatch_send() on the dispatch entry. this runs isc_nm_send() to send a request. 4) Call dns_dispatch_removeresponse() to terminate listening and close the connection. Implementation comments below: - As we will be using netmgr buffers now. code to send the length in TCP queries has also been removed as that is handled by the netmgr. - TCP dispatches can be used by multiple simultaneous queries, so dns_dispatch_connect() now checks whether the dispatch is already connected before calling isc_nm_tcpdnsconnect() again. - Running dns_dispatch_getnext() from a non-network thread caused a crash due to assertions in the netmgr read functions that appear to be unnecessary now. the assertions have been removed. - fctx->nqueries was formerly incremented when the connection was successful, but is now incremented when the query is started and decremented if the connection fails. - It's no longer necessary for each dispatch to have a pool of tasks, so there's now a single task per dispatch. - Dispatch code to avoid UDP ports already in use has been removed. - dns_resolver and dns_request have been modified to use netmgr callback functions instead of task events. some additional changes were needed to handle shutdown processing correctly. - Timeout processing is not yet fully converted to use netmgr timeouts. - Fixed a lock order cycle reported by TSAN (view -> zone-> adb -> view) by by calling dns_zt functions without holding the view lock.
2021-01-14 13:02:57 -08:00
if (!tcp || !connected) {
result = dns_dispatch_connect(request->dispentry);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
goto unlink;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
request->flags |= DNS_REQUEST_F_CONNECTING | DNS_REQUEST_F_TCP;
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
} else {
Convert dispatch to netmgr The flow of operations in dispatch is changing and will now be similar for both UDP and TCP queries: 1) Call dns_dispatch_addresponse() to assign a query ID and register that we'll be listening for a response with that ID soon. the parameters for this function include callback functions to inform the caller when the socket is connected and when the message has been sent, as well as a task action that will be sent when the response arrives. (later this could become a netmgr callback, but at this stage to minimize disruption to the calling code, we continue to use isc_task for the response event.) on successful completion of this function, a dispatch entry object will be instantiated. 2) Call dns_dispatch_connect() on the dispatch entry. this runs isc_nm_udpconnect() or isc_nm_tcpdnsconnect(), as needed, and begins listening for responses. the caller is informed via a callback function when the connection is established. 3) Call dns_dispatch_send() on the dispatch entry. this runs isc_nm_send() to send a request. 4) Call dns_dispatch_removeresponse() to terminate listening and close the connection. Implementation comments below: - As we will be using netmgr buffers now. code to send the length in TCP queries has also been removed as that is handled by the netmgr. - TCP dispatches can be used by multiple simultaneous queries, so dns_dispatch_connect() now checks whether the dispatch is already connected before calling isc_nm_tcpdnsconnect() again. - Running dns_dispatch_getnext() from a non-network thread caused a crash due to assertions in the netmgr read functions that appear to be unnecessary now. the assertions have been removed. - fctx->nqueries was formerly incremented when the connection was successful, but is now incremented when the query is started and decremented if the connection fails. - It's no longer necessary for each dispatch to have a pool of tasks, so there's now a single task per dispatch. - Dispatch code to avoid UDP ports already in use has been removed. - dns_resolver and dns_request have been modified to use netmgr callback functions instead of task events. some additional changes were needed to handle shutdown processing correctly. - Timeout processing is not yet fully converted to use netmgr timeouts. - Fixed a lock order cycle reported by TSAN (view -> zone-> adb -> view) by by calling dns_zt functions without holding the view lock.
2021-01-14 13:02:57 -08:00
req_send(request);
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
}
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
req_log(ISC_LOG_DEBUG(3), "dns_request_createraw: request %p", request);
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
*requestp = request;
return (ISC_R_SUCCESS);
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
unlink:
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
LOCK(&requestmgr->lock);
ISC_LIST_UNLINK(requestmgr->requests, request, link);
UNLOCK(&requestmgr->lock);
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
cleanup:
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (tclone != NULL) {
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
isc_task_detach(&tclone);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
remove more duplicated code
2001-01-23 19:50:10 +00:00
req_destroy(request);
req_log(ISC_LOG_DEBUG(3), "dns_request_createraw: failed %s",
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
dns_result_totext(result));
return (result);
}
checkpoint
2000-02-24 14:31:43 +00:00
isc_result_t
dns_request_create(dns_requestmgr_t *requestmgr, dns_message_t *message,
4546. [func] Extend the use of const declarations. [RT #43379]
2016-12-30 15:45:08 +11:00
const isc_sockaddr_t *address, unsigned int options,
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
dns_tsigkey_t *key, unsigned int timeout, isc_task_t *task,
apply the modified style
2020-02-13 14:44:37 -08:00
isc_taskaction_t action, void *arg,
dns_request_t **requestp) {
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
return (dns_request_createvia(requestmgr, message, NULL, address, -1,
options, key, timeout, 0, 0, task, action,
arg, requestp));
536. [func] Use transfer-source{-v6} when sending refresh queries. Transfer-source{-v6} now take a optional port parameter for setting the UDP source port. The port parameter is ignored for TCP.
2000-10-31 01:17:19 +00:00
}
isc_result_t
dns_request_createvia(dns_requestmgr_t *requestmgr, dns_message_t *message,
4546. [func] Extend the use of const declarations. [RT #43379]
2016-12-30 15:45:08 +11:00
const isc_sockaddr_t *srcaddr,
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
const isc_sockaddr_t *destaddr, isc_dscp_t dscp,
unsigned int options, dns_tsigkey_t *key,
unsigned int timeout, unsigned int udptimeout,
unsigned int udpretries, isc_task_t *task,
isc_taskaction_t action, void *arg,
apply the modified style
2020-02-13 14:44:37 -08:00
dns_request_t **requestp) {
dns_request_t *request = NULL;
isc_task_t *tclone = NULL;
isc_result_t result;
isc_mem_t *mctx;
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
dns_messageid_t id;
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
bool tcp = false;
apply the modified style
2020-02-13 14:44:37 -08:00
bool settsigkey = true;
bool connected = false;
checkpoint
2000-02-24 14:31:43 +00:00
REQUIRE(VALID_REQUESTMGR(requestmgr));
REQUIRE(message != NULL);
536. [func] Use transfer-source{-v6} when sending refresh queries. Transfer-source{-v6} now take a optional port parameter for setting the UDP source port. The port parameter is ignored for TCP.
2000-10-31 01:17:19 +00:00
REQUIRE(destaddr != NULL);
checkpoint
2000-02-24 14:31:43 +00:00
REQUIRE(task != NULL);
REQUIRE(action != NULL);
REQUIRE(requestp != NULL && *requestp == NULL);
REQUIRE(timeout > 0);
checkpoint
2000-03-13 20:43:39 +00:00
mctx = requestmgr->mctx;
remove more duplicated code
2001-01-23 19:50:10 +00:00
req_log(ISC_LOG_DEBUG(3), "dns_request_createvia");
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
[master] fix dns_request_createvia assert 3474. [bug] nsupdate could assert when the local and remote address families didn't match. [RT #22897]
2013-01-23 15:39:05 -08:00
if (srcaddr != NULL &&
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
isc_sockaddr_pf(srcaddr) != isc_sockaddr_pf(destaddr)) {
[master] fix dns_request_createvia assert 3474. [bug] nsupdate could assert when the local and remote address families didn't match. [RT #22897]
2013-01-23 15:39:05 -08:00
return (ISC_R_FAMILYMISMATCH);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
[master] fix dns_request_createvia assert 3474. [bug] nsupdate could assert when the local and remote address families didn't match. [RT #22897]
2013-01-23 15:39:05 -08:00
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (isblackholed(requestmgr->dispatchmgr, destaddr)) {
common code elimination
2001-01-23 07:36:06 +00:00
return (DNS_R_BLACKHOLED);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
539. [func] Support the blackhole option.
2000-11-03 02:45:55 +00:00
remove more duplicated code
2001-01-23 19:50:10 +00:00
result = new_request(mctx, &request);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
remove more duplicated code
2001-01-23 19:50:10 +00:00
return (result);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
checkpoint
2000-03-13 20:43:39 +00:00
2074. [bug] dns_request_create2(), dns_request_create3(), dns_request_createraw2() and dns_request_createraw3() failed to send multiple UDP requests. [RT #16349]
2006-08-21 00:35:36 +00:00
request->udpcount = udpretries;
[master] add DSCP support 3535. [func] Add support for setting Differentiated Services Code Point (DSCP) values in named. Most configuration options which take a "port" option (e.g., listen-on, forwarders, also-notify, masters, notify-source, etc) can now also take a "dscp" option specifying a code point for use with outgoing traffic, if supported by the underlying OS. [RT #27596]
2013-03-22 12:27:54 -07:00
request->dscp = dscp;
merge 4319
2002-11-12 23:58:14 +00:00
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
request->event = (dns_requestevent_t *)isc_event_allocate(
mctx, task, DNS_EVENT_REQUESTDONE, action, arg,
sizeof(dns_requestevent_t));
checkpoint
2000-03-13 20:43:39 +00:00
isc_task_attach(task, &tclone);
convert sender, arg, action, etc. to ev_sender, ev_arg, ev_action, etc.
2000-04-17 19:22:44 +00:00
request->event->ev_sender = task;
checkpoint
2000-03-20 12:22:02 +00:00
request->event->request = request;
request->event->result = ISC_R_FAILURE;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (key != NULL) {
tsig keys were not properly ref counted
2000-07-21 23:00:31 +00:00
dns_tsigkey_attach(key, &request->tsigkey);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
Trailing whitespace trimmed. Perhaps running "perl util/spacewhack.pl in your own CVS tree will help minimize CVS conflicts. Maybe not. Blame Graff for getting me to trim all trailing whitespace.
2000-08-01 01:33:37 +00:00
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
use_tcp:
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
if ((options & DNS_REQUESTOPT_TCP) != 0) {
tcp = true;
request->timeout = timeout * 1000;
} else {
if (udptimeout == 0 && udpretries != 0) {
udptimeout = timeout / (udpretries + 1);
}
if (udptimeout == 0) {
udptimeout = 1;
}
request->timeout = udptimeout * 1000;
}
Make sharing of pending TCP dispatches nonoptional The DNS_REQUESTOPT_SHARE flag was added when client-side pipelining of TCP queries was implemented. there was no need to make it optional; forcing it to be in effect for all requests simplfiies the code.
2020-12-11 15:20:33 -08:00
result = get_dispatch(tcp, false, requestmgr, srcaddr, destaddr, dscp,
&connected, &request->dispatch);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
common code elimination
2001-01-23 07:36:06 +00:00
goto cleanup;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
common code elimination
2001-01-23 07:36:06 +00:00
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
result = dns_dispatch_addresponse(
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
request->dispatch, 0, request->timeout, destaddr, task,
req_connected, req_senddone, req_response, req_timeout, request,
&id, &request->dispentry);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
checkpoint
2000-03-13 20:43:39 +00:00
goto cleanup;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
checkpoint
2000-03-13 20:43:39 +00:00
checkpoint
2000-03-20 12:22:02 +00:00
message->id = id;
4074. [cleanup] Cleaned up more warnings from gcc -Wshadow. [RT #38708]
2015-02-27 10:55:55 +11:00
if (settsigkey) {
Check return values or cast them to (void), as required by the coding standards; add exceptions to the coding standards for cases where this is not desirable
2001-11-30 01:59:49 +00:00
result = dns_message_settsigkey(message, request->tsigkey);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
Check return values or cast them to (void), as required by the coding standards; add exceptions to the coding standards for cases where this is not desirable
2001-11-30 01:59:49 +00:00
goto cleanup;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
Check return values or cast them to (void), as required by the coding standards; add exceptions to the coding standards for cases where this is not desirable
2001-11-30 01:59:49 +00:00
}
265. [bug] dns_request_create() not works for TCP. 264. [func] Dispatch can not take TCP sockets in connecting state. Set DNS_DISPATCHATTR_CONNECTED when calling dns_dispatch_createtcp() for connected TCP sockets or call dns_dispatch_starttcp() when the socket is connected.
2000-06-20 23:54:01 +00:00
result = req_render(message, &request->query, options, mctx);
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
if (result == DNS_R_USETCP && (options & DNS_REQUESTOPT_TCP) == 0) {
checkpoint
2000-03-20 12:22:02 +00:00
/*
* Try again using TCP.
*/
dns_message_renderreset(message);
Merge the mlg-20000518 branch onto the mainline. Change summary: dns_dispatch_create() no longer exists. dns_dispatch_createtcp() and dns_dispatch_getudp() are the replacements. _createtcp() takes a bound, connected TCP socket, while _getudp() will search for a sharable UDP socket, and if found, attach to it and return a pointer to it. If one is not found, it will create a udp socket, bind it to a supplied local address, and create a new dispatcher around it. dns_dispatch_remove{request,response}() no longer take the dispatch as an argument. query-source can now be set per view. The dispatch manager holds onto three memory pools, one for allocating dispatchers from, one for events, and one for requests/replies. The free list on these pools is hard-coded, but set to 1024. This keeps us from having to dig into the isc_mem_t the pools draw from as often. dns_resolver_create() and dns_view_createresolver() require that valid dispatchers be passed in; dispatchers are no longer created for the caller.
2000-05-19 21:46:46 +00:00
dns_dispatch_removeresponse(&request->dispentry, NULL);
checkpoint
2000-03-20 12:22:02 +00:00
dns_dispatch_detach(&request->dispatch);
options |= DNS_REQUESTOPT_TCP;
Replace custom isc_boolean_t with C standard bool type
2018-04-17 08:29:14 -07:00
settsigkey = false;
checkpoint
2000-03-20 12:22:02 +00:00
goto use_tcp;
}
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
checkpoint
2000-03-13 20:43:39 +00:00
goto cleanup;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
The message code now has functions to manipulate TSIG and SIG(0), and the callers use these functions. Also a lot of TSIG cleanup.
2000-05-30 23:14:57 +00:00
result = dns_message_getquerytsig(message, mctx, &request->tsig);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
The message code now has functions to manipulate TSIG and SIG(0), and the callers use these functions. Also a lot of TSIG cleanup.
2000-05-30 23:14:57 +00:00
goto cleanup;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
The message code now has functions to manipulate TSIG and SIG(0), and the callers use these functions. Also a lot of TSIG cleanup.
2000-05-30 23:14:57 +00:00
checkpoint
2000-03-20 12:22:02 +00:00
LOCK(&requestmgr->lock);
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
if (requestmgr->exiting) {
UNLOCK(&requestmgr->lock);
result = ISC_R_SHUTTINGDOWN;
goto cleanup;
}
requestmgr_attach(requestmgr, &request->requestmgr);
add request locking. dns_request_create() failed to detach from requestmgr under certain conditions.
2000-03-22 07:00:39 +00:00
request->hash = mgr_gethash(requestmgr);
checkpoint
2000-03-20 12:22:02 +00:00
ISC_LIST_APPEND(requestmgr->requests, request, link);
UNLOCK(&requestmgr->lock);
checkpoint
2000-03-13 20:43:39 +00:00
1059. [func] dns_request now support will now retry UDP queries, dns_request_createvia2() and dns_request_createraw2().
2001-10-18 06:09:39 +00:00
request->destaddr = *destaddr;
Convert dispatch to netmgr The flow of operations in dispatch is changing and will now be similar for both UDP and TCP queries: 1) Call dns_dispatch_addresponse() to assign a query ID and register that we'll be listening for a response with that ID soon. the parameters for this function include callback functions to inform the caller when the socket is connected and when the message has been sent, as well as a task action that will be sent when the response arrives. (later this could become a netmgr callback, but at this stage to minimize disruption to the calling code, we continue to use isc_task for the response event.) on successful completion of this function, a dispatch entry object will be instantiated. 2) Call dns_dispatch_connect() on the dispatch entry. this runs isc_nm_udpconnect() or isc_nm_tcpdnsconnect(), as needed, and begins listening for responses. the caller is informed via a callback function when the connection is established. 3) Call dns_dispatch_send() on the dispatch entry. this runs isc_nm_send() to send a request. 4) Call dns_dispatch_removeresponse() to terminate listening and close the connection. Implementation comments below: - As we will be using netmgr buffers now. code to send the length in TCP queries has also been removed as that is handled by the netmgr. - TCP dispatches can be used by multiple simultaneous queries, so dns_dispatch_connect() now checks whether the dispatch is already connected before calling isc_nm_tcpdnsconnect() again. - Running dns_dispatch_getnext() from a non-network thread caused a crash due to assertions in the netmgr read functions that appear to be unnecessary now. the assertions have been removed. - fctx->nqueries was formerly incremented when the connection was successful, but is now incremented when the query is started and decremented if the connection fails. - It's no longer necessary for each dispatch to have a pool of tasks, so there's now a single task per dispatch. - Dispatch code to avoid UDP ports already in use has been removed. - dns_resolver and dns_request have been modified to use netmgr callback functions instead of task events. some additional changes were needed to handle shutdown processing correctly. - Timeout processing is not yet fully converted to use netmgr timeouts. - Fixed a lock order cycle reported by TSAN (view -> zone-> adb -> view) by by calling dns_zt functions without holding the view lock.
2021-01-14 13:02:57 -08:00
if (!tcp || !connected) {
result = dns_dispatch_connect(request->dispentry);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
goto unlink;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
request->flags |= DNS_REQUEST_F_CONNECTING | DNS_REQUEST_F_TCP;
checkpoint
2000-03-20 12:22:02 +00:00
} else {
Convert dispatch to netmgr The flow of operations in dispatch is changing and will now be similar for both UDP and TCP queries: 1) Call dns_dispatch_addresponse() to assign a query ID and register that we'll be listening for a response with that ID soon. the parameters for this function include callback functions to inform the caller when the socket is connected and when the message has been sent, as well as a task action that will be sent when the response arrives. (later this could become a netmgr callback, but at this stage to minimize disruption to the calling code, we continue to use isc_task for the response event.) on successful completion of this function, a dispatch entry object will be instantiated. 2) Call dns_dispatch_connect() on the dispatch entry. this runs isc_nm_udpconnect() or isc_nm_tcpdnsconnect(), as needed, and begins listening for responses. the caller is informed via a callback function when the connection is established. 3) Call dns_dispatch_send() on the dispatch entry. this runs isc_nm_send() to send a request. 4) Call dns_dispatch_removeresponse() to terminate listening and close the connection. Implementation comments below: - As we will be using netmgr buffers now. code to send the length in TCP queries has also been removed as that is handled by the netmgr. - TCP dispatches can be used by multiple simultaneous queries, so dns_dispatch_connect() now checks whether the dispatch is already connected before calling isc_nm_tcpdnsconnect() again. - Running dns_dispatch_getnext() from a non-network thread caused a crash due to assertions in the netmgr read functions that appear to be unnecessary now. the assertions have been removed. - fctx->nqueries was formerly incremented when the connection was successful, but is now incremented when the query is started and decremented if the connection fails. - It's no longer necessary for each dispatch to have a pool of tasks, so there's now a single task per dispatch. - Dispatch code to avoid UDP ports already in use has been removed. - dns_resolver and dns_request have been modified to use netmgr callback functions instead of task events. some additional changes were needed to handle shutdown processing correctly. - Timeout processing is not yet fully converted to use netmgr timeouts. - Fixed a lock order cycle reported by TSAN (view -> zone-> adb -> view) by by calling dns_zt functions without holding the view lock.
2021-01-14 13:02:57 -08:00
req_send(request);
checkpoint
2000-03-20 12:22:02 +00:00
}
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
req_log(ISC_LOG_DEBUG(3), "dns_request_createvia: request %p", request);
checkpoint
2000-03-20 12:22:02 +00:00
*requestp = request;
checkpoint
2000-02-24 14:31:43 +00:00
return (ISC_R_SUCCESS);
checkpoint
2000-03-13 20:43:39 +00:00
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
unlink:
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
LOCK(&requestmgr->lock);
ISC_LIST_UNLINK(requestmgr->requests, request, link);
UNLOCK(&requestmgr->lock);
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
cleanup:
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (tclone != NULL) {
checkpoint
2000-03-13 20:43:39 +00:00
isc_task_detach(&tclone);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
remove more duplicated code
2001-01-23 19:50:10 +00:00
req_destroy(request);
req_log(ISC_LOG_DEBUG(3), "dns_request_createvia: failed %s",
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
dns_result_totext(result));
checkpoint
2000-03-13 20:43:39 +00:00
return (result);
}
static isc_result_t
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
req_render(dns_message_t *message, isc_buffer_t **bufferp, unsigned int options,
apply the modified style
2020-02-13 14:44:37 -08:00
isc_mem_t *mctx) {
isc_buffer_t *buf1 = NULL;
isc_buffer_t *buf2 = NULL;
isc_result_t result;
isc_region_t r;
move compression context create/delete into the caller of the message rendering functions. This reduces the size of the message object.
2001-03-05 21:15:47 +00:00
dns_compress_t cctx;
apply the modified style
2020-02-13 14:44:37 -08:00
bool cleanup_cctx = false;
checkpoint
2000-03-13 20:43:39 +00:00
REQUIRE(bufferp != NULL && *bufferp == NULL);
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
req_log(ISC_LOG_DEBUG(3), "request_render");
checkpoint
2000-03-20 12:22:02 +00:00
checkpoint
2000-03-13 20:43:39 +00:00
/*
* Create buffer able to hold largest possible message.
*/
Refactor the isc_buffer_allocate() usage using the semantic patch The isc_buffer_allocate() function now cannot fail with ISC_R_MEMORY. This commit removes all the checks on the return code using the semantic patch from previous commit, as isc_buffer_allocate() now returns void.
2020-02-02 08:35:46 +01:00
isc_buffer_allocate(mctx, &buf1, 65535);
checkpoint
2000-03-13 20:43:39 +00:00
move compression context create/delete into the caller of the message rendering functions. This reduces the size of the message object.
2001-03-05 21:15:47 +00:00
result = dns_compress_init(&cctx, -1, mctx);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
move compression context create/delete into the caller of the message rendering functions. This reduces the size of the message object.
2001-03-05 21:15:47 +00:00
return (result);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
Replace custom isc_boolean_t with C standard bool type
2018-04-17 08:29:14 -07:00
cleanup_cctx = true;
move compression context create/delete into the caller of the message rendering functions. This reduces the size of the message object.
2001-03-05 21:15:47 +00:00
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if ((options & DNS_REQUESTOPT_CASE) != 0) {
Replace custom isc_boolean_t with C standard bool type
2018-04-17 08:29:14 -07:00
dns_compress_setsensitive(&cctx, true);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
2854. [func] nsupdate will now preserve the entered case of domain names in update requests it sends. [RT #20928]
2010-03-04 05:24:56 +00:00
checkpoint
2000-03-13 20:43:39 +00:00
/*
* Render message.
*/
move compression context create/delete into the caller of the message rendering functions. This reduces the size of the message object.
2001-03-05 21:15:47 +00:00
result = dns_message_renderbegin(message, &cctx, buf1);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
checkpoint
2000-03-13 20:43:39 +00:00
goto cleanup;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
checkpoint
2000-03-13 20:43:39 +00:00
result = dns_message_rendersection(message, DNS_SECTION_QUESTION, 0);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
checkpoint
2000-03-13 20:43:39 +00:00
goto cleanup;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
checkpoint
2000-03-13 20:43:39 +00:00
result = dns_message_rendersection(message, DNS_SECTION_ANSWER, 0);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
checkpoint
2000-03-13 20:43:39 +00:00
goto cleanup;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
checkpoint
2000-03-13 20:43:39 +00:00
result = dns_message_rendersection(message, DNS_SECTION_AUTHORITY, 0);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
checkpoint
2000-03-13 20:43:39 +00:00
goto cleanup;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
checkpoint
2000-03-13 20:43:39 +00:00
result = dns_message_rendersection(message, DNS_SECTION_ADDITIONAL, 0);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
checkpoint
2000-03-13 20:43:39 +00:00
goto cleanup;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
checkpoint
2000-03-13 20:43:39 +00:00
result = dns_message_renderend(message);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
checkpoint
2000-03-13 20:43:39 +00:00
goto cleanup;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
checkpoint
2000-03-13 20:43:39 +00:00
move compression context create/delete into the caller of the message rendering functions. This reduces the size of the message object.
2001-03-05 21:15:47 +00:00
dns_compress_invalidate(&cctx);
Replace custom isc_boolean_t with C standard bool type
2018-04-17 08:29:14 -07:00
cleanup_cctx = false;
move compression context create/delete into the caller of the message rendering functions. This reduces the size of the message object.
2001-03-05 21:15:47 +00:00
checkpoint
2000-03-13 20:43:39 +00:00
/*
* Copy rendered message to exact sized buffer.
*/
103. [func] libisc buffer API changes for <isc/buffer.h>: Added: isc_buffer_base(b) (pointer) isc_buffer_current(b) (pointer) isc_buffer_active(b) (pointer) isc_buffer_used(b) (pointer) isc_buffer_length(b) (int) isc_buffer_usedlength(b) (int) isc_buffer_consumedlength(b) (int) isc_buffer_remaininglength(b) (int) isc_buffer_activelength(b) (int) isc_buffer_availablelength(b) (int) Removed: ISC_BUFFER_USEDCOUNT(b) ISC_BUFFER_AVAILABLECOUNT(b) isc_buffer_type(b) Changed names: isc_buffer_used(b, r) -> isc_buffer_usedregion(b, r) isc_buffer_available(b, r) -> isc_buffer_available_region(b, r) isc_buffer_consumed(b, r) -> isc_buffer_consumedregion(b, r) isc_buffer_active(b, r) -> isc_buffer_activeregion(b, r) isc_buffer_remaining(b, r) -> isc_buffer_remainingregion(b, r) Buffer types were removed, so the ISC_BUFFERTYPE_* macros are no more, and the type argument to isc_buffer_init and isc_buffer_allocate were removed. isc_buffer_putstr is now void (instead of isc_result_t) and requires that the caller ensure that there is enough available buffer space for the string.
2000-04-27 00:03:12 +00:00
isc_buffer_usedregion(buf1, &r);
Convert dispatch to netmgr The flow of operations in dispatch is changing and will now be similar for both UDP and TCP queries: 1) Call dns_dispatch_addresponse() to assign a query ID and register that we'll be listening for a response with that ID soon. the parameters for this function include callback functions to inform the caller when the socket is connected and when the message has been sent, as well as a task action that will be sent when the response arrives. (later this could become a netmgr callback, but at this stage to minimize disruption to the calling code, we continue to use isc_task for the response event.) on successful completion of this function, a dispatch entry object will be instantiated. 2) Call dns_dispatch_connect() on the dispatch entry. this runs isc_nm_udpconnect() or isc_nm_tcpdnsconnect(), as needed, and begins listening for responses. the caller is informed via a callback function when the connection is established. 3) Call dns_dispatch_send() on the dispatch entry. this runs isc_nm_send() to send a request. 4) Call dns_dispatch_removeresponse() to terminate listening and close the connection. Implementation comments below: - As we will be using netmgr buffers now. code to send the length in TCP queries has also been removed as that is handled by the netmgr. - TCP dispatches can be used by multiple simultaneous queries, so dns_dispatch_connect() now checks whether the dispatch is already connected before calling isc_nm_tcpdnsconnect() again. - Running dns_dispatch_getnext() from a non-network thread caused a crash due to assertions in the netmgr read functions that appear to be unnecessary now. the assertions have been removed. - fctx->nqueries was formerly incremented when the connection was successful, but is now incremented when the query is started and decremented if the connection fails. - It's no longer necessary for each dispatch to have a pool of tasks, so there's now a single task per dispatch. - Dispatch code to avoid UDP ports already in use has been removed. - dns_resolver and dns_request have been modified to use netmgr callback functions instead of task events. some additional changes were needed to handle shutdown processing correctly. - Timeout processing is not yet fully converted to use netmgr timeouts. - Fixed a lock order cycle reported by TSAN (view -> zone-> adb -> view) by by calling dns_zt functions without holding the view lock.
2021-01-14 13:02:57 -08:00
if ((options & DNS_REQUESTOPT_TCP) == 0 && r.length > 512) {
265. [bug] dns_request_create() not works for TCP. 264. [func] Dispatch can not take TCP sockets in connecting state. Set DNS_DISPATCHATTR_CONNECTED when calling dns_dispatch_createtcp() for connected TCP sockets or call dns_dispatch_starttcp() when the socket is connected.
2000-06-20 23:54:01 +00:00
result = DNS_R_USETCP;
goto cleanup;
}
Convert dispatch to netmgr The flow of operations in dispatch is changing and will now be similar for both UDP and TCP queries: 1) Call dns_dispatch_addresponse() to assign a query ID and register that we'll be listening for a response with that ID soon. the parameters for this function include callback functions to inform the caller when the socket is connected and when the message has been sent, as well as a task action that will be sent when the response arrives. (later this could become a netmgr callback, but at this stage to minimize disruption to the calling code, we continue to use isc_task for the response event.) on successful completion of this function, a dispatch entry object will be instantiated. 2) Call dns_dispatch_connect() on the dispatch entry. this runs isc_nm_udpconnect() or isc_nm_tcpdnsconnect(), as needed, and begins listening for responses. the caller is informed via a callback function when the connection is established. 3) Call dns_dispatch_send() on the dispatch entry. this runs isc_nm_send() to send a request. 4) Call dns_dispatch_removeresponse() to terminate listening and close the connection. Implementation comments below: - As we will be using netmgr buffers now. code to send the length in TCP queries has also been removed as that is handled by the netmgr. - TCP dispatches can be used by multiple simultaneous queries, so dns_dispatch_connect() now checks whether the dispatch is already connected before calling isc_nm_tcpdnsconnect() again. - Running dns_dispatch_getnext() from a non-network thread caused a crash due to assertions in the netmgr read functions that appear to be unnecessary now. the assertions have been removed. - fctx->nqueries was formerly incremented when the connection was successful, but is now incremented when the query is started and decremented if the connection fails. - It's no longer necessary for each dispatch to have a pool of tasks, so there's now a single task per dispatch. - Dispatch code to avoid UDP ports already in use has been removed. - dns_resolver and dns_request have been modified to use netmgr callback functions instead of task events. some additional changes were needed to handle shutdown processing correctly. - Timeout processing is not yet fully converted to use netmgr timeouts. - Fixed a lock order cycle reported by TSAN (view -> zone-> adb -> view) by by calling dns_zt functions without holding the view lock.
2021-01-14 13:02:57 -08:00
isc_buffer_allocate(mctx, &buf2, r.length);
checkpoint
2000-03-13 20:43:39 +00:00
result = isc_buffer_copyregion(buf2, &r);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
checkpoint
2000-03-13 20:43:39 +00:00
goto cleanup;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
checkpoint
2000-03-13 20:43:39 +00:00
/*
* Cleanup and return.
*/
isc_buffer_free(&buf1);
*bufferp = buf2;
return (ISC_R_SUCCESS);
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
cleanup:
checkpoint
2000-03-20 12:22:02 +00:00
dns_message_renderreset(message);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (buf1 != NULL) {
checkpoint
2000-03-13 20:43:39 +00:00
isc_buffer_free(&buf1);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
if (buf2 != NULL) {
checkpoint
2000-03-13 20:43:39 +00:00
isc_buffer_free(&buf2);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
if (cleanup_cctx) {
move compression context create/delete into the caller of the message rendering functions. This reduces the size of the message object.
2001-03-05 21:15:47 +00:00
dns_compress_invalidate(&cctx);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
checkpoint
2000-03-13 20:43:39 +00:00
return (result);
checkpoint
2000-02-24 14:31:43 +00:00
}
do dns_request_t cancel processing through a control event to ensure that dns_dispatch_removeresponse() is called from the correct task [RT #844]
2001-02-13 02:49:07 +00:00
/*
* If this request is no longer waiting for events,
* send the completion event. This will ultimately
* cause the request to be destroyed.
*
* Requires:
* 'request' is locked by the caller.
*/
static void
apply the modified style
2020-02-13 14:44:37 -08:00
send_if_done(dns_request_t *request, isc_result_t result) {
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
if (request->event != NULL) {
do dns_request_t cancel processing through a control event to ensure that dns_dispatch_removeresponse() is called from the correct task [RT #844]
2001-02-13 02:49:07 +00:00
req_sendevent(request, result);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
do dns_request_t cancel processing through a control event to ensure that dns_dispatch_removeresponse() is called from the correct task [RT #844]
2001-02-13 02:49:07 +00:00
}
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
void
request_cancel(dns_request_t *request) {
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (!DNS_REQUEST_CANCELED(request)) {
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
req_log(ISC_LOG_DEBUG(3), "do_cancel: request %p", request);
request->flags |= DNS_REQUEST_F_CANCELED;
request->flags &= ~DNS_REQUEST_F_CONNECTING;
if (request->dispentry != NULL) {
dns_dispatch_cancel(NULL, request->dispentry,
DNS_REQUEST_SENDING(request),
DNS_REQUEST_CONNECTING(request));
dns_dispatch_removeresponse(&request->dispentry, NULL);
}
dns_dispatch_detach(&request->dispatch);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
do dns_request_t cancel processing through a control event to ensure that dns_dispatch_removeresponse() is called from the correct task [RT #844]
2001-02-13 02:49:07 +00:00
}
Check return values or cast them to (void), as required by the coding standards; add exceptions to the coding standards for cases where this is not desirable
2001-11-30 01:59:49 +00:00
void
apply the modified style
2020-02-13 14:44:37 -08:00
dns_request_cancel(dns_request_t *request) {
checkpoint
2000-03-20 12:22:02 +00:00
REQUIRE(VALID_REQUEST(request));
checkpoint
2000-03-13 20:43:39 +00:00
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
req_log(ISC_LOG_DEBUG(3), "dns_request_cancel: request %p", request);
add request locking. dns_request_create() failed to detach from requestmgr under certain conditions.
2000-03-22 07:00:39 +00:00
LOCK(&request->requestmgr->locks[request->hash]);
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
request_cancel(request);
send_if_done(request, ISC_R_CANCELED);
add request locking. dns_request_create() failed to detach from requestmgr under certain conditions.
2000-03-22 07:00:39 +00:00
UNLOCK(&request->requestmgr->locks[request->hash]);
checkpoint
2000-02-24 14:31:43 +00:00
}
checkpoint
2000-03-13 20:43:39 +00:00
checkpoint
2000-02-24 14:31:43 +00:00
isc_result_t
186 [func] dns_request_getresponse() has an additional arguement 'preserve_order'.
2000-05-18 02:59:20 +00:00
dns_request_getresponse(dns_request_t *request, dns_message_t *message,
apply the modified style
2020-02-13 14:44:37 -08:00
unsigned int options) {
If the request was signed with a tsig key, verify the signature on the response.
2000-07-21 20:33:13 +00:00
isc_result_t result;
checkpoint
2000-03-13 20:43:39 +00:00
REQUIRE(VALID_REQUEST(request));
REQUIRE(request->answer != NULL);
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
req_log(ISC_LOG_DEBUG(3), "dns_request_getresponse: request %p",
request);
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
Check return values or cast them to (void), as required by the coding standards; add exceptions to the coding standards for cases where this is not desirable
2001-11-30 01:59:49 +00:00
result = dns_message_setquerytsig(message, request->tsig);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
Check return values or cast them to (void), as required by the coding standards; add exceptions to the coding standards for cases where this is not desirable
2001-11-30 01:59:49 +00:00
return (result);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
Check return values or cast them to (void), as required by the coding standards; add exceptions to the coding standards for cases where this is not desirable
2001-11-30 01:59:49 +00:00
result = dns_message_settsigkey(message, request->tsigkey);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
Check return values or cast them to (void), as required by the coding standards; add exceptions to the coding standards for cases where this is not desirable
2001-11-30 01:59:49 +00:00
return (result);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
508. [func] dns_message_parse() can now do a best-effort attempt, which should allow dig to print more invalid messages.
2000-10-06 18:58:30 +00:00
result = dns_message_parse(message, request->answer, options);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
If the request was signed with a tsig key, verify the signature on the response.
2000-07-21 20:33:13 +00:00
return (result);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
if (request->tsigkey != NULL) {
The call to dns_tsig_verify doesn't need a keyring.
2000-07-21 22:22:55 +00:00
result = dns_tsig_verify(request->answer, message, NULL, NULL);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
If the request was signed with a tsig key, verify the signature on the response.
2000-07-21 20:33:13 +00:00
return (result);
checkpoint
2000-02-24 14:31:43 +00:00
}
add "mdig +yaml" output format
2019-07-20 14:35:59 -04:00
isc_buffer_t *
apply the modified style
2020-02-13 14:44:37 -08:00
dns_request_getanswer(dns_request_t *request) {
add "mdig +yaml" output format
2019-07-20 14:35:59 -04:00
REQUIRE(VALID_REQUEST(request));
return (request->answer);
}
Replace custom isc_boolean_t with C standard bool type
2018-04-17 08:29:14 -07:00
bool
apply the modified style
2020-02-13 14:44:37 -08:00
dns_request_usedtcp(dns_request_t *request) {
Add function to determine whether a given request used TCP or not.
2000-06-06 02:07:13 +00:00
REQUIRE(VALID_REQUEST(request));
Turn (int & flag) into (int & flag) != 0 when implicitly typed to bool
2018-10-11 11:57:57 +02:00
return ((request->flags & DNS_REQUEST_F_TCP) != 0);
Add function to determine whether a given request used TCP or not.
2000-06-06 02:07:13 +00:00
}
checkpoint
2000-02-24 14:31:43 +00:00
void
apply the modified style
2020-02-13 14:44:37 -08:00
dns_request_destroy(dns_request_t **requestp) {
checkpoint
2000-03-20 12:22:02 +00:00
dns_request_t *request;
Trailing whitespace trimmed. Perhaps running "perl util/spacewhack.pl in your own CVS tree will help minimize CVS conflicts. Maybe not. Blame Graff for getting me to trim all trailing whitespace.
2000-08-01 01:33:37 +00:00
checkpoint
2000-03-20 12:22:02 +00:00
REQUIRE(requestp != NULL && VALID_REQUEST(*requestp));
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
checkpoint
2000-03-20 12:22:02 +00:00
request = *requestp;
Clear the pointer to destroyed object early using the semantic patch Also disable the semantic patch as the code needs tweaks here and there because some destroy functions might not destroy the object and return early if the object is still in use.
2020-02-08 04:37:54 -08:00
*requestp = NULL;
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
req_log(ISC_LOG_DEBUG(3), "dns_request_destroy: request %p", request);
fix locking hierarchy violation [RT #1672]
2001-08-29 21:15:56 +00:00
LOCK(&request->requestmgr->lock);
add request locking. dns_request_create() failed to detach from requestmgr under certain conditions.
2000-03-22 07:00:39 +00:00
LOCK(&request->requestmgr->locks[request->hash]);
fix locking hierarchy violation [RT #1672]
2001-08-29 21:15:56 +00:00
ISC_LIST_UNLINK(request->requestmgr->requests, request, link);
more request shutdown logic fixes from Mark
2000-12-22 19:39:01 +00:00
INSIST(!DNS_REQUEST_CONNECTING(request));
642. [bug] #622 needed more work.
2000-12-31 05:05:34 +00:00
INSIST(!DNS_REQUEST_SENDING(request));
add request locking. dns_request_create() failed to detach from requestmgr under certain conditions.
2000-03-22 07:00:39 +00:00
UNLOCK(&request->requestmgr->locks[request->hash]);
fix locking hierarchy violation [RT #1672]
2001-08-29 21:15:56 +00:00
UNLOCK(&request->requestmgr->lock);
add request locking. dns_request_create() failed to detach from requestmgr under certain conditions.
2000-03-22 07:00:39 +00:00
do dns_request_t cancel processing through a control event to ensure that dns_dispatch_removeresponse() is called from the correct task [RT #844]
2001-02-13 02:49:07 +00:00
/*
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
* These should have been cleaned up before the completion
* event was sent.
do dns_request_t cancel processing through a control event to ensure that dns_dispatch_removeresponse() is called from the correct task [RT #844]
2001-02-13 02:49:07 +00:00
*/
INSIST(!ISC_LINK_LINKED(request, link));
INSIST(request->dispentry == NULL);
INSIST(request->dispatch == NULL);
more request shutdown logic fixes from Mark
2000-12-22 19:39:01 +00:00
req_destroy(request);
checkpoint
2000-02-24 14:31:43 +00:00
}
checkpoint
2000-03-20 12:22:02 +00:00
/***
*** Private: request.
***/
checkpoint
2000-03-13 20:43:39 +00:00
static void
Convert dispatch to netmgr The flow of operations in dispatch is changing and will now be similar for both UDP and TCP queries: 1) Call dns_dispatch_addresponse() to assign a query ID and register that we'll be listening for a response with that ID soon. the parameters for this function include callback functions to inform the caller when the socket is connected and when the message has been sent, as well as a task action that will be sent when the response arrives. (later this could become a netmgr callback, but at this stage to minimize disruption to the calling code, we continue to use isc_task for the response event.) on successful completion of this function, a dispatch entry object will be instantiated. 2) Call dns_dispatch_connect() on the dispatch entry. this runs isc_nm_udpconnect() or isc_nm_tcpdnsconnect(), as needed, and begins listening for responses. the caller is informed via a callback function when the connection is established. 3) Call dns_dispatch_send() on the dispatch entry. this runs isc_nm_send() to send a request. 4) Call dns_dispatch_removeresponse() to terminate listening and close the connection. Implementation comments below: - As we will be using netmgr buffers now. code to send the length in TCP queries has also been removed as that is handled by the netmgr. - TCP dispatches can be used by multiple simultaneous queries, so dns_dispatch_connect() now checks whether the dispatch is already connected before calling isc_nm_tcpdnsconnect() again. - Running dns_dispatch_getnext() from a non-network thread caused a crash due to assertions in the netmgr read functions that appear to be unnecessary now. the assertions have been removed. - fctx->nqueries was formerly incremented when the connection was successful, but is now incremented when the query is started and decremented if the connection fails. - It's no longer necessary for each dispatch to have a pool of tasks, so there's now a single task per dispatch. - Dispatch code to avoid UDP ports already in use has been removed. - dns_resolver and dns_request have been modified to use netmgr callback functions instead of task events. some additional changes were needed to handle shutdown processing correctly. - Timeout processing is not yet fully converted to use netmgr timeouts. - Fixed a lock order cycle reported by TSAN (view -> zone-> adb -> view) by by calling dns_zt functions without holding the view lock.
2021-01-14 13:02:57 -08:00
req_connected(isc_nmhandle_t *handle, isc_result_t eresult, void *arg) {
dns_request_t *request = (dns_request_t *)arg;
UNUSED(handle);
checkpoint
2000-03-13 20:43:39 +00:00
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
if (eresult == ISC_R_CANCELED) {
return;
}
Added REQUIRE's
2000-04-28 22:07:29 +00:00
REQUIRE(VALID_REQUEST(request));
checkpoint
2000-03-20 12:22:02 +00:00
REQUIRE(DNS_REQUEST_CONNECTING(request));
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
req_log(ISC_LOG_DEBUG(3), "req_connected: request %p", request);
checkpoint
2000-03-13 20:43:39 +00:00
622. [bug] A canceled request could be destroyed before dns_request_destroy() was called. [RT #562]
2000-12-19 03:36:48 +00:00
LOCK(&request->requestmgr->locks[request->hash]);
checkpoint
2000-03-20 12:22:02 +00:00
request->flags &= ~DNS_REQUEST_F_CONNECTING;
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
if (eresult == ISC_R_TIMEDOUT) {
dns_dispatch_removeresponse(&request->dispentry, NULL);
dns_dispatch_detach(&request->dispatch);
send_if_done(request, eresult);
} else if (DNS_REQUEST_CANCELED(request)) {
send_if_done(request, ISC_R_CANCELED);
} else if (eresult == ISC_R_SUCCESS) {
req_send(request);
checkpoint
2000-03-20 12:22:02 +00:00
} else {
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
request_cancel(request);
send_if_done(request, ISC_R_CANCELED);
checkpoint
2000-03-20 12:22:02 +00:00
}
622. [bug] A canceled request could be destroyed before dns_request_destroy() was called. [RT #562]
2000-12-19 03:36:48 +00:00
UNLOCK(&request->requestmgr->locks[request->hash]);
checkpoint
2000-03-20 12:22:02 +00:00
}
static void
Convert dispatch to netmgr The flow of operations in dispatch is changing and will now be similar for both UDP and TCP queries: 1) Call dns_dispatch_addresponse() to assign a query ID and register that we'll be listening for a response with that ID soon. the parameters for this function include callback functions to inform the caller when the socket is connected and when the message has been sent, as well as a task action that will be sent when the response arrives. (later this could become a netmgr callback, but at this stage to minimize disruption to the calling code, we continue to use isc_task for the response event.) on successful completion of this function, a dispatch entry object will be instantiated. 2) Call dns_dispatch_connect() on the dispatch entry. this runs isc_nm_udpconnect() or isc_nm_tcpdnsconnect(), as needed, and begins listening for responses. the caller is informed via a callback function when the connection is established. 3) Call dns_dispatch_send() on the dispatch entry. this runs isc_nm_send() to send a request. 4) Call dns_dispatch_removeresponse() to terminate listening and close the connection. Implementation comments below: - As we will be using netmgr buffers now. code to send the length in TCP queries has also been removed as that is handled by the netmgr. - TCP dispatches can be used by multiple simultaneous queries, so dns_dispatch_connect() now checks whether the dispatch is already connected before calling isc_nm_tcpdnsconnect() again. - Running dns_dispatch_getnext() from a non-network thread caused a crash due to assertions in the netmgr read functions that appear to be unnecessary now. the assertions have been removed. - fctx->nqueries was formerly incremented when the connection was successful, but is now incremented when the query is started and decremented if the connection fails. - It's no longer necessary for each dispatch to have a pool of tasks, so there's now a single task per dispatch. - Dispatch code to avoid UDP ports already in use has been removed. - dns_resolver and dns_request have been modified to use netmgr callback functions instead of task events. some additional changes were needed to handle shutdown processing correctly. - Timeout processing is not yet fully converted to use netmgr timeouts. - Fixed a lock order cycle reported by TSAN (view -> zone-> adb -> view) by by calling dns_zt functions without holding the view lock.
2021-01-14 13:02:57 -08:00
req_senddone(isc_nmhandle_t *handle, isc_result_t eresult, void *arg) {
dns_request_t *request = (dns_request_t *)arg;
checkpoint
2000-03-20 12:22:02 +00:00
Added REQUIRE's
2000-04-28 22:07:29 +00:00
REQUIRE(VALID_REQUEST(request));
642. [bug] #622 needed more work.
2000-12-31 05:05:34 +00:00
REQUIRE(DNS_REQUEST_SENDING(request));
checkpoint
2000-03-20 12:22:02 +00:00
Convert dispatch to netmgr The flow of operations in dispatch is changing and will now be similar for both UDP and TCP queries: 1) Call dns_dispatch_addresponse() to assign a query ID and register that we'll be listening for a response with that ID soon. the parameters for this function include callback functions to inform the caller when the socket is connected and when the message has been sent, as well as a task action that will be sent when the response arrives. (later this could become a netmgr callback, but at this stage to minimize disruption to the calling code, we continue to use isc_task for the response event.) on successful completion of this function, a dispatch entry object will be instantiated. 2) Call dns_dispatch_connect() on the dispatch entry. this runs isc_nm_udpconnect() or isc_nm_tcpdnsconnect(), as needed, and begins listening for responses. the caller is informed via a callback function when the connection is established. 3) Call dns_dispatch_send() on the dispatch entry. this runs isc_nm_send() to send a request. 4) Call dns_dispatch_removeresponse() to terminate listening and close the connection. Implementation comments below: - As we will be using netmgr buffers now. code to send the length in TCP queries has also been removed as that is handled by the netmgr. - TCP dispatches can be used by multiple simultaneous queries, so dns_dispatch_connect() now checks whether the dispatch is already connected before calling isc_nm_tcpdnsconnect() again. - Running dns_dispatch_getnext() from a non-network thread caused a crash due to assertions in the netmgr read functions that appear to be unnecessary now. the assertions have been removed. - fctx->nqueries was formerly incremented when the connection was successful, but is now incremented when the query is started and decremented if the connection fails. - It's no longer necessary for each dispatch to have a pool of tasks, so there's now a single task per dispatch. - Dispatch code to avoid UDP ports already in use has been removed. - dns_resolver and dns_request have been modified to use netmgr callback functions instead of task events. some additional changes were needed to handle shutdown processing correctly. - Timeout processing is not yet fully converted to use netmgr timeouts. - Fixed a lock order cycle reported by TSAN (view -> zone-> adb -> view) by by calling dns_zt functions without holding the view lock.
2021-01-14 13:02:57 -08:00
UNUSED(handle);
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
Convert dispatch to netmgr The flow of operations in dispatch is changing and will now be similar for both UDP and TCP queries: 1) Call dns_dispatch_addresponse() to assign a query ID and register that we'll be listening for a response with that ID soon. the parameters for this function include callback functions to inform the caller when the socket is connected and when the message has been sent, as well as a task action that will be sent when the response arrives. (later this could become a netmgr callback, but at this stage to minimize disruption to the calling code, we continue to use isc_task for the response event.) on successful completion of this function, a dispatch entry object will be instantiated. 2) Call dns_dispatch_connect() on the dispatch entry. this runs isc_nm_udpconnect() or isc_nm_tcpdnsconnect(), as needed, and begins listening for responses. the caller is informed via a callback function when the connection is established. 3) Call dns_dispatch_send() on the dispatch entry. this runs isc_nm_send() to send a request. 4) Call dns_dispatch_removeresponse() to terminate listening and close the connection. Implementation comments below: - As we will be using netmgr buffers now. code to send the length in TCP queries has also been removed as that is handled by the netmgr. - TCP dispatches can be used by multiple simultaneous queries, so dns_dispatch_connect() now checks whether the dispatch is already connected before calling isc_nm_tcpdnsconnect() again. - Running dns_dispatch_getnext() from a non-network thread caused a crash due to assertions in the netmgr read functions that appear to be unnecessary now. the assertions have been removed. - fctx->nqueries was formerly incremented when the connection was successful, but is now incremented when the query is started and decremented if the connection fails. - It's no longer necessary for each dispatch to have a pool of tasks, so there's now a single task per dispatch. - Dispatch code to avoid UDP ports already in use has been removed. - dns_resolver and dns_request have been modified to use netmgr callback functions instead of task events. some additional changes were needed to handle shutdown processing correctly. - Timeout processing is not yet fully converted to use netmgr timeouts. - Fixed a lock order cycle reported by TSAN (view -> zone-> adb -> view) by by calling dns_zt functions without holding the view lock.
2021-01-14 13:02:57 -08:00
req_log(ISC_LOG_DEBUG(3), "req_senddone: request %p", request);
checkpoint
2000-03-13 20:43:39 +00:00
642. [bug] #622 needed more work.
2000-12-31 05:05:34 +00:00
LOCK(&request->requestmgr->locks[request->hash]);
request->flags &= ~DNS_REQUEST_F_SENDING;
if (DNS_REQUEST_CANCELED(request)) {
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
if (eresult == ISC_R_TIMEDOUT) {
send_if_done(request, eresult);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
} else {
do dns_request_t cancel processing through a control event to ensure that dns_dispatch_removeresponse() is called from the correct task [RT #844]
2001-02-13 02:49:07 +00:00
send_if_done(request, ISC_R_CANCELED);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
Convert dispatch to netmgr The flow of operations in dispatch is changing and will now be similar for both UDP and TCP queries: 1) Call dns_dispatch_addresponse() to assign a query ID and register that we'll be listening for a response with that ID soon. the parameters for this function include callback functions to inform the caller when the socket is connected and when the message has been sent, as well as a task action that will be sent when the response arrives. (later this could become a netmgr callback, but at this stage to minimize disruption to the calling code, we continue to use isc_task for the response event.) on successful completion of this function, a dispatch entry object will be instantiated. 2) Call dns_dispatch_connect() on the dispatch entry. this runs isc_nm_udpconnect() or isc_nm_tcpdnsconnect(), as needed, and begins listening for responses. the caller is informed via a callback function when the connection is established. 3) Call dns_dispatch_send() on the dispatch entry. this runs isc_nm_send() to send a request. 4) Call dns_dispatch_removeresponse() to terminate listening and close the connection. Implementation comments below: - As we will be using netmgr buffers now. code to send the length in TCP queries has also been removed as that is handled by the netmgr. - TCP dispatches can be used by multiple simultaneous queries, so dns_dispatch_connect() now checks whether the dispatch is already connected before calling isc_nm_tcpdnsconnect() again. - Running dns_dispatch_getnext() from a non-network thread caused a crash due to assertions in the netmgr read functions that appear to be unnecessary now. the assertions have been removed. - fctx->nqueries was formerly incremented when the connection was successful, but is now incremented when the query is started and decremented if the connection fails. - It's no longer necessary for each dispatch to have a pool of tasks, so there's now a single task per dispatch. - Dispatch code to avoid UDP ports already in use has been removed. - dns_resolver and dns_request have been modified to use netmgr callback functions instead of task events. some additional changes were needed to handle shutdown processing correctly. - Timeout processing is not yet fully converted to use netmgr timeouts. - Fixed a lock order cycle reported by TSAN (view -> zone-> adb -> view) by by calling dns_zt functions without holding the view lock.
2021-01-14 13:02:57 -08:00
} else if (eresult != ISC_R_SUCCESS) {
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
request_cancel(request);
3281. [bug] SOA refresh queries could be treated as cancelled despite succeeding over the loopback interface. [RT #27782]
2012-02-07 19:50:20 +00:00
send_if_done(request, ISC_R_CANCELED);
642. [bug] #622 needed more work.
2000-12-31 05:05:34 +00:00
}
checkpoint
2000-03-13 20:43:39 +00:00
Convert dispatch to netmgr The flow of operations in dispatch is changing and will now be similar for both UDP and TCP queries: 1) Call dns_dispatch_addresponse() to assign a query ID and register that we'll be listening for a response with that ID soon. the parameters for this function include callback functions to inform the caller when the socket is connected and when the message has been sent, as well as a task action that will be sent when the response arrives. (later this could become a netmgr callback, but at this stage to minimize disruption to the calling code, we continue to use isc_task for the response event.) on successful completion of this function, a dispatch entry object will be instantiated. 2) Call dns_dispatch_connect() on the dispatch entry. this runs isc_nm_udpconnect() or isc_nm_tcpdnsconnect(), as needed, and begins listening for responses. the caller is informed via a callback function when the connection is established. 3) Call dns_dispatch_send() on the dispatch entry. this runs isc_nm_send() to send a request. 4) Call dns_dispatch_removeresponse() to terminate listening and close the connection. Implementation comments below: - As we will be using netmgr buffers now. code to send the length in TCP queries has also been removed as that is handled by the netmgr. - TCP dispatches can be used by multiple simultaneous queries, so dns_dispatch_connect() now checks whether the dispatch is already connected before calling isc_nm_tcpdnsconnect() again. - Running dns_dispatch_getnext() from a non-network thread caused a crash due to assertions in the netmgr read functions that appear to be unnecessary now. the assertions have been removed. - fctx->nqueries was formerly incremented when the connection was successful, but is now incremented when the query is started and decremented if the connection fails. - It's no longer necessary for each dispatch to have a pool of tasks, so there's now a single task per dispatch. - Dispatch code to avoid UDP ports already in use has been removed. - dns_resolver and dns_request have been modified to use netmgr callback functions instead of task events. some additional changes were needed to handle shutdown processing correctly. - Timeout processing is not yet fully converted to use netmgr timeouts. - Fixed a lock order cycle reported by TSAN (view -> zone-> adb -> view) by by calling dns_zt functions without holding the view lock.
2021-01-14 13:02:57 -08:00
UNLOCK(&request->requestmgr->locks[request->hash]);
checkpoint
2000-03-13 20:43:39 +00:00
}
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
static void
req_timeout(isc_nmhandle_t *handle, isc_result_t eresult, void *arg) {
dns_request_t *request = (dns_request_t *)arg;
REQUIRE(VALID_REQUEST(request));
UNUSED(eresult);
req_log(ISC_LOG_DEBUG(3), "req_timeout: request %p", request);
LOCK(&request->requestmgr->locks[request->hash]);
if (--request->udpcount != 0) {
isc_nmhandle_settimeout(handle, request->timeout);
if (!DNS_REQUEST_SENDING(request)) {
req_send(request);
}
}
UNLOCK(&request->requestmgr->locks[request->hash]);
}
checkpoint
2000-03-13 20:43:39 +00:00
static void
apply the modified style
2020-02-13 14:44:37 -08:00
req_response(isc_task_t *task, isc_event_t *event) {
isc_result_t result;
dns_request_t *request = event->ev_arg;
checkpoint
2000-03-13 20:43:39 +00:00
dns_dispatchevent_t *devent = (dns_dispatchevent_t *)event;
apply the modified style
2020-02-13 14:44:37 -08:00
isc_region_t r;
checkpoint
2000-03-13 20:43:39 +00:00
REQUIRE(VALID_REQUEST(request));
convert sender, arg, action, etc. to ev_sender, ev_arg, ev_action, etc.
2000-04-17 19:22:44 +00:00
REQUIRE(event->ev_type == DNS_EVENT_DISPATCH);
checkpoint
2000-03-13 20:43:39 +00:00
checkpoint
2000-03-20 12:22:02 +00:00
UNUSED(task);
Trailing whitespace trimmed. Perhaps running "perl util/spacewhack.pl in your own CVS tree will help minimize CVS conflicts. Maybe not. Blame Graff for getting me to trim all trailing whitespace.
2000-08-01 01:33:37 +00:00
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
req_log(ISC_LOG_DEBUG(3), "req_response: request %p: %s", request,
dns_result_totext(devent->result));
checkpoint
2000-03-20 12:22:02 +00:00
add request locking. dns_request_create() failed to detach from requestmgr under certain conditions.
2000-03-22 07:00:39 +00:00
LOCK(&request->requestmgr->locks[request->hash]);
checkpoint
2000-03-20 12:22:02 +00:00
result = devent->result;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
checkpoint
2000-03-13 20:43:39 +00:00
goto done;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
checkpoint
2000-03-13 20:43:39 +00:00
/*
checkpoint
2000-03-20 12:22:02 +00:00
* Copy buffer to request.
checkpoint
2000-03-13 20:43:39 +00:00
*/
103. [func] libisc buffer API changes for <isc/buffer.h>: Added: isc_buffer_base(b) (pointer) isc_buffer_current(b) (pointer) isc_buffer_active(b) (pointer) isc_buffer_used(b) (pointer) isc_buffer_length(b) (int) isc_buffer_usedlength(b) (int) isc_buffer_consumedlength(b) (int) isc_buffer_remaininglength(b) (int) isc_buffer_activelength(b) (int) isc_buffer_availablelength(b) (int) Removed: ISC_BUFFER_USEDCOUNT(b) ISC_BUFFER_AVAILABLECOUNT(b) isc_buffer_type(b) Changed names: isc_buffer_used(b, r) -> isc_buffer_usedregion(b, r) isc_buffer_available(b, r) -> isc_buffer_available_region(b, r) isc_buffer_consumed(b, r) -> isc_buffer_consumedregion(b, r) isc_buffer_active(b, r) -> isc_buffer_activeregion(b, r) isc_buffer_remaining(b, r) -> isc_buffer_remainingregion(b, r) Buffer types were removed, so the ISC_BUFFERTYPE_* macros are no more, and the type argument to isc_buffer_init and isc_buffer_allocate were removed. isc_buffer_putstr is now void (instead of isc_result_t) and requires that the caller ensure that there is enough available buffer space for the string.
2000-04-27 00:03:12 +00:00
isc_buffer_usedregion(&devent->buffer, &r);
Refactor the isc_buffer_allocate() usage using the semantic patch The isc_buffer_allocate() function now cannot fail with ISC_R_MEMORY. This commit removes all the checks on the return code using the semantic patch from previous commit, as isc_buffer_allocate() now returns void.
2020-02-02 08:35:46 +01:00
isc_buffer_allocate(request->mctx, &request->answer, r.length);
checkpoint
2000-03-20 12:22:02 +00:00
result = isc_buffer_copyregion(request->answer, &r);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (result != ISC_R_SUCCESS) {
checkpoint
2000-03-20 12:22:02 +00:00
isc_buffer_free(&request->answer);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
done:
checkpoint
2000-03-20 12:22:02 +00:00
/*
* Cleanup.
*/
Merge the mlg-20000518 branch onto the mainline. Change summary: dns_dispatch_create() no longer exists. dns_dispatch_createtcp() and dns_dispatch_getudp() are the replacements. _createtcp() takes a bound, connected TCP socket, while _getudp() will search for a sharable UDP socket, and if found, attach to it and return a pointer to it. If one is not found, it will create a udp socket, bind it to a supplied local address, and create a new dispatcher around it. dns_dispatch_remove{request,response}() no longer take the dispatch as an argument. query-source can now be set per view. The dispatch manager holds onto three memory pools, one for allocating dispatchers from, one for events, and one for requests/replies. The free list on these pools is hard-coded, but set to 1024. This keeps us from having to dig into the isc_mem_t the pools draw from as often. dns_resolver_create() and dns_view_createresolver() require that valid dispatchers be passed in; dispatchers are no longer created for the caller.
2000-05-19 21:46:46 +00:00
dns_dispatch_removeresponse(&request->dispentry, &devent);
Rewrite dns_resolver and dns_request to use netmgr timeouts - The `timeout_action` parameter to dns_dispatch_addresponse() been replaced with a netmgr callback that is called when a dispatch read times out. this callback may optionally reset the read timer and resume reading. - Added a function to convert isc_interval to milliseconds; this is used to translate fctx->interval into a value that can be passed to dns_dispatch_addresponse() as the timeout. - Note that netmgr timeouts are accurate to the millisecond, so code to check whether a timeout has been reached cannot rely on microsecond accuracy. - If serve-stale is configured, then a timeout received by the resolver may trigger it to return stale data, and then resume waiting for the read timeout. this is no longer based on a separate stale timer. - The code for canceling requests in request.c has been altered so that it can run asynchronously. - TCP timeout events apply to the dispatch, which may be shared by multiple queries. since in the event of a timeout we have no query ID to use to identify the resp we wanted, we now just send the timeout to the oldest query that was pending. - There was some additional refactoring in the resolver: combining fctx_join() and fctx_try_events() into one function to reduce code duplication, and using fixednames in fetchctx and fetchevent. - Incidental fix: new_adbaddrinfo() can't return NULL anymore, so the code can be simplified.
2021-04-22 18:58:01 -07:00
request_cancel(request);
checkpoint
2000-03-20 12:22:02 +00:00
/*
* Send completion event.
*/
do dns_request_t cancel processing through a control event to ensure that dns_dispatch_removeresponse() is called from the correct task [RT #844]
2001-02-13 02:49:07 +00:00
send_if_done(request, result);
add request locking. dns_request_create() failed to detach from requestmgr under certain conditions.
2000-03-22 07:00:39 +00:00
UNLOCK(&request->requestmgr->locks[request->hash]);
checkpoint
2000-03-13 20:43:39 +00:00
}
checkpoint
2000-03-20 12:22:02 +00:00
static void
apply the modified style
2020-02-13 14:44:37 -08:00
req_sendevent(dns_request_t *request, isc_result_t result) {
checkpoint
2000-03-20 12:22:02 +00:00
isc_task_t *task;
Added REQUIRE's
2000-04-28 22:07:29 +00:00
REQUIRE(VALID_REQUEST(request));
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
req_log(ISC_LOG_DEBUG(3), "req_sendevent: request %p", request);
remove memory leak in dns_requestmgr_create(). requestmgr now has internal and external reference counts. mctx is now attached / detached. send shutdown events once all requests have completed. dns_request_create now fails if the manager is exiting. dns_dispatch_detach(dispatchv6).
2000-04-18 08:27:48 +00:00
add request locking. dns_request_create() failed to detach from requestmgr under certain conditions.
2000-03-22 07:00:39 +00:00
/*
* Lock held by caller.
*/
convert sender, arg, action, etc. to ev_sender, ev_arg, ev_action, etc.
2000-04-17 19:22:44 +00:00
task = request->event->ev_sender;
request->event->ev_sender = request;
checkpoint
2000-03-20 12:22:02 +00:00
request->event->result = result;
isc_task_sendanddetach(&task, (isc_event_t **)&request->event);
}
static void
apply the modified style
2020-02-13 14:44:37 -08:00
req_destroy(dns_request_t *request) {
Added REQUIRE's
2000-04-28 22:07:29 +00:00
REQUIRE(VALID_REQUEST(request));
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
req_log(ISC_LOG_DEBUG(3), "req_destroy: request %p", request);
checkpoint
2000-03-20 12:22:02 +00:00
request->magic = 0;
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
if (request->query != NULL) {
checkpoint
2000-03-20 12:22:02 +00:00
isc_buffer_free(&request->query);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
if (request->answer != NULL) {
checkpoint
2000-03-20 12:22:02 +00:00
isc_buffer_free(&request->answer);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
if (request->event != NULL) {
checkpoint
2000-03-20 12:22:02 +00:00
isc_event_free((isc_event_t **)&request->event);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
if (request->dispentry != NULL) {
Merge the mlg-20000518 branch onto the mainline. Change summary: dns_dispatch_create() no longer exists. dns_dispatch_createtcp() and dns_dispatch_getudp() are the replacements. _createtcp() takes a bound, connected TCP socket, while _getudp() will search for a sharable UDP socket, and if found, attach to it and return a pointer to it. If one is not found, it will create a udp socket, bind it to a supplied local address, and create a new dispatcher around it. dns_dispatch_remove{request,response}() no longer take the dispatch as an argument. query-source can now be set per view. The dispatch manager holds onto three memory pools, one for allocating dispatchers from, one for events, and one for requests/replies. The free list on these pools is hard-coded, but set to 1024. This keeps us from having to dig into the isc_mem_t the pools draw from as often. dns_resolver_create() and dns_view_createresolver() require that valid dispatchers be passed in; dispatchers are no longer created for the caller.
2000-05-19 21:46:46 +00:00
dns_dispatch_removeresponse(&request->dispentry, NULL);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
if (request->dispatch != NULL) {
checkpoint
2000-03-20 12:22:02 +00:00
dns_dispatch_detach(&request->dispatch);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
if (request->tsig != NULL) {
The message code now has functions to manipulate TSIG and SIG(0), and the callers use these functions. Also a lot of TSIG cleanup.
2000-05-30 23:14:57 +00:00
isc_buffer_free(&request->tsig);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
if (request->tsigkey != NULL) {
tsig keys were not properly ref counted
2000-07-21 23:00:31 +00:00
dns_tsigkey_detach(&request->tsigkey);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
if (request->requestmgr != NULL) {
remove more duplicated code
2001-01-23 19:50:10 +00:00
requestmgr_detach(&request->requestmgr);
Use clang-tidy to add curly braces around one-line statements The command used to reformat the files in this commit was: ./util/run-clang-tidy \ -clang-tidy-binary clang-tidy-11 -clang-apply-replacements-binary clang-apply-replacements-11 \ -checks=-*,readability-braces-around-statements \ -j 9 \ -fix \ -format \ -style=file \ -quiet clang-format -i --style=format $(git ls-files '*.c' '*.h') uncrustify -c .uncrustify.cfg --replace --no-backup $(git ls-files '*.c' '*.h') clang-format -i --style=format $(git ls-files '*.c' '*.h')
2020-02-13 21:48:23 +01:00
}
Replace usage of isc_mem_put+isc_mem_detach with isc_mem_putanddetach Using isc_mem_put(mctx, ...) + isc_mem_detach(mctx) required juggling with the local variables when mctx was part of the freed object. The isc_mem_putanddetach function can handle this case internally, but it wasn't used everywhere. This commit apply the semantic patching plus bit of manual work to replace all such occurrences with proper usage of isc_mem_putanddetach().
2019-07-23 17:16:57 -04:00
isc_mem_putanddetach(&request->mctx, request, sizeof(*request));
checkpoint
2000-03-20 12:22:02 +00:00
}
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
static void
apply the modified style
2020-02-13 14:44:37 -08:00
req_log(int level, const char *fmt, ...) {
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
va_list ap;
va_start(ap, fmt);
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
isc_log_vwrite(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_REQUEST,
level, fmt, ap);
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
va_end(ap);
}
Reference in New Issue Copy Permalink