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

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1066 lines
26 KiB
C
Raw Normal View History

checkpoint
2000-02-24 14:31:43 +00:00
/*
update copyright notice
2012-02-07 23:47:24 +00:00
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
checkpoint
2000-02-24 14:31:43 +00:00
*
* SPDX-License-Identifier: MPL-2.0
Update the copyright information in all files in the repository This commit converts the license handling to adhere to the REUSE specification. It specifically: 1. Adds used licnses to LICENSES/ directory 2. Add "isc" template for adding the copyright boilerplate 3. Changes all source files to include copyright and SPDX license header, this includes all the C sources, documentation, zone files, configuration files. There are notes in the doc/dev/copyrights file on how to add correct headers to the new files. 4. Handle the rest that can't be modified via .reuse/dep5 file. The binary (or otherwise unmodifiable) files could have license places next to them in <foo>.license file, but this would lead to cluttered repository and most of the files handled in the .reuse/dep5 file are system test files.
2021-06-03 08:37:05 +02:00
*
checkpoint
2000-02-24 14:31:43 +00: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
* 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
*
checkpoint
2000-02-24 14:31:43 +00:00
* See the COPYRIGHT file distributed with this work for additional
format string bugs and improved format string checking [RT #1578]
2001-08-08 22:54:55 +00:00
* 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
refactor dns_request to use loopmgr callbacks dns_request_create() and _createraw() now take a 'loop' parameter and run the callback event on the specified loop. as the task manager is no longer used, it has been removed from the dns_requestmgr structure. the dns_resolver_taskmgr() function is also no longer used and has been removed.
2022-10-25 22:56:48 -07:00
#include <isc/async.h>
Convert all categories and modules into static lists Remove the complicated mechanism that could be (in theory) used by external libraries to register new categories and modules with statically defined lists in <isc/log.h>. This is similar to what we have done for <isc/result.h> result codes. All the libraries are now internal to BIND 9, so we don't need to provide a mechanism to register extra categories and modules.
2024-08-14 13:25:50 +02:00
#include <isc/log.h>
refactor dns_request to use loopmgr callbacks dns_request_create() and _createraw() now take a 'loop' parameter and run the callback event on the specified loop. as the task manager is no longer used, it has been removed from the dns_requestmgr structure. the dns_resolver_taskmgr() function is also no longer used and has been removed.
2022-10-25 22:56:48 -07:00
#include <isc/loop.h>
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>
Make isc_result a static enum Remove the dynamic registration of result codes. Convert isc_result_t from unsigned + #defines into 32-bit enum type in grand unified <isc/result.h> header. Keep the existing values of the result codes even at the expense of the description and identifier tables being unnecessary large. Additionally, add couple of: switch (result) { [...] default: break; } statements where compiler now complains about missing enum values in the switch statement.
2021-10-04 17:14:53 +02:00
#include <isc/result.h>
Add attach/detach for the dns_dispatch_send() The order in which the netievents are processed on the network manager loop is not guaranteed. Therefore the recv/read callback can come earlier than the send/write callback. The dns_request API wasn't ready for this reordering and it was destroying the dns_request_t object before the send callback has been called. Add additional attach/detach in the req_send()/req_senddone() functions to make sure we don't destroy the dns_request_t while it's still being references by asynchronous call.
2022-03-03 13:30:24 +01:00
#include <isc/thread.h>
Implement TLS transport support for dns_request and dns_dispatch This change prepares ground for sending DNS requests using DoT, which, in particular, will be used for forwarding dynamic updates to TLS-enabled primaries.
2022-09-19 11:04:22 +00:00
#include <isc/tls.h>
checkpoint
2000-03-13 20:43:39 +00:00
#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/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>
Implement TLS transport support for dns_request and dns_dispatch This change prepares ground for sending DNS requests using DoT, which, in particular, will be used for forwarding dynamic updates to TLS-enabled primaries.
2022-09-19 11:04:22 +00:00
#include <dns/transport.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
use ISC_MAGIC for all magic numbers, for our friends in EBCDIC land
2001-06-04 19:33:39 +00:00
#define REQUESTMGR_MAGIC ISC_MAGIC('R', 'q', 'u', 'M')
#define VALID_REQUESTMGR(mgr) ISC_MAGIC_VALID(mgr, REQUESTMGR_MAGIC)
checkpoint
2000-02-24 14:31:43 +00:00
use ISC_MAGIC for all magic numbers, for our friends in EBCDIC land
2001-06-04 19:33:39 +00:00
#define REQUEST_MAGIC ISC_MAGIC('R', 'q', 'u', '!')
#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;
checkpoint
2000-02-24 14:31:43 +00:00
struct dns_requestmgr {
#857 was incomplete, ISC_MAGIC was not being used everwhere it should have been. 'magic' was not being declared consistantly. some #include <isc/magic.h> were missing from other include files. NS_SERVER_VALID was not using ISC_MAGIC_VALID.
2001-08-28 03:58:29 +00:00
unsigned int magic;
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
isc_mem_t *mctx;
Refactor dispatch, resolver and request Since every dispsock was associated with a dispentry anyway (though not always vice versa), the members of dispsock have been combined into dispentry, which is now reference-counted. dispentry objects are now attached before connecting and detached afterward to prevent races between the connect callback and dns_dispatch_removeresponse(). Dispatch and dispatchmgr objects are now reference counted as well, and the shutdown process has been simplified. reference counting of resquery and request objects has also been cleaned up significantly. dns_dispatch_cancel() now flags a dispentry as having been canceled, so that if the connect callback runs after cancellation, it will not initiate a read. The isblackholed() function has been simplified.
2021-05-25 22:54:17 -07:00
isc_refcount_t references;
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
isc_loopmgr_t *loopmgr;
Refactor dispatch, resolver and request Since every dispsock was associated with a dispentry anyway (though not always vice versa), the members of dispsock have been combined into dispentry, which is now reference-counted. dispentry objects are now attached before connecting and detached afterward to prevent races between the connect callback and dns_dispatch_removeresponse(). Dispatch and dispatchmgr objects are now reference counted as well, and the shutdown process has been simplified. reference counting of resquery and request objects has also been cleaned up significantly. dns_dispatch_cancel() now flags a dispentry as having been canceled, so that if the connect callback runs after cancellation, it will not initiate a read. The isblackholed() function has been simplified.
2021-05-25 22:54:17 -07:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
atomic_bool shuttingdown;
checkpoint
2000-02-24 14:31:43 +00:00
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;
Make dns_dispatch bound to threads Instead of high number of dispatches (4 * named_g_udpdisp)[1], make the dispatches bound to threads and make dns_dispatchset_t create a dispatch for each thread (event loop). This required couple of other changes: 1. The dns_dispatch_createudp() must be called on loop, so the isc_tid() is already initialized - changes to nsupdate and mdig were required. 2. The dns_requestmgr had only a single dispatch per v4 and v6. Instead of using single dispatch, use dns_dispatchset_t for each protocol - this is same as dns_resolver.
2023-09-15 11:36:28 +02:00
dns_dispatchset_t *dispatches4;
dns_dispatchset_t *dispatches6;
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
dns_requestlist_t *requests;
checkpoint
2000-02-24 14:31:43 +00:00
};
struct dns_request {
#857 was incomplete, ISC_MAGIC was not being used everwhere it should have been. 'magic' was not being declared consistantly. some #include <isc/magic.h> were missing from other include files. NS_SERVER_VALID was not using ISC_MAGIC_VALID.
2001-08-28 03:58:29 +00:00
unsigned int magic;
Refactor dispatch, resolver and request Since every dispsock was associated with a dispentry anyway (though not always vice versa), the members of dispsock have been combined into dispentry, which is now reference-counted. dispentry objects are now attached before connecting and detached afterward to prevent races between the connect callback and dns_dispatch_removeresponse(). Dispatch and dispatchmgr objects are now reference counted as well, and the shutdown process has been simplified. reference counting of resquery and request objects has also been cleaned up significantly. dns_dispatch_cancel() now flags a dispentry as having been canceled, so that if the connect callback runs after cancellation, it will not initiate a read. The isblackholed() function has been simplified.
2021-05-25 22:54:17 -07:00
isc_refcount_t references;
implement dns_dispatchmgr_t, replacing dns_dispatchlist_t. Use it throughout the library/server.
2000-05-10 21:34:50 +00:00
isc_mem_t *mctx;
Replace custom isc_u?intNN_t types with C99 u?intNN_t types
2018-03-28 14:19:37 +02:00
int32_t flags;
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
refactor dns_request to use loopmgr callbacks dns_request_create() and _createraw() now take a 'loop' parameter and run the callback event on the specified loop. as the task manager is no longer used, it has been removed from the dns_requestmgr structure. the dns_resolver_taskmgr() function is also no longer used and has been removed.
2022-10-25 22:56:48 -07:00
isc_loop_t *loop;
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
unsigned int tid;
refactor dns_request to use loopmgr callbacks dns_request_create() and _createraw() now take a 'loop' parameter and run the callback event on the specified loop. as the task manager is no longer used, it has been removed from the dns_requestmgr structure. the dns_resolver_taskmgr() function is also no longer used and has been removed.
2022-10-25 22:56:48 -07:00
isc_result_t result;
isc_job_cb cb;
void *arg;
implement dns_dispatchmgr_t, replacing dns_dispatchlist_t. Use it throughout the library/server.
2000-05-10 21:34:50 +00:00
ISC_LINK(dns_request_t) link;
isc_buffer_t *query;
isc_buffer_t *answer;
dns_dispatch_t *dispatch;
dns_dispentry_t *dispentry;
dns_requestmgr_t *requestmgr;
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_t *tsig;
notify and zone soa queries are now tsig signed when appropriate.
2000-05-24 17:30:41 +00:00
dns_tsigkey_t *tsigkey;
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
isc_sockaddr_t destaddr;
Separate the connect and the read timeouts in dispatch The network manager layer has two different timers with their own timeout values for TCP connections: connect timeout and read timeout. Separate the connect and the read TCP timeouts in the dispatch module too.
2024-10-30 09:23:33 +00:00
unsigned int connect_timeout;
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;
merge 4319
2002-11-12 23:58:14 +00:00
unsigned int udpcount;
checkpoint
2000-03-13 20:43:39 +00:00
};
checkpoint
2000-02-24 14:31:43 +00:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
#define DNS_REQUEST_F_CONNECTING (1 << 0)
#define DNS_REQUEST_F_SENDING (1 << 1)
#define DNS_REQUEST_F_COMPLETE (1 << 2)
#define DNS_REQUEST_F_TCP (1 << 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
checkpoint
2000-03-20 12:22:02 +00:00
#define DNS_REQUEST_CONNECTING(r) (((r)->flags & DNS_REQUEST_F_CONNECTING) != 0)
642. [bug] #622 needed more work.
2000-12-31 05:05:34 +00:00
#define DNS_REQUEST_SENDING(r) (((r)->flags & DNS_REQUEST_F_SENDING) != 0)
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
#define DNS_REQUEST_COMPLETE(r) (((r)->flags & DNS_REQUEST_F_COMPLETE) != 0)
checkpoint
2000-03-20 12:22:02 +00:00
checkpoint
2000-02-24 14:31:43 +00:00
/***
*** Forward
***/
186 [func] dns_request_getresponse() has an additional arguement 'preserve_order'.
2000-05-18 02:59:20 +00:00
static isc_result_t
req_render(dns_message_t *message, isc_buffer_t **buffer, unsigned int options,
isc_mem_t *mctx);
checkpoint
2000-03-20 12:22:02 +00:00
static void
dispatch: Remove 'timeout' callback - It is no longer necessary to pass a 'timeout' callback to dns_dispatch_addresponse(); timeouts are handled directly by the 'response' callback instead. - The netmgr handle is no longer passed to dispatch callbacks, since they don't (and can't) use it. instead, dispatch_cb_t now takes a result code, region, and argument. - Cleaned up timeout-related tests in dispatch_test.c
2021-08-03 15:27:06 +02:00
req_response(isc_result_t result, isc_region_t *region, void *arg);
checkpoint
2000-03-20 12:22:02 +00:00
static void
dispatch: Remove 'timeout' callback - It is no longer necessary to pass a 'timeout' callback to dns_dispatch_addresponse(); timeouts are handled directly by the 'response' callback instead. - The netmgr handle is no longer passed to dispatch callbacks, since they don't (and can't) use it. instead, dispatch_cb_t now takes a result code, region, and argument. - Cleaned up timeout-related tests in dispatch_test.c
2021-08-03 15:27:06 +02:00
req_senddone(isc_result_t eresult, isc_region_t *region, void *arg);
checkpoint
2000-03-20 12:22:02 +00:00
static void
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
req_cleanup(dns_request_t *request);
static void
checkpoint
2000-03-20 12:22:02 +00:00
req_sendevent(dns_request_t *request, isc_result_t result);
static void
dispatch: Remove 'timeout' callback - It is no longer necessary to pass a 'timeout' callback to dns_dispatch_addresponse(); timeouts are handled directly by the 'response' callback instead. - The netmgr handle is no longer passed to dispatch callbacks, since they don't (and can't) use it. instead, dispatch_cb_t now takes a result code, region, and argument. - Cleaned up timeout-related tests in dispatch_test.c
2021-08-03 15:27:06 +02:00
req_connected(isc_result_t eresult, isc_region_t *region, void *arg);
checkpoint
2000-03-20 12:22:02 +00:00
static void
req_destroy(dns_request_t *request);
format string bugs and improved format string checking [RT #1578]
2001-08-08 22:54:55 +00:00
static void
req_log(int level, const char *fmt, ...) ISC_FORMAT_PRINTF(2, 3);
checkpoint
2000-02-24 14:31:43 +00:00
/***
*** Public
***/
isc_result_t
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
dns_requestmgr_create(isc_mem_t *mctx, isc_loopmgr_t *loopmgr,
dns_dispatchmgr_t *dispatchmgr,
checkpoint
2000-03-20 12:22:02 +00:00
dns_dispatch_t *dispatchv4, dns_dispatch_t *dispatchv6,
dns_requestmgr_t **requestmgrp) {
checkpoint
2000-02-24 14:31:43 +00:00
REQUIRE(requestmgrp != NULL && *requestmgrp == 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
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
req_log(ISC_LOG_DEBUG(3), "%s", __func__);
checkpoint
2000-02-24 14:31:43 +00:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
dns_requestmgr_t *requestmgr = isc_mem_get(mctx, sizeof(*requestmgr));
*requestmgr = (dns_requestmgr_t){
.magic = REQUESTMGR_MAGIC,
.loopmgr = loopmgr,
};
isc_mem_attach(mctx, &requestmgr->mctx);
isc_mutex_init returns 'void'
2018-11-16 15:33:22 +01:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
uint32_t nloops = isc_loopmgr_nloops(requestmgr->loopmgr);
Do extra manual isc_mem_cget() conversions Some of the cases weren't caught by the coccinelle and there were some places where cget+memmove() could get converted to simple creget().
2023-08-23 10:00:12 +02:00
requestmgr->requests = isc_mem_cget(requestmgr->mctx, nloops,
sizeof(requestmgr->requests[0]));
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
for (size_t i = 0; i < nloops; i++) {
ISC_LIST_INIT(requestmgr->requests[i]);
/* unreferenced in requests_shutdown() */
isc_loop_ref(isc_loop_get(requestmgr->loopmgr, i));
add request locking. dns_request_create() failed to detach from requestmgr under certain conditions.
2000-03-22 07:00:39 +00:00
}
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
dns_dispatchmgr_attach(dispatchmgr, &requestmgr->dispatchmgr);
checkpoint
2000-03-13 20:43:39 +00:00
if (dispatchv4 != NULL) {
Make dns_dispatch bound to threads Instead of high number of dispatches (4 * named_g_udpdisp)[1], make the dispatches bound to threads and make dns_dispatchset_t create a dispatch for each thread (event loop). This required couple of other changes: 1. The dns_dispatch_createudp() must be called on loop, so the isc_tid() is already initialized - changes to nsupdate and mdig were required. 2. The dns_requestmgr had only a single dispatch per v4 and v6. Instead of using single dispatch, use dns_dispatchset_t for each protocol - this is same as dns_resolver.
2023-09-15 11:36:28 +02:00
dns_dispatchset_create(requestmgr->mctx, dispatchv4,
&requestmgr->dispatches4,
isc_loopmgr_nloops(requestmgr->loopmgr));
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
if (dispatchv6 != NULL) {
Make dns_dispatch bound to threads Instead of high number of dispatches (4 * named_g_udpdisp)[1], make the dispatches bound to threads and make dns_dispatchset_t create a dispatch for each thread (event loop). This required couple of other changes: 1. The dns_dispatch_createudp() must be called on loop, so the isc_tid() is already initialized - changes to nsupdate and mdig were required. 2. The dns_requestmgr had only a single dispatch per v4 and v6. Instead of using single dispatch, use dns_dispatchset_t for each protocol - this is same as dns_resolver.
2023-09-15 11:36:28 +02:00
dns_dispatchset_create(requestmgr->mctx, dispatchv6,
&requestmgr->dispatches6,
isc_loopmgr_nloops(requestmgr->loopmgr));
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
}
dispatch: Fix several connect-related issues - startrecv() and getnext() have been rewritten. - Don't set TCP flag when connecting a UDP dispatch. - Prevent TCP connections from trying to connect twice. - dns_dispatch_gettcp() can now find a matching TCP dispatch that has not yet fully connected, and attach to it. when the connection is completed, the connect callbacks are run for all of the pending entries. - An atomic 'state' variable is now used for connection state instead of attributes. - When dns_dispatch_cancel() is called on a TCP dispatch entry, only that one entry is canceled. the dispatch itself should not be shut down until there are no dispatch entries left associated with it. - Other incidental cleanup, including removing DNS_DISPATCHATTR_IPV4 and _IPV6 (they were being set in the dispatch attributes but never used), cleaning up dns_requestmgr_create(), and renaming dns_dispatch_read() to the more descriptive dns_dispatch_resume().
2021-08-03 18:24:27 -07:00
Refactor dispatch, resolver and request Since every dispsock was associated with a dispentry anyway (though not always vice versa), the members of dispsock have been combined into dispentry, which is now reference-counted. dispentry objects are now attached before connecting and detached afterward to prevent races between the connect callback and dns_dispatch_removeresponse(). Dispatch and dispatchmgr objects are now reference counted as well, and the shutdown process has been simplified. reference counting of resquery and request objects has also been cleaned up significantly. dns_dispatch_cancel() now flags a dispentry as having been canceled, so that if the connect callback runs after cancellation, it will not initiate a read. The isblackholed() function has been simplified.
2021-05-25 22:54:17 -07:00
isc_refcount_init(&requestmgr->references, 1);
dispatch: Fix several connect-related issues - startrecv() and getnext() have been rewritten. - Don't set TCP flag when connecting a UDP dispatch. - Prevent TCP connections from trying to connect twice. - dns_dispatch_gettcp() can now find a matching TCP dispatch that has not yet fully connected, and attach to it. when the connection is completed, the connect callbacks are run for all of the pending entries. - An atomic 'state' variable is now used for connection state instead of attributes. - When dns_dispatch_cancel() is called on a TCP dispatch entry, only that one entry is canceled. the dispatch itself should not be shut down until there are no dispatch entries left associated with it. - Other incidental cleanup, including removing DNS_DISPATCHATTR_IPV4 and _IPV6 (they were being set in the dispatch attributes but never used), cleaning up dns_requestmgr_create(), and renaming dns_dispatch_read() to the more descriptive dns_dispatch_resume().
2021-08-03 18:24:27 -07:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
req_log(ISC_LOG_DEBUG(3), "%s: %p", __func__, requestmgr);
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
*requestmgrp = requestmgr;
checkpoint
2000-02-24 14:31:43 +00:00
return ISC_R_SUCCESS;
}
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
static void
requests_shutdown(void *arg) {
dns_requestmgr_t *requestmgr = arg;
uint32_t tid = isc_tid();
implicitly declare list elements in ISC_LIST_FOREACH macros ISC_LIST_FOREACH and related macros now use 'typeof(list.head)' to declare the list elements automatically; the caller no longer needs to do so. ISC_LIST_FOREACH_SAFE also now implicitly declares its own 'next' pointer, so it only needs three parameters instead of four.
2025-03-20 15:46:35 -07:00
ISC_LIST_FOREACH_SAFE (requestmgr->requests[tid], request, link) {
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
req_log(ISC_LOG_DEBUG(3), "%s(%" PRIu32 ": request %p",
__func__, tid, request);
if (DNS_REQUEST_COMPLETE(request)) {
/* The callback has been already scheduled */
continue;
}
req_sendevent(request, ISC_R_SHUTTINGDOWN);
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
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
isc_loop_unref(isc_loop_get(requestmgr->loopmgr, tid));
dns_requestmgr_detach(&requestmgr);
checkpoint
2000-02-24 14:31:43 +00:00
}
void
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
dns_requestmgr_shutdown(dns_requestmgr_t *requestmgr) {
Restore dns_requestmgr_shutdown re-entrancy In the conversion to rcu the ability to call dns_requestmgr_shutdown multiple times was lost. nsupdate depended on this. Restore support for that.
2024-01-18 13:43:30 +11:00
bool first;
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
REQUIRE(VALID_REQUESTMGR(requestmgr));
Refactor dispatch, resolver and request Since every dispsock was associated with a dispentry anyway (though not always vice versa), the members of dispsock have been combined into dispentry, which is now reference-counted. dispentry objects are now attached before connecting and detached afterward to prevent races between the connect callback and dns_dispatch_removeresponse(). Dispatch and dispatchmgr objects are now reference counted as well, and the shutdown process has been simplified. reference counting of resquery and request objects has also been cleaned up significantly. dns_dispatch_cancel() now flags a dispentry as having been canceled, so that if the connect callback runs after cancellation, it will not initiate a read. The isblackholed() function has been simplified.
2021-05-25 22:54:17 -07:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
req_log(ISC_LOG_DEBUG(3), "%s: %p", __func__, requestmgr);
checkpoint
2000-02-24 14:31:43 +00:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
rcu_read_lock();
Restore dns_requestmgr_shutdown re-entrancy In the conversion to rcu the ability to call dns_requestmgr_shutdown multiple times was lost. nsupdate depended on this. Restore support for that.
2024-01-18 13:43:30 +11:00
first = atomic_compare_exchange_strong(&requestmgr->shuttingdown,
&(bool){ false }, true);
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
rcu_read_unlock();
Refactor dispatch, resolver and request Since every dispsock was associated with a dispentry anyway (though not always vice versa), the members of dispsock have been combined into dispentry, which is now reference-counted. dispentry objects are now attached before connecting and detached afterward to prevent races between the connect callback and dns_dispatch_removeresponse(). Dispatch and dispatchmgr objects are now reference counted as well, and the shutdown process has been simplified. reference counting of resquery and request objects has also been cleaned up significantly. dns_dispatch_cancel() now flags a dispentry as having been canceled, so that if the connect callback runs after cancellation, it will not initiate a read. The isblackholed() function has been simplified.
2021-05-25 22:54:17 -07:00
Restore dns_requestmgr_shutdown re-entrancy In the conversion to rcu the ability to call dns_requestmgr_shutdown multiple times was lost. nsupdate depended on this. Restore support for that.
2024-01-18 13:43:30 +11:00
if (!first) {
return;
}
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
/*
* Wait until all dns_request_create{raw}() are finished, so
* there will be no new requests added to the lists.
*/
synchronize_rcu();
checkpoint
2000-02-24 14:31:43 +00:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
uint32_t tid = isc_tid();
uint32_t nloops = isc_loopmgr_nloops(requestmgr->loopmgr);
for (size_t i = 0; i < nloops; i++) {
dns_requestmgr_ref(requestmgr);
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
if (i == tid) {
/* Run the current loop synchronously */
requests_shutdown(requestmgr);
continue;
}
checkpoint
2000-02-24 14:31:43 +00:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
isc_loop_t *loop = isc_loop_get(requestmgr->loopmgr, i);
isc_async_run(loop, requests_shutdown, 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
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
requestmgr_destroy(dns_requestmgr_t *requestmgr) {
req_log(ISC_LOG_DEBUG(3), "%s", __func__);
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
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
INSIST(atomic_load(&requestmgr->shuttingdown));
add request locking. dns_request_create() failed to detach from requestmgr under certain conditions.
2000-03-22 07:00:39 +00:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
size_t nloops = isc_loopmgr_nloops(requestmgr->loopmgr);
for (size_t i = 0; i < nloops; i++) {
INSIST(ISC_LIST_EMPTY(requestmgr->requests[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
}
Apply the isc_mem_cget semantic patch
2023-08-23 08:56:31 +02:00
isc_mem_cput(requestmgr->mctx, requestmgr->requests, nloops,
sizeof(requestmgr->requests[0]));
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
Make dns_dispatch bound to threads Instead of high number of dispatches (4 * named_g_udpdisp)[1], make the dispatches bound to threads and make dns_dispatchset_t create a dispatch for each thread (event loop). This required couple of other changes: 1. The dns_dispatch_createudp() must be called on loop, so the isc_tid() is already initialized - changes to nsupdate and mdig were required. 2. The dns_requestmgr had only a single dispatch per v4 and v6. Instead of using single dispatch, use dns_dispatchset_t for each protocol - this is same as dns_resolver.
2023-09-15 11:36:28 +02:00
if (requestmgr->dispatches4 != NULL) {
dns_dispatchset_destroy(&requestmgr->dispatches4);
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
}
Make dns_dispatch bound to threads Instead of high number of dispatches (4 * named_g_udpdisp)[1], make the dispatches bound to threads and make dns_dispatchset_t create a dispatch for each thread (event loop). This required couple of other changes: 1. The dns_dispatch_createudp() must be called on loop, so the isc_tid() is already initialized - changes to nsupdate and mdig were required. 2. The dns_requestmgr had only a single dispatch per v4 and v6. Instead of using single dispatch, use dns_dispatchset_t for each protocol - this is same as dns_resolver.
2023-09-15 11:36:28 +02:00
if (requestmgr->dispatches6 != NULL) {
dns_dispatchset_destroy(&requestmgr->dispatches6);
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
}
dispatch: Fix several connect-related issues - startrecv() and getnext() have been rewritten. - Don't set TCP flag when connecting a UDP dispatch. - Prevent TCP connections from trying to connect twice. - dns_dispatch_gettcp() can now find a matching TCP dispatch that has not yet fully connected, and attach to it. when the connection is completed, the connect callbacks are run for all of the pending entries. - An atomic 'state' variable is now used for connection state instead of attributes. - When dns_dispatch_cancel() is called on a TCP dispatch entry, only that one entry is canceled. the dispatch itself should not be shut down until there are no dispatch entries left associated with it. - Other incidental cleanup, including removing DNS_DISPATCHATTR_IPV4 and _IPV6 (they were being set in the dispatch attributes but never used), cleaning up dns_requestmgr_create(), and renaming dns_dispatch_read() to the more descriptive dns_dispatch_resume().
2021-08-03 18:24:27 -07:00
if (requestmgr->dispatchmgr != NULL) {
dns_dispatchmgr_detach(&requestmgr->dispatchmgr);
}
checkpoint
2000-03-13 20:43:39 +00:00
requestmgr->magic = 0;
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(&requestmgr->mctx, requestmgr,
sizeof(*requestmgr));
checkpoint
2000-02-24 14:31:43 +00:00
}
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
#if DNS_REQUEST_TRACE
ISC_REFCOUNT_TRACE_IMPL(dns_requestmgr, requestmgr_destroy);
#else
ISC_REFCOUNT_IMPL(dns_requestmgr, requestmgr_destroy);
#endif
add request locking. dns_request_create() failed to detach from requestmgr under certain conditions.
2000-03-22 07:00:39 +00:00
Remove use of the inline keyword used as suggestion to compiler Historically, the inline keyword was a strong suggestion to the compiler that it should inline the function marked inline. As compilers became better at optimising, this functionality has receded, and using inline as a suggestion to inline a function is obsolete. The compiler will happily ignore it and inline something else entirely if it finds that's a better optimisation. Therefore, remove all the occurences of the inline keyword with static functions inside single compilation unit and leave the decision whether to inline a function or not entirely on the compiler NOTE: We keep the usage the inline keyword when the purpose is to change the linkage behaviour.
2021-10-11 13:43:12 +02: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_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
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
req_log(ISC_LOG_DEBUG(3), "%s: request %p", __func__, request);
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
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;
Add attach/detach for the dns_dispatch_send() The order in which the netievents are processed on the network manager loop is not guaranteed. Therefore the recv/read callback can come earlier than the send/write callback. The dns_request API wasn't ready for this reordering and it was destroying the dns_request_t object before the send callback has been called. Add additional attach/detach in the req_send()/req_senddone() functions to make sure we don't destroy the dns_request_t while it's still being references by asynchronous call.
2022-03-03 13:30:24 +01:00
/* detached in req_senddone() */
refactor dns_request to use loopmgr callbacks dns_request_create() and _createraw() now take a 'loop' parameter and run the callback event on the specified loop. as the task manager is no longer used, it has been removed from the dns_requestmgr structure. the dns_resolver_taskmgr() function is also no longer used and has been removed.
2022-10-25 22:56:48 -07:00
dns_request_ref(request);
remove nonfunctional DSCP implementation DSCP has not been fully working since the network manager was introduced in 9.16, and has been completely broken since 9.18. This seems to have caused very few difficulties for anyone, so we have now marked it as obsolete and removed the implementation. To ensure that old config files don't fail, the code to parse dscp key-value pairs is still present, but a warning is logged that the feature is obsolete and should not be used. Nothing is done with configured values, and there is no longer any range checking.
2023-01-05 22:18:55 -08:00
dns_dispatch_send(request->dispentry, &r);
checkpoint
2000-03-20 12:22:02 +00:00
}
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
static dns_request_t *
new_request(isc_mem_t *mctx, isc_loop_t *loop, isc_job_cb cb, void *arg,
Separate the connect and the read timeouts in dispatch The network manager layer has two different timers with their own timeout values for TCP connections: connect timeout and read timeout. Separate the connect and the read TCP timeouts in the dispatch module too.
2024-10-30 09:23:33 +00:00
bool tcp, unsigned int connect_timeout, unsigned int timeout,
unsigned int udptimeout, unsigned int udpretries) {
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
dns_request_t *request = isc_mem_get(mctx, sizeof(*request));
*request = (dns_request_t){
.magic = REQUEST_MAGIC,
.loop = loop,
.tid = isc_tid(),
.cb = cb,
.arg = arg,
.link = ISC_LINK_INITIALIZER,
.result = ISC_R_FAILURE,
.udpcount = udpretries + 1,
};
remove more duplicated code
2001-01-23 19:50:10 +00:00
Refactor dispatch, resolver and request Since every dispsock was associated with a dispentry anyway (though not always vice versa), the members of dispsock have been combined into dispentry, which is now reference-counted. dispentry objects are now attached before connecting and detached afterward to prevent races between the connect callback and dns_dispatch_removeresponse(). Dispatch and dispatchmgr objects are now reference counted as well, and the shutdown process has been simplified. reference counting of resquery and request objects has also been cleaned up significantly. dns_dispatch_cancel() now flags a dispentry as having been canceled, so that if the connect callback runs after cancellation, it will not initiate a read. The isblackholed() function has been simplified.
2021-05-25 22:54:17 -07:00
isc_refcount_init(&request->references, 1);
remove more duplicated code
2001-01-23 19:50:10 +00:00
isc_mem_attach(mctx, &request->mctx);
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
if (tcp) {
Separate the connect and the read timeouts in dispatch The network manager layer has two different timers with their own timeout values for TCP connections: connect timeout and read timeout. Separate the connect and the read TCP timeouts in the dispatch module too.
2024-10-30 09:23:33 +00:00
request->connect_timeout = connect_timeout * 1000;
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
request->timeout = timeout * 1000;
} else {
if (udptimeout == 0) {
udptimeout = timeout / request->udpcount;
}
if (udptimeout == 0) {
udptimeout = 1;
}
request->timeout = udptimeout * 1000;
}
return request;
remove more duplicated code
2001-01-23 19:50:10 +00:00
}
Replace custom isc_boolean_t with C standard bool type
2018-04-17 08:29:14 -07:00
static bool
4546. [func] Extend the use of const declarations. [RT #43379]
2016-12-30 15:45:08 +11:00
isblackholed(dns_dispatchmgr_t *dispatchmgr, const isc_sockaddr_t *destaddr) {
removed more needless attaching and detaching of the blackhole ACL
2001-02-09 00:23:16 +00:00
dns_acl_t *blackhole;
common code elimination
2001-01-23 07:36:06 +00:00
isc_netaddr_t netaddr;
char netaddrstr[ISC_NETADDR_FORMATSIZE];
Refactor dispatch, resolver and request Since every dispsock was associated with a dispentry anyway (though not always vice versa), the members of dispsock have been combined into dispentry, which is now reference-counted. dispentry objects are now attached before connecting and detached afterward to prevent races between the connect callback and dns_dispatch_removeresponse(). Dispatch and dispatchmgr objects are now reference counted as well, and the shutdown process has been simplified. reference counting of resquery and request objects has also been cleaned up significantly. dns_dispatch_cancel() now flags a dispentry as having been canceled, so that if the connect callback runs after cancellation, it will not initiate a read. The isblackholed() function has been simplified.
2021-05-25 22:54:17 -07:00
int match;
isc_result_t result;
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);
Refactor dispatch, resolver and request Since every dispsock was associated with a dispentry anyway (though not always vice versa), the members of dispsock have been combined into dispentry, which is now reference-counted. dispentry objects are now attached before connecting and detached afterward to prevent races between the connect callback and dns_dispatch_removeresponse(). Dispatch and dispatchmgr objects are now reference counted as well, and the shutdown process has been simplified. reference counting of resquery and request objects has also been cleaned up significantly. dns_dispatch_cancel() now flags a dispentry as having been canceled, so that if the connect callback runs after cancellation, it will not initiate a read. The isblackholed() function has been simplified.
2021-05-25 22:54:17 -07:00
if (blackhole == NULL) {
return false;
common code elimination
2001-01-23 07:36:06 +00:00
}
Refactor dispatch, resolver and request Since every dispsock was associated with a dispentry anyway (though not always vice versa), the members of dispsock have been combined into dispentry, which is now reference-counted. dispentry objects are now attached before connecting and detached afterward to prevent races between the connect callback and dns_dispatch_removeresponse(). Dispatch and dispatchmgr objects are now reference counted as well, and the shutdown process has been simplified. reference counting of resquery and request objects has also been cleaned up significantly. dns_dispatch_cancel() now flags a dispentry as having been canceled, so that if the connect callback runs after cancellation, it will not initiate a read. The isblackholed() function has been simplified.
2021-05-25 22:54:17 -07:00
isc_netaddr_fromsockaddr(&netaddr, destaddr);
result = dns_acl_match(&netaddr, NULL, blackhole, NULL, &match, NULL);
negative 'blackhole' ACL match could be treated as positive There was a bug in the checking of the "blackhole" ACL in dns_request_create*(), causing an address to be treated as included in the ACL if it was explicitly *excluded*. Thus, leaving "blackhole" unset had no effect, but setting it to "none" would cause any destination addresses to be rejected for dns_request purposes. This would cause zone transfer requests and SOA queries to fail, among other things. The bug has been fixed, and "blackhole { none; };" was added to the xfer system test as a regression test.
2022-02-16 15:46:33 -08:00
if (result != ISC_R_SUCCESS || match <= 0) {
Refactor dispatch, resolver and request Since every dispsock was associated with a dispentry anyway (though not always vice versa), the members of dispsock have been combined into dispentry, which is now reference-counted. dispentry objects are now attached before connecting and detached afterward to prevent races between the connect callback and dns_dispatch_removeresponse(). Dispatch and dispatchmgr objects are now reference counted as well, and the shutdown process has been simplified. reference counting of resquery and request objects has also been cleaned up significantly. dns_dispatch_cancel() now flags a dispentry as having been canceled, so that if the connect callback runs after cancellation, it will not initiate a read. The isblackholed() function has been simplified.
2021-05-25 22:54:17 -07:00
return false;
common code elimination
2001-01-23 07:36:06 +00:00
}
Refactor dispatch, resolver and request Since every dispsock was associated with a dispentry anyway (though not always vice versa), the members of dispsock have been combined into dispentry, which is now reference-counted. dispentry objects are now attached before connecting and detached afterward to prevent races between the connect callback and dns_dispatch_removeresponse(). Dispatch and dispatchmgr objects are now reference counted as well, and the shutdown process has been simplified. reference counting of resquery and request objects has also been cleaned up significantly. dns_dispatch_cancel() now flags a dispentry as having been canceled, so that if the connect callback runs after cancellation, it will not initiate a read. The isblackholed() function has been simplified.
2021-05-25 22:54:17 -07:00
isc_netaddr_format(&netaddr, netaddrstr, sizeof(netaddrstr));
req_log(ISC_LOG_DEBUG(10), "blackholed address %s", netaddrstr);
return true;
common code elimination
2001-01-23 07:36:06 +00:00
}
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,
Fix TCP dispatches and transport Dispatch needs to know the transport that is being used over the TCP connection to correctly allow for it to be reused. Add a transport parameter to dns_dispatch_createtcp and dns_dispatch_gettcp and use it when selecting a TCP socket for reuse.
2024-10-15 16:09:48 +11:00
dns_transport_t *transport, dns_dispatch_t **dispatchp) {
common code elimination
2001-01-23 07:36:06 +00:00
isc_result_t result;
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) {
libdns refactoring: get rid of multiple versions of dns_dispatch_createtcp and dns_dispatch_addresponse, unify dns_dispatch_gettcp and dns_dispatch_gettcp2
2018-04-03 14:35:07 +02:00
result = dns_dispatch_gettcp(requestmgr->dispatchmgr, destaddr,
Fix TCP dispatches and transport Dispatch needs to know the transport that is being used over the TCP connection to correctly allow for it to be reused. Add a transport parameter to dns_dispatch_createtcp and dns_dispatch_gettcp and use it when selecting a TCP socket for reuse.
2024-10-15 16:09:48 +11:00
srcaddr, transport, 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));
req_log(ISC_LOG_DEBUG(1),
Fix the thread safety in the dns_dispatch unit The dispatches are not thread-bound, and used freely between various threads (see the dns_resolver and dns_request units for details). This refactoring make sure that all non-const dns_dispatch_t and dns_dispentry_t members are accessed under a lock, and both object now track their internal state (NONE, CONNECTING, CONNECTED, CANCELED) instead of guessing the state from the state of various struct members. During the refactoring, the artificial limit DNS_DISPATCH_SOCKSQUOTA on UDP sockets per dispatch was removed as the limiting needs to happen and happens on in dns_resolver and limiting the number of UDP sockets artificially in dispatch could lead to unpredictable behaviour in case one dispatch has the limit exhausted by others are idle. The TCP artificial limit of DNS_DISPATCH_MAXREQUESTS makes even less sense as the TCP connections are only reused in the dns_request API that's not a heavy user of the outgoing connections. As a side note, the fact that UDP and TCP dispatch pretends to be same thing, but in fact the connected UDP is handled from dns_dispentry_t and dns_dispatch_t acts as a broker, but connected TCP is handled from dns_dispatch_t and dns_dispatchmgr_t acts as a broker doesn't really help the clarity of this unit. This refactoring kept to API almost same - only dns_dispatch_cancel() and dns_dispatch_done() were merged into dns_dispatch_done() as we need to cancel active netmgr handles in any case to not leave dangling connections around. The functions handling UDP and TCP have been mostly split to their matching counterparts and the dns_dispatch_<function> functions are now thing wrappers that call <udp|tcp>_dispatch_<function> based on the socket type. More debugging-level logging was added to the unit to accomodate for this fact.
2022-11-30 17:58:35 +01:00
"attached to TCP connection to %s", peer);
[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
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
}
dispatch: Refactor to eliminate dns_dispatchevent - Responses received by the dispatch are no longer sent to the caller via a task event, but via a netmgr-style recv callback. the 'action' parameter to dns_dispatch_addresponse() is now called 'response' and is called directly from udp_recv() or tcp_recv() when a valid response has been received. - All references to isc_task and isc_taskmgr have been removed from dispatch functions. - All references to dns_dispatchevent_t have been removed and the type has been deleted. - Added a task to the resolver response context, to be used for fctx events. - When the caller cancels an operation, the response handler will be called with ISC_R_CANCELED; it can abort immediately since the caller will presumably have taken care of cleanup already. - Cleaned up attach/detach in resquery and request.
2021-07-26 20:23:18 -07:00
result = dns_dispatch_createtcp(requestmgr->dispatchmgr, srcaddr,
Fix TCP dispatches and transport Dispatch needs to know the transport that is being used over the TCP connection to correctly allow for it to be reused. Add a transport parameter to dns_dispatch_createtcp and dns_dispatch_gettcp and use it when selecting a TCP socket for reuse.
2024-10-15 16:09:48 +11:00
destaddr, transport, 0, 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:
Make dns_dispatch bound to threads Instead of high number of dispatches (4 * named_g_udpdisp)[1], make the dispatches bound to threads and make dns_dispatchset_t create a dispatch for each thread (event loop). This required couple of other changes: 1. The dns_dispatch_createudp() must be called on loop, so the isc_tid() is already initialized - changes to nsupdate and mdig were required. 2. The dns_requestmgr had only a single dispatch per v4 and v6. Instead of using single dispatch, use dns_dispatchset_t for each protocol - this is same as dns_resolver.
2023-09-15 11:36:28 +02:00
disp = dns_dispatchset_get(requestmgr->dispatches4);
common code elimination
2001-01-23 07:36:06 +00:00
break;
case PF_INET6:
Make dns_dispatch bound to threads Instead of high number of dispatches (4 * named_g_udpdisp)[1], make the dispatches bound to threads and make dns_dispatchset_t create a dispatch for each thread (event loop). This required couple of other changes: 1. The dns_dispatch_createudp() must be called on loop, so the isc_tid() is already initialized - changes to nsupdate and mdig were required. 2. The dns_requestmgr had only a single dispatch per v4 and v6. Instead of using single dispatch, use dns_dispatchset_t for each protocol - this is same as dns_resolver.
2023-09-15 11:36:28 +02:00
disp = dns_dispatchset_get(requestmgr->dispatches6);
common code elimination
2001-01-23 07:36:06 +00:00
break;
default:
return ISC_R_NOTIMPLEMENTED;
}
if (disp == NULL) {
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
dispatch: Fix several connect-related issues - startrecv() and getnext() have been rewritten. - Don't set TCP flag when connecting a UDP dispatch. - Prevent TCP connections from trying to connect twice. - dns_dispatch_gettcp() can now find a matching TCP dispatch that has not yet fully connected, and attach to it. when the connection is completed, the connect callbacks are run for all of the pending entries. - An atomic 'state' variable is now used for connection state instead of attributes. - When dns_dispatch_cancel() is called on a TCP dispatch entry, only that one entry is canceled. the dispatch itself should not be shut down until there are no dispatch entries left associated with it. - Other incidental cleanup, including removing DNS_DISPATCHATTR_IPV4 and _IPV6 (they were being set in the dispatch attributes but never used), cleaning up dns_requestmgr_create(), and renaming dns_dispatch_read() to the more descriptive dns_dispatch_resume().
2021-08-03 18:24:27 -07:00
return dns_dispatch_createudp(requestmgr->dispatchmgr, srcaddr,
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
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,
Fix TCP dispatches and transport Dispatch needs to know the transport that is being used over the TCP connection to correctly allow for it to be reused. Add a transport parameter to dns_dispatch_createtcp and dns_dispatch_gettcp and use it when selecting a TCP socket for reuse.
2024-10-15 16:09:48 +11:00
dns_transport_t *transport, 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
common code elimination
2001-01-23 07:36:06 +00: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,
Fix TCP dispatches and transport Dispatch needs to know the transport that is being used over the TCP connection to correctly allow for it to be reused. Add a transport parameter to dns_dispatch_createtcp and dns_dispatch_gettcp and use it when selecting a TCP socket for reuse.
2024-10-15 16:09:48 +11:00
transport, dispatchp);
common code elimination
2001-01-23 07:36:06 +00: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,
Implement TLS transport support for dns_request and dns_dispatch This change prepares ground for sending DNS requests using DoT, which, in particular, will be used for forwarding dynamic updates to TLS-enabled primaries.
2022-09-19 11:04:22 +00:00
const isc_sockaddr_t *destaddr,
dns_transport_t *transport,
remove nonfunctional DSCP implementation DSCP has not been fully working since the network manager was introduced in 9.16, and has been completely broken since 9.18. This seems to have caused very few difficulties for anyone, so we have now marked it as obsolete and removed the implementation. To ensure that old config files don't fail, the code to parse dscp key-value pairs is still present, but a warning is logged that the feature is obsolete and should not be used. Nothing is done with configured values, and there is no longer any range checking.
2023-01-05 22:18:55 -08:00
isc_tlsctx_cache_t *tlsctx_cache, unsigned int options,
Separate the connect and the read timeouts in dispatch The network manager layer has two different timers with their own timeout values for TCP connections: connect timeout and read timeout. Separate the connect and the read TCP timeouts in the dispatch module too.
2024-10-30 09:23:33 +00:00
unsigned int connect_timeout, unsigned int timeout,
unsigned int udptimeout, unsigned int udpretries,
isc_loop_t *loop, isc_job_cb cb, void *arg,
dns_request_t **requestp) {
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
dns_request_t *request = NULL;
isc_result_t result;
dispatch: Refactor to eliminate dns_dispatchevent - Responses received by the dispatch are no longer sent to the caller via a task event, but via a netmgr-style recv callback. the 'action' parameter to dns_dispatch_addresponse() is now called 'response' and is called directly from udp_recv() or tcp_recv() when a valid response has been received. - All references to isc_task and isc_taskmgr have been removed from dispatch functions. - All references to dns_dispatchevent_t have been removed and the type has been deleted. - Added a task to the resolver response context, to be used for fctx events. - When the caller cancels an operation, the response handler will be called with ISC_R_CANCELED; it can abort immediately since the caller will presumably have taken care of cleanup already. - Cleaned up attach/detach in resquery and request.
2021-07-26 20:23:18 -07:00
isc_mem_t *mctx = NULL;
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
dns_messageid_t id;
Replace custom isc_boolean_t with C standard bool type
2018-04-17 08:29:14 -07:00
bool tcp = false;
bool newtcp = false;
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
isc_region_t r;
3961. [bug] Forwarding of SIG(0) signed UPDATE messages failed with BADSIG. [RT #37216]
2014-10-01 07:24:16 +10:00
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);
refactor dns_request to use loopmgr callbacks dns_request_create() and _createraw() now take a 'loop' parameter and run the callback event on the specified loop. as the task manager is no longer used, it has been removed from the dns_requestmgr structure. the dns_resolver_taskmgr() function is also no longer used and has been removed.
2022-10-25 22:56:48 -07:00
REQUIRE(loop != NULL);
REQUIRE(cb != NULL);
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
REQUIRE(requestp != NULL && *requestp == NULL);
Separate the connect and the read timeouts in dispatch The network manager layer has two different timers with their own timeout values for TCP connections: connect timeout and read timeout. Separate the connect and the read TCP timeouts in the dispatch module too.
2024-10-30 09:23:33 +00:00
REQUIRE(connect_timeout > 0 && timeout > 0);
Synchronize dns_request_createraw() and dns_request_create() UDP timeout The dns_request_createraw() function, unlike dns_request_create(), when calculating the UDP timeout value, doesn't check that 'udpretries' is not zero, and that is the more logical behavior, because the calculation formula uses division to 'udpretries + 1', where '1' is the first try. Change the dns_request_create() function to remove the 'udpretries != 0' condition. Add a 'REQUIRE(udpretries != UINT_MAX)' check to protect from a division by zero. Make the 'request->udpcount' field to represent the number of tries, instead of the number of retries.
2022-12-12 11:55:09 +00:00
REQUIRE(udpretries != UINT_MAX);
update copyright notice
2008-06-23 23:47:11 +00: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;
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
req_log(ISC_LOG_DEBUG(3), "%s", __func__);
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
rcu_read_lock();
Refactor dispatch, resolver and request Since every dispsock was associated with a dispentry anyway (though not always vice versa), the members of dispsock have been combined into dispentry, which is now reference-counted. dispentry objects are now attached before connecting and detached afterward to prevent races between the connect callback and dns_dispatch_removeresponse(). Dispatch and dispatchmgr objects are now reference counted as well, and the shutdown process has been simplified. reference counting of resquery and request objects has also been cleaned up significantly. dns_dispatch_cancel() now flags a dispentry as having been canceled, so that if the connect callback runs after cancellation, it will not initiate a read. The isblackholed() function has been simplified.
2021-05-25 22:54:17 -07:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
if (atomic_load_acquire(&requestmgr->shuttingdown)) {
result = ISC_R_SHUTTINGDOWN;
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
}
539. [func] Support the blackhole option.
2000-11-03 02:45:55 +00:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
if (isblackholed(requestmgr->dispatchmgr, destaddr)) {
result = DNS_R_BLACKHOLED;
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
}
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
isc_buffer_usedregion(msgbuf, &r);
if (r.length < DNS_MESSAGE_HEADERLEN || r.length > 65535) {
result = DNS_R_FORMERR;
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
goto done;
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
}
update copyright notice
2008-06-23 23:47:11 +00:00
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00: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;
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
Separate the connect and the read timeouts in dispatch The network manager layer has two different timers with their own timeout values for TCP connections: connect timeout and read timeout. Separate the connect and the read TCP timeouts in the dispatch module too.
2024-10-30 09:23:33 +00:00
request = new_request(mctx, loop, cb, arg, tcp, connect_timeout,
timeout, udptimeout, udpretries);
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
Refactor dispatch, resolver and request Since every dispsock was associated with a dispentry anyway (though not always vice versa), the members of dispsock have been combined into dispentry, which is now reference-counted. dispentry objects are now attached before connecting and detached afterward to prevent races between the connect callback and dns_dispatch_removeresponse(). Dispatch and dispatchmgr objects are now reference counted as well, and the shutdown process has been simplified. reference counting of resquery and request objects has also been cleaned up significantly. dns_dispatch_cancel() now flags a dispentry as having been canceled, so that if the connect callback runs after cancellation, it will not initiate a read. The isblackholed() function has been simplified.
2021-05-25 22:54:17 -07:00
isc_buffer_allocate(mctx, &request->query, r.length + (tcp ? 2 : 0));
result = isc_buffer_copyregion(request->query, &r);
if (result != ISC_R_SUCCESS) {
goto cleanup;
}
3961. [bug] Forwarding of SIG(0) signed UPDATE messages failed with BADSIG. [RT #37216]
2014-10-01 07:24:16 +10:00
again:
remove nonfunctional DSCP implementation DSCP has not been fully working since the network manager was introduced in 9.16, and has been completely broken since 9.18. This seems to have caused very few difficulties for anyone, so we have now marked it as obsolete and removed the implementation. To ensure that old config files don't fail, the code to parse dscp key-value pairs is still present, but a warning is logged that the feature is obsolete and should not be used. Nothing is done with configured values, and there is no longer any range checking.
2023-01-05 22:18:55 -08:00
result = get_dispatch(tcp, newtcp, requestmgr, srcaddr, destaddr,
Fix TCP dispatches and transport Dispatch needs to know the transport that is being used over the TCP connection to correctly allow for it to be reused. Add a transport parameter to dns_dispatch_createtcp and dns_dispatch_gettcp and use it when selecting a TCP socket for reuse.
2024-10-15 16:09:48 +11:00
transport, &request->dispatch);
common code elimination
2001-01-23 07:36:06 +00:00
if (result != ISC_R_SUCCESS) {
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02: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;
}
Separate the connect and the read timeouts in dispatch The network manager layer has two different timers with their own timeout values for TCP connections: connect timeout and read timeout. Separate the connect and the read TCP timeouts in the dispatch module too.
2024-10-30 09:23:33 +00:00
result = dns_dispatch_add(request->dispatch, loop, dispopt,
request->connect_timeout, request->timeout,
destaddr, transport, tlsctx_cache,
req_connected, req_senddone, req_response,
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) {
dns_dispatch_detach(&request->dispatch);
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
newtcp = true;
3961. [bug] Forwarding of SIG(0) signed UPDATE messages failed with BADSIG. [RT #37216]
2014-10-01 07:24:16 +10:00
goto again;
}
Add attach/detach for the dns_dispatch_send() The order in which the netievents are processed on the network manager loop is not guaranteed. Therefore the recv/read callback can come earlier than the send/write callback. The dns_request API wasn't ready for this reordering and it was destroying the dns_request_t object before the send callback has been called. Add additional attach/detach in the req_send()/req_senddone() functions to make sure we don't destroy the dns_request_t while it's still being references by asynchronous call.
2022-03-03 13:30:24 +01:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02: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
/* Add message ID. */
isc_buffer_usedregion(request->query, &r);
r.base[0] = (id >> 8) & 0xff;
r.base[1] = id & 0xff;
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;
Fix the thread safety in the dns_dispatch unit The dispatches are not thread-bound, and used freely between various threads (see the dns_resolver and dns_request units for details). This refactoring make sure that all non-const dns_dispatch_t and dns_dispentry_t members are accessed under a lock, and both object now track their internal state (NONE, CONNECTING, CONNECTED, CANCELED) instead of guessing the state from the state of various struct members. During the refactoring, the artificial limit DNS_DISPATCH_SOCKSQUOTA on UDP sockets per dispatch was removed as the limiting needs to happen and happens on in dns_resolver and limiting the number of UDP sockets artificially in dispatch could lead to unpredictable behaviour in case one dispatch has the limit exhausted by others are idle. The TCP artificial limit of DNS_DISPATCH_MAXREQUESTS makes even less sense as the TCP connections are only reused in the dns_request API that's not a heavy user of the outgoing connections. As a side note, the fact that UDP and TCP dispatch pretends to be same thing, but in fact the connected UDP is handled from dns_dispentry_t and dns_dispatch_t acts as a broker, but connected TCP is handled from dns_dispatch_t and dns_dispatchmgr_t acts as a broker doesn't really help the clarity of this unit. This refactoring kept to API almost same - only dns_dispatch_cancel() and dns_dispatch_done() were merged into dns_dispatch_done() as we need to cancel active netmgr handles in any case to not leave dangling connections around. The functions handling UDP and TCP have been mostly split to their matching counterparts and the dns_dispatch_<function> functions are now thing wrappers that call <udp|tcp>_dispatch_<function> based on the socket type. More debugging-level logging was added to the unit to accomodate for this fact.
2022-11-30 17:58:35 +01:00
request->flags |= DNS_REQUEST_F_CONNECTING;
if (tcp) {
request->flags |= DNS_REQUEST_F_TCP;
}
dispatch: Clean up connect and recv callbacks - disp_connected() has been split into two functions, udp_connected() (which takes 'resp' as an argument) and tcp_connected() (which takes 'disp', and calls the connect callbacks for all pending resps). - In dns_dispatch_connect(), if a connection is already open, we need to detach the dispentry immediately because we won't be running tcp_connected(). - dns_disptach_cancel() also now calls the connect callbacks for pending TCP responses, and the response callbacks for open TCP connections waiting on read. - If udp_connected() runs after dns_dispatch_cancel() has been called, ensure that the caller's connect callback is run. - If a UDP connection fails with EADDRINUSE, we try again up to five times with a different local port number before giving up. - If a TCP connection is canceled while still pending connection, the connect timeout may still fire. we attach the dispatch before connecting to ensure that it won't be detached too soon in this case. - The dispentry is no longer removed from the pending list when deactivating, so that the connect callback can still be run if dns_dispatch_removeresponse() was run while the connecting was pending. - Rewrote dns_dispatch_gettcp() to avoid a data race. - startrecv() and dispatch_getnext() can be called with a NULL resp when using TCP. - Refactored udp_recv() and tcp_recv() and added result logging. - EOF is now treated the same as CANCELED in response callbacks. - ISC_R_SHUTTINGDOWN is sent to the reponse callbacks for all resps if tcp_recv() is triggered by a netmgr shutdown. (response callbacks are *not* sent by udp_recv() in this case.)
2021-08-04 13:14:11 -07:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
dns_requestmgr_attach(requestmgr, &request->requestmgr);
ISC_LIST_APPEND(requestmgr->requests[request->tid], request, link);
dns_request_ref(request); /* detached in req_connected() */
Fix the thread safety in the dns_dispatch unit The dispatches are not thread-bound, and used freely between various threads (see the dns_resolver and dns_request units for details). This refactoring make sure that all non-const dns_dispatch_t and dns_dispentry_t members are accessed under a lock, and both object now track their internal state (NONE, CONNECTING, CONNECTED, CANCELED) instead of guessing the state from the state of various struct members. During the refactoring, the artificial limit DNS_DISPATCH_SOCKSQUOTA on UDP sockets per dispatch was removed as the limiting needs to happen and happens on in dns_resolver and limiting the number of UDP sockets artificially in dispatch could lead to unpredictable behaviour in case one dispatch has the limit exhausted by others are idle. The TCP artificial limit of DNS_DISPATCH_MAXREQUESTS makes even less sense as the TCP connections are only reused in the dns_request API that's not a heavy user of the outgoing connections. As a side note, the fact that UDP and TCP dispatch pretends to be same thing, but in fact the connected UDP is handled from dns_dispentry_t and dns_dispatch_t acts as a broker, but connected TCP is handled from dns_dispatch_t and dns_dispatchmgr_t acts as a broker doesn't really help the clarity of this unit. This refactoring kept to API almost same - only dns_dispatch_cancel() and dns_dispatch_done() were merged into dns_dispatch_done() as we need to cancel active netmgr handles in any case to not leave dangling connections around. The functions handling UDP and TCP have been mostly split to their matching counterparts and the dns_dispatch_<function> functions are now thing wrappers that call <udp|tcp>_dispatch_<function> based on the socket type. More debugging-level logging was added to the unit to accomodate for this fact.
2022-11-30 17:58:35 +01:00
result = dns_dispatch_connect(request->dispentry);
if (result != ISC_R_SUCCESS) {
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
dns_request_unref(request);
goto cleanup;
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
}
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
req_log(ISC_LOG_DEBUG(3), "%s: request %p", __func__, request);
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
*requestp = request;
Add attach/detach for the dns_dispatch_send() The order in which the netievents are processed on the network manager loop is not guaranteed. Therefore the recv/read callback can come earlier than the send/write callback. The dns_request API wasn't ready for this reordering and it was destroying the dns_request_t object before the send callback has been called. Add additional attach/detach in the req_send()/req_senddone() functions to make sure we don't destroy the dns_request_t while it's still being references by asynchronous call.
2022-03-03 13:30:24 +01:00
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
cleanup:
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
if (result != ISC_R_SUCCESS) {
req_cleanup(request);
dns_request_detach(&request);
req_log(ISC_LOG_DEBUG(3), "%s: failed %s", __func__,
isc_result_totext(result));
}
done:
rcu_read_unlock();
439. [func] New function dns_request_createraw().
2000-09-11 06:35:57 +00:00
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,
merge dns_request_createvia() into dns_request_create() dns_request_create() was a front-end to dns_request_createvia() that was only used by test binaries. dns_request_createvia() has been renamed to dns_request_create(), and the test programs that formerly used dns_request_create() have been updated to use the new parameters.
2022-09-08 11:43:41 -07:00
const isc_sockaddr_t *srcaddr,
Implement TLS transport support for dns_request and dns_dispatch This change prepares ground for sending DNS requests using DoT, which, in particular, will be used for forwarding dynamic updates to TLS-enabled primaries.
2022-09-19 11:04:22 +00:00
const isc_sockaddr_t *destaddr, dns_transport_t *transport,
remove nonfunctional DSCP implementation DSCP has not been fully working since the network manager was introduced in 9.16, and has been completely broken since 9.18. This seems to have caused very few difficulties for anyone, so we have now marked it as obsolete and removed the implementation. To ensure that old config files don't fail, the code to parse dscp key-value pairs is still present, but a warning is logged that the feature is obsolete and should not be used. Nothing is done with configured values, and there is no longer any range checking.
2023-01-05 22:18:55 -08:00
isc_tlsctx_cache_t *tlsctx_cache, unsigned int options,
Separate the connect and the read timeouts in dispatch The network manager layer has two different timers with their own timeout values for TCP connections: connect timeout and read timeout. Separate the connect and the read TCP timeouts in the dispatch module too.
2024-10-30 09:23:33 +00:00
dns_tsigkey_t *key, unsigned int connect_timeout,
unsigned int timeout, unsigned int udptimeout,
unsigned int udpretries, isc_loop_t *loop, isc_job_cb cb,
void *arg, dns_request_t **requestp) {
checkpoint
2000-03-13 20:43:39 +00:00
dns_request_t *request = NULL;
isc_result_t result;
dispatch: Refactor to eliminate dns_dispatchevent - Responses received by the dispatch are no longer sent to the caller via a task event, but via a netmgr-style recv callback. the 'action' parameter to dns_dispatch_addresponse() is now called 'response' and is called directly from udp_recv() or tcp_recv() when a valid response has been received. - All references to isc_task and isc_taskmgr have been removed from dispatch functions. - All references to dns_dispatchevent_t have been removed and the type has been deleted. - Added a task to the resolver response context, to be used for fctx events. - When the caller cancels an operation, the response handler will be called with ISC_R_CANCELED; it can abort immediately since the caller will presumably have taken care of cleanup already. - Cleaned up attach/detach in resquery and request.
2021-07-26 20:23:18 -07:00
isc_mem_t *mctx = NULL;
checkpoint
2000-03-20 12:22:02 +00: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;
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);
refactor dns_request to use loopmgr callbacks dns_request_create() and _createraw() now take a 'loop' parameter and run the callback event on the specified loop. as the task manager is no longer used, it has been removed from the dns_requestmgr structure. the dns_resolver_taskmgr() function is also no longer used and has been removed.
2022-10-25 22:56:48 -07:00
REQUIRE(loop != NULL);
REQUIRE(cb != NULL);
checkpoint
2000-02-24 14:31:43 +00:00
REQUIRE(requestp != NULL && *requestp == NULL);
Separate the connect and the read timeouts in dispatch The network manager layer has two different timers with their own timeout values for TCP connections: connect timeout and read timeout. Separate the connect and the read TCP timeouts in the dispatch module too.
2024-10-30 09:23:33 +00:00
REQUIRE(connect_timeout > 0 && timeout > 0);
Synchronize dns_request_createraw() and dns_request_create() UDP timeout The dns_request_createraw() function, unlike dns_request_create(), when calculating the UDP timeout value, doesn't check that 'udpretries' is not zero, and that is the more logical behavior, because the calculation formula uses division to 'udpretries + 1', where '1' is the first try. Change the dns_request_create() function to remove the 'udpretries != 0' condition. Add a 'REQUIRE(udpretries != UINT_MAX)' check to protect from a division by zero. Make the 'request->udpcount' field to represent the number of tries, instead of the number of retries.
2022-12-12 11:55:09 +00:00
REQUIRE(udpretries != UINT_MAX);
checkpoint
2000-02-24 14:31:43 +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 &&
Update sources to Clang 15 formatting
2022-11-02 19:33:14 +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
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
mctx = requestmgr->mctx;
req_log(ISC_LOG_DEBUG(3), "%s", __func__);
rcu_read_lock();
if (atomic_load_acquire(&requestmgr->shuttingdown)) {
result = ISC_R_SHUTTINGDOWN;
goto done;
}
common code elimination
2001-01-23 07:36:06 +00:00
if (isblackholed(requestmgr->dispatchmgr, destaddr)) {
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
result = DNS_R_BLACKHOLED;
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
}
539. [func] Support the blackhole option.
2000-11-03 02:45:55 +00:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
if ((options & DNS_REQUESTOPT_TCP) != 0) {
tcp = 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-03-13 20:43:39 +00:00
Separate the connect and the read timeouts in dispatch The network manager layer has two different timers with their own timeout values for TCP connections: connect timeout and read timeout. Separate the connect and the read TCP timeouts in the dispatch module too.
2024-10-30 09:23:33 +00:00
request = new_request(mctx, loop, cb, arg, tcp, connect_timeout,
timeout, udptimeout, udpretries);
Add attach/detach for the dns_dispatch_send() The order in which the netievents are processed on the network manager loop is not guaranteed. Therefore the recv/read callback can come earlier than the send/write callback. The dns_request API wasn't ready for this reordering and it was destroying the dns_request_t object before the send callback has been called. Add additional attach/detach in the req_send()/req_senddone() functions to make sure we don't destroy the dns_request_t while it's still being references by asynchronous call.
2022-03-03 13:30:24 +01:00
tsig keys were not properly ref counted
2000-07-21 23:00:31 +00:00
if (key != NULL) {
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
Refactor dispatch, resolver and request Since every dispsock was associated with a dispentry anyway (though not always vice versa), the members of dispsock have been combined into dispentry, which is now reference-counted. dispentry objects are now attached before connecting and detached afterward to prevent races between the connect callback and dns_dispatch_removeresponse(). Dispatch and dispatchmgr objects are now reference counted as well, and the shutdown process has been simplified. reference counting of resquery and request objects has also been cleaned up significantly. dns_dispatch_cancel() now flags a dispentry as having been canceled, so that if the connect callback runs after cancellation, it will not initiate a read. The isblackholed() function has been simplified.
2021-05-25 22:54:17 -07:00
result = dns_message_settsigkey(message, request->tsigkey);
if (result != ISC_R_SUCCESS) {
goto cleanup;
}
Add attach/detach for the dns_dispatch_send() The order in which the netievents are processed on the network manager loop is not guaranteed. Therefore the recv/read callback can come earlier than the send/write callback. The dns_request API wasn't ready for this reordering and it was destroying the dns_request_t object before the send callback has been called. Add additional attach/detach in the req_send()/req_senddone() functions to make sure we don't destroy the dns_request_t while it's still being references by asynchronous call.
2022-03-03 13:30:24 +01:00
again:
remove nonfunctional DSCP implementation DSCP has not been fully working since the network manager was introduced in 9.16, and has been completely broken since 9.18. This seems to have caused very few difficulties for anyone, so we have now marked it as obsolete and removed the implementation. To ensure that old config files don't fail, the code to parse dscp key-value pairs is still present, but a warning is logged that the feature is obsolete and should not be used. Nothing is done with configured values, and there is no longer any range checking.
2023-01-05 22:18:55 -08:00
result = get_dispatch(tcp, false, requestmgr, srcaddr, destaddr,
Fix TCP dispatches and transport Dispatch needs to know the transport that is being used over the TCP connection to correctly allow for it to be reused. Add a transport parameter to dns_dispatch_createtcp and dns_dispatch_gettcp and use it when selecting a TCP socket for reuse.
2024-10-15 16:09:48 +11:00
transport, &request->dispatch);
common code elimination
2001-01-23 07:36:06 +00:00
if (result != ISC_R_SUCCESS) {
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02: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
Separate the connect and the read timeouts in dispatch The network manager layer has two different timers with their own timeout values for TCP connections: connect timeout and read timeout. Separate the connect and the read TCP timeouts in the dispatch module too.
2024-10-30 09:23:33 +00:00
result = dns_dispatch_add(request->dispatch, loop, 0,
request->connect_timeout, request->timeout,
Implement TLS transport support for dns_request and dns_dispatch This change prepares ground for sending DNS requests using DoT, which, in particular, will be used for forwarding dynamic updates to TLS-enabled primaries.
2022-09-19 11:04:22 +00:00
destaddr, transport, tlsctx_cache,
req_connected, req_senddone, req_response,
request, &id, &request->dispentry);
checkpoint
2000-03-13 20:43:39 +00:00
if (result != ISC_R_SUCCESS) {
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02: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;
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);
Refactor dispatch, resolver and request Since every dispsock was associated with a dispentry anyway (though not always vice versa), the members of dispsock have been combined into dispentry, which is now reference-counted. dispentry objects are now attached before connecting and detached afterward to prevent races between the connect callback and dns_dispatch_removeresponse(). Dispatch and dispatchmgr objects are now reference counted as well, and the shutdown process has been simplified. reference counting of resquery and request objects has also been cleaned up significantly. dns_dispatch_cancel() now flags a dispentry as having been canceled, so that if the connect callback runs after cancellation, it will not initiate a read. The isblackholed() function has been simplified.
2021-05-25 22:54:17 -07:00
if (result == DNS_R_USETCP && !tcp) {
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
/* Try again using TCP. */
checkpoint
2000-03-20 12:22:02 +00:00
dns_message_renderreset(message);
refactor dispatch cancellation Renamed some functions for clarity and readability: - dns_dispatch_addresponse() -> dns_dispatch_add() - dns_dispatch_removeresponse() -> dns_dispatch_done() The dns_dispatch_cancel() function now calls dns_dispatch_done() directly, so it is no longer ever necessary to call both functions. dns_dispatch_cancel() is used to terminate dispatch connections that are still pending, while dns_dispatch_done() is used when they are complete.
2021-10-03 15:15:50 -07:00
dns_dispatch_done(&request->dispentry);
checkpoint
2000-03-20 12:22:02 +00:00
dns_dispatch_detach(&request->dispatch);
options |= DNS_REQUESTOPT_TCP;
Refactor dispatch, resolver and request Since every dispsock was associated with a dispentry anyway (though not always vice versa), the members of dispsock have been combined into dispentry, which is now reference-counted. dispentry objects are now attached before connecting and detached afterward to prevent races between the connect callback and dns_dispatch_removeresponse(). Dispatch and dispatchmgr objects are now reference counted as well, and the shutdown process has been simplified. reference counting of resquery and request objects has also been cleaned up significantly. dns_dispatch_cancel() now flags a dispentry as having been canceled, so that if the connect callback runs after cancellation, it will not initiate a read. The isblackholed() function has been simplified.
2021-05-25 22:54:17 -07:00
tcp = true;
Add attach/detach for the dns_dispatch_send() The order in which the netievents are processed on the network manager loop is not guaranteed. Therefore the recv/read callback can come earlier than the send/write callback. The dns_request API wasn't ready for this reordering and it was destroying the dns_request_t object before the send callback has been called. Add additional attach/detach in the req_send()/req_senddone() functions to make sure we don't destroy the dns_request_t while it's still being references by asynchronous call.
2022-03-03 13:30:24 +01:00
goto again;
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
} else if (result != ISC_R_SUCCESS) {
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);
if (result != ISC_R_SUCCESS) {
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02: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
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;
remove dead code in dns_request the 'connected' variable in 'dns_request_create()` was always false.
2023-02-21 18:15:55 -08:00
request->flags |= DNS_REQUEST_F_CONNECTING;
if (tcp) {
request->flags |= DNS_REQUEST_F_TCP;
}
dispatch: Clean up connect and recv callbacks - disp_connected() has been split into two functions, udp_connected() (which takes 'resp' as an argument) and tcp_connected() (which takes 'disp', and calls the connect callbacks for all pending resps). - In dns_dispatch_connect(), if a connection is already open, we need to detach the dispentry immediately because we won't be running tcp_connected(). - dns_disptach_cancel() also now calls the connect callbacks for pending TCP responses, and the response callbacks for open TCP connections waiting on read. - If udp_connected() runs after dns_dispatch_cancel() has been called, ensure that the caller's connect callback is run. - If a UDP connection fails with EADDRINUSE, we try again up to five times with a different local port number before giving up. - If a TCP connection is canceled while still pending connection, the connect timeout may still fire. we attach the dispatch before connecting to ensure that it won't be detached too soon in this case. - The dispentry is no longer removed from the pending list when deactivating, so that the connect callback can still be run if dns_dispatch_removeresponse() was run while the connecting was pending. - Rewrote dns_dispatch_gettcp() to avoid a data race. - startrecv() and dispatch_getnext() can be called with a NULL resp when using TCP. - Refactored udp_recv() and tcp_recv() and added result logging. - EOF is now treated the same as CANCELED in response callbacks. - ISC_R_SHUTTINGDOWN is sent to the reponse callbacks for all resps if tcp_recv() is triggered by a netmgr shutdown. (response callbacks are *not* sent by udp_recv() in this case.)
2021-08-04 13:14:11 -07:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
dns_requestmgr_attach(requestmgr, &request->requestmgr);
ISC_LIST_APPEND(requestmgr->requests[request->tid], request, link);
dns_request_ref(request); /* detached in req_connected() */
remove dead code in dns_request the 'connected' variable in 'dns_request_create()` was always false.
2023-02-21 18:15:55 -08:00
result = dns_dispatch_connect(request->dispentry);
if (result != ISC_R_SUCCESS) {
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
dns_request_unref(request);
goto cleanup;
checkpoint
2000-03-20 12:22:02 +00:00
}
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
req_log(ISC_LOG_DEBUG(3), "%s: request %p", __func__, request);
checkpoint
2000-03-20 12:22:02 +00:00
*requestp = request;
Add attach/detach for the dns_dispatch_send() The order in which the netievents are processed on the network manager loop is not guaranteed. Therefore the recv/read callback can come earlier than the send/write callback. The dns_request API wasn't ready for this reordering and it was destroying the dns_request_t object before the send callback has been called. Add additional attach/detach in the req_send()/req_senddone() functions to make sure we don't destroy the dns_request_t while it's still being references by asynchronous call.
2022-03-03 13:30:24 +01:00
checkpoint
2000-03-13 20:43:39 +00:00
cleanup:
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
if (result != ISC_R_SUCCESS) {
req_cleanup(request);
dns_request_detach(&request);
req_log(ISC_LOG_DEBUG(3), "%s: failed %s", __func__,
isc_result_totext(result));
}
done:
rcu_read_unlock();
checkpoint
2000-03-13 20:43:39 +00:00
return result;
}
static isc_result_t
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
req_render(dns_message_t *message, isc_buffer_t **bufferp, unsigned int options,
isc_mem_t *mctx) {
checkpoint
2000-03-13 20:43:39 +00:00
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;
Simplify and speed up DNS name compression All we need for compression is a very small hash set of compression offsets, because most of the information we need (the previously added names) can be found in the message using the compression offsets. This change combines dns_compress_find() and dns_compress_add() into one function dns_compress_name() that both finds any existing suffix, and adds any new prefix to the table. The old split led to performance problems caused by duplicate names in the compression context. Compression contexts are now either small or large, which the caller chooses depending on the expected size of the message. There is no dynamic resizing. There is a behaviour change: compression now acts on all the labels in each name, instead of just the last few. A small benchmark suggests this is about 2x faster.
2022-06-23 21:53:46 +01:00
unsigned int compflags;
checkpoint
2000-03-13 20:43:39 +00:00
REQUIRE(bufferp != NULL && *bufferp == NULL);
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
req_log(ISC_LOG_DEBUG(3), "%s", __func__);
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
Simplify and speed up DNS name compression All we need for compression is a very small hash set of compression offsets, because most of the information we need (the previously added names) can be found in the message using the compression offsets. This change combines dns_compress_find() and dns_compress_add() into one function dns_compress_name() that both finds any existing suffix, and adds any new prefix to the table. The old split led to performance problems caused by duplicate names in the compression context. Compression contexts are now either small or large, which the caller chooses depending on the expected size of the message. There is no dynamic resizing. There is a behaviour change: compression now acts on all the labels in each name, instead of just the last few. A small benchmark suggests this is about 2x faster.
2022-06-23 21:53:46 +01:00
compflags = 0;
if ((options & DNS_REQUESTOPT_LARGE) != 0) {
compflags |= DNS_COMPRESS_LARGE;
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
if ((options & DNS_REQUESTOPT_CASE) != 0) {
Simplify and speed up DNS name compression All we need for compression is a very small hash set of compression offsets, because most of the information we need (the previously added names) can be found in the message using the compression offsets. This change combines dns_compress_find() and dns_compress_add() into one function dns_compress_name() that both finds any existing suffix, and adds any new prefix to the table. The old split led to performance problems caused by duplicate names in the compression context. Compression contexts are now either small or large, which the caller chooses depending on the expected size of the message. There is no dynamic resizing. There is a behaviour change: compression now acts on all the labels in each name, instead of just the last few. A small benchmark suggests this is about 2x faster.
2022-06-23 21:53:46 +01:00
compflags |= DNS_COMPRESS_CASE;
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
}
Simplify and speed up DNS name compression All we need for compression is a very small hash set of compression offsets, because most of the information we need (the previously added names) can be found in the message using the compression offsets. This change combines dns_compress_find() and dns_compress_add() into one function dns_compress_name() that both finds any existing suffix, and adds any new prefix to the table. The old split led to performance problems caused by duplicate names in the compression context. Compression contexts are now either small or large, which the caller chooses depending on the expected size of the message. There is no dynamic resizing. There is a behaviour change: compression now acts on all the labels in each name, instead of just the last few. A small benchmark suggests this is about 2x faster.
2022-06-23 21:53:46 +01:00
dns_compress_init(&cctx, mctx, compflags);
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);
s/DNS_R_/ISC_R_/ change for some codes.
2000-04-06 22:03:35 +00: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);
s/DNS_R_/ISC_R_/ change for some codes.
2000-04-06 22:03:35 +00: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);
s/DNS_R_/ISC_R_/ change for some codes.
2000-04-06 22:03:35 +00: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);
s/DNS_R_/ISC_R_/ change for some codes.
2000-04-06 22:03:35 +00: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);
s/DNS_R_/ISC_R_/ change for some codes.
2000-04-06 22:03:35 +00: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);
s/DNS_R_/ISC_R_/ change for some codes.
2000-04-06 22:03:35 +00: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
/*
* 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);
if (result != ISC_R_SUCCESS) {
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.
*/
Simplify and speed up DNS name compression All we need for compression is a very small hash set of compression offsets, because most of the information we need (the previously added names) can be found in the message using the compression offsets. This change combines dns_compress_find() and dns_compress_add() into one function dns_compress_name() that both finds any existing suffix, and adds any new prefix to the table. The old split led to performance problems caused by duplicate names in the compression context. Compression contexts are now either small or large, which the caller chooses depending on the expected size of the message. There is no dynamic resizing. There is a behaviour change: compression now acts on all the labels in each name, instead of just the last few. A small benchmark suggests this is about 2x faster.
2022-06-23 21:53:46 +01:00
dns_compress_invalidate(&cctx);
checkpoint
2000-03-13 20:43:39 +00:00
isc_buffer_free(&buf1);
*bufferp = buf2;
return ISC_R_SUCCESS;
cleanup:
checkpoint
2000-03-20 12:22:02 +00:00
dns_message_renderreset(message);
Simplify and speed up DNS name compression All we need for compression is a very small hash set of compression offsets, because most of the information we need (the previously added names) can be found in the message using the compression offsets. This change combines dns_compress_find() and dns_compress_add() into one function dns_compress_name() that both finds any existing suffix, and adds any new prefix to the table. The old split led to performance problems caused by duplicate names in the compression context. Compression contexts are now either small or large, which the caller chooses depending on the expected size of the message. There is no dynamic resizing. There is a behaviour change: compression now acts on all the labels in each name, instead of just the last few. A small benchmark suggests this is about 2x faster.
2022-06-23 21:53:46 +01:00
dns_compress_invalidate(&cctx);
checkpoint
2000-03-13 20:43:39 +00:00
if (buf1 != NULL) {
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
}
checkpoint
2000-03-13 20:43:39 +00:00
if (buf2 != NULL) {
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
}
checkpoint
2000-03-13 20:43:39 +00:00
return result;
checkpoint
2000-02-24 14:31:43 +00:00
}
dns_request_cancel needs to be callable from any thread Check the tid and cancel the request immediately or pass it to the appropriate loop for processing. Call request->cb directly from req_sendevent as it is now always called with the correct tid.
2023-12-06 11:34:52 +11:00
static void
request_cancel(dns_request_t *request) {
checkpoint
2000-03-20 12:22:02 +00:00
REQUIRE(VALID_REQUEST(request));
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
REQUIRE(request->tid == isc_tid());
checkpoint
2000-03-13 20:43:39 +00:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
if (DNS_REQUEST_COMPLETE(request)) {
/* The request callback was already called */
return;
}
req_log(ISC_LOG_DEBUG(3), "%s: request %p", __func__, request);
req_sendevent(request, ISC_R_CANCELED); /* call asynchronously */
checkpoint
2000-02-24 14:31:43 +00:00
}
checkpoint
2000-03-13 20:43:39 +00:00
dns_request_cancel needs to be callable from any thread Check the tid and cancel the request immediately or pass it to the appropriate loop for processing. Call request->cb directly from req_sendevent as it is now always called with the correct tid.
2023-12-06 11:34:52 +11:00
static void
req_cancel_cb(void *arg) {
dns_request_t *request = arg;
request_cancel(request);
dns_request_unref(request);
}
void
dns_request_cancel(dns_request_t *request) {
REQUIRE(VALID_REQUEST(request));
if (request->tid == isc_tid()) {
request_cancel(request);
} else {
dns_request_ref(request);
isc_async_run(request->loop, req_cancel_cb, request);
}
}
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,
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
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));
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
REQUIRE(request->tid == isc_tid());
checkpoint
2000-03-13 20:43:39 +00:00
REQUIRE(request->answer != NULL);
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
req_log(ISC_LOG_DEBUG(3), "%s: request %p", __func__, 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
dns_rdatalist_tordataset() and dns_rdatalist_fromrdataset() can not fail Clean up dns_rdatalist_tordataset() and dns_rdatalist_fromrdataset() functions by making them return void, because they cannot fail. Clean up other functions that subsequently cannot fail.
2022-07-29 12:40:45 +00:00
dns_message_setquerytsig(message, request->tsig);
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);
if (result != ISC_R_SUCCESS) {
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);
If the request was signed with a tsig key, verify the signature on the response.
2000-07-21 20:33:13 +00:00
if (result != ISC_R_SUCCESS) {
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 the request was signed with a tsig key, verify the signature on the response.
2000-07-21 20:33:13 +00: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 *
dns_request_getanswer(dns_request_t *request) {
REQUIRE(VALID_REQUEST(request));
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
REQUIRE(request->tid == isc_tid());
add "mdig +yaml" output format
2019-07-20 14:35:59 -04:00
return request->answer;
}
Replace custom isc_boolean_t with C standard bool type
2018-04-17 08:29:14 -07:00
bool
Add function to determine whether a given request used TCP or not.
2000-06-06 02:07:13 +00:00
dns_request_usedtcp(dns_request_t *request) {
REQUIRE(VALID_REQUEST(request));
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
REQUIRE(request->tid == isc_tid());
Add function to determine whether a given request used TCP or not.
2000-06-06 02:07:13 +00:00
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
dns_request_destroy(dns_request_t **requestp) {
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
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
dns_request_t *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
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
req_log(ISC_LOG_DEBUG(3), "%s: request %p", __func__, request);
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
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
if (DNS_REQUEST_COMPLETE(request)) {
dns_request_cancel(request);
refactor dns_request to use loopmgr callbacks dns_request_create() and _createraw() now take a 'loop' parameter and run the callback event on the specified loop. as the task manager is no longer used, it has been removed from the dns_requestmgr structure. the dns_resolver_taskmgr() function is also no longer used and has been removed.
2022-10-25 22:56:48 -07:00
}
Add attach/detach for the dns_dispatch_send() The order in which the netievents are processed on the network manager loop is not guaranteed. Therefore the recv/read callback can come earlier than the send/write callback. The dns_request API wasn't ready for this reordering and it was destroying the dns_request_t object before the send callback has been called. Add additional attach/detach in the req_send()/req_senddone() functions to make sure we don't destroy the dns_request_t while it's still being references by asynchronous call.
2022-03-03 13:30:24 +01:00
/* final detach to shut down request */
refactor dns_request to use loopmgr callbacks dns_request_create() and _createraw() now take a 'loop' parameter and run the callback event on the specified loop. as the task manager is no longer used, it has been removed from the dns_requestmgr structure. the dns_resolver_taskmgr() function is also no longer used and has been removed.
2022-10-25 22:56:48 -07:00
dns_request_detach(&request);
checkpoint
2000-02-24 14:31:43 +00:00
}
checkpoint
2000-03-20 12:22:02 +00:00
checkpoint
2000-03-13 20:43:39 +00:00
static void
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
req_connected(isc_result_t eresult, isc_region_t *region ISC_ATTR_UNUSED,
void *arg) {
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_request_t *request = (dns_request_t *)arg;
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
REQUIRE(VALID_REQUEST(request));
REQUIRE(request->tid == isc_tid());
REQUIRE(DNS_REQUEST_CONNECTING(request));
checkpoint
2000-03-13 20:43:39 +00:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
req_log(ISC_LOG_DEBUG(3), "%s: request %p: %s", __func__, request,
Refactor dispatch, resolver and request Since every dispsock was associated with a dispentry anyway (though not always vice versa), the members of dispsock have been combined into dispentry, which is now reference-counted. dispentry objects are now attached before connecting and detached afterward to prevent races between the connect callback and dns_dispatch_removeresponse(). Dispatch and dispatchmgr objects are now reference counted as well, and the shutdown process has been simplified. reference counting of resquery and request objects has also been cleaned up significantly. dns_dispatch_cancel() now flags a dispentry as having been canceled, so that if the connect callback runs after cancellation, it will not initiate a read. The isblackholed() function has been simplified.
2021-05-25 22:54:17 -07:00
isc_result_totext(eresult));
checkpoint
2000-03-20 12:22:02 +00:00
request->flags &= ~DNS_REQUEST_F_CONNECTING;
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
if (DNS_REQUEST_COMPLETE(request)) {
/* The request callback was already called */
goto detach;
}
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
req_send(request);
checkpoint
2000-03-20 12:22:02 +00:00
} else {
on connect error, send the actual result to the caller formerly if a connection failed in dns_request, the callback function was called with ISC_R_CANCELED. change this to the actual result code so the failure is correctly reported.
2023-01-31 13:30:12 -08:00
req_sendevent(request, eresult);
checkpoint
2000-03-20 12:22:02 +00:00
}
Refactor dispatch, resolver and request Since every dispsock was associated with a dispentry anyway (though not always vice versa), the members of dispsock have been combined into dispentry, which is now reference-counted. dispentry objects are now attached before connecting and detached afterward to prevent races between the connect callback and dns_dispatch_removeresponse(). Dispatch and dispatchmgr objects are now reference counted as well, and the shutdown process has been simplified. reference counting of resquery and request objects has also been cleaned up significantly. dns_dispatch_cancel() now flags a dispentry as having been canceled, so that if the connect callback runs after cancellation, it will not initiate a read. The isblackholed() function has been simplified.
2021-05-25 22:54:17 -07:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
detach:
merge dns_request_createvia() into dns_request_create() dns_request_create() was a front-end to dns_request_createvia() that was only used by test binaries. dns_request_createvia() has been renamed to dns_request_create(), and the test programs that formerly used dns_request_create() have been updated to use the new parameters.
2022-09-08 11:43:41 -07:00
/* attached in dns_request_create/_createraw() */
refactor dns_request to use loopmgr callbacks dns_request_create() and _createraw() now take a 'loop' parameter and run the callback event on the specified loop. as the task manager is no longer used, it has been removed from the dns_requestmgr structure. the dns_resolver_taskmgr() function is also no longer used and has been removed.
2022-10-25 22:56:48 -07:00
dns_request_unref(request);
checkpoint
2000-03-20 12:22:02 +00:00
}
static void
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
req_senddone(isc_result_t eresult, isc_region_t *region ISC_ATTR_UNUSED,
void *arg) {
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_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));
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
REQUIRE(request->tid == isc_tid());
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
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
req_log(ISC_LOG_DEBUG(3), "%s: request %p", __func__, request);
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
642. [bug] #622 needed more work.
2000-12-31 05:05:34 +00:00
request->flags &= ~DNS_REQUEST_F_SENDING;
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
if (DNS_REQUEST_COMPLETE(request)) {
/* The request callback was already called */
goto detach;
642. [bug] #622 needed more work.
2000-12-31 05:05:34 +00:00
}
checkpoint
2000-03-13 20:43:39 +00:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
if (eresult != ISC_R_SUCCESS) {
req_sendevent(request, eresult);
}
Add attach/detach for the dns_dispatch_send() The order in which the netievents are processed on the network manager loop is not guaranteed. Therefore the recv/read callback can come earlier than the send/write callback. The dns_request API wasn't ready for this reordering and it was destroying the dns_request_t object before the send callback has been called. Add additional attach/detach in the req_send()/req_senddone() functions to make sure we don't destroy the dns_request_t while it's still being references by asynchronous call.
2022-03-03 13:30:24 +01:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
detach:
Add attach/detach for the dns_dispatch_send() The order in which the netievents are processed on the network manager loop is not guaranteed. Therefore the recv/read callback can come earlier than the send/write callback. The dns_request API wasn't ready for this reordering and it was destroying the dns_request_t object before the send callback has been called. Add additional attach/detach in the req_send()/req_senddone() functions to make sure we don't destroy the dns_request_t while it's still being references by asynchronous call.
2022-03-03 13:30:24 +01:00
/* attached in req_send() */
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
dns_request_unref(request);
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
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
req_response(isc_result_t eresult, isc_region_t *region, void *arg) {
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
dns_request_t *request = (dns_request_t *)arg;
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
if (eresult == ISC_R_CANCELED) {
dispatch: Remove 'timeout' callback - It is no longer necessary to pass a 'timeout' callback to dns_dispatch_addresponse(); timeouts are handled directly by the 'response' callback instead. - The netmgr handle is no longer passed to dispatch callbacks, since they don't (and can't) use it. instead, dispatch_cb_t now takes a result code, region, and argument. - Cleaned up timeout-related tests in dispatch_test.c
2021-08-03 15:27:06 +02:00
return;
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
}
Perform request validation in req_response() before using the pointer The 'request' pointer is used before it is checked. Perform the check before using the pointer.
2022-12-12 12:08:16 +00:00
REQUIRE(VALID_REQUEST(request));
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
REQUIRE(request->tid == isc_tid());
req_log(ISC_LOG_DEBUG(3), "%s: request %p: %s", __func__, request,
isc_result_totext(eresult));
Perform request validation in req_response() before using the pointer The 'request' pointer is used before it is checked. Perform the check before using the pointer.
2022-12-12 12:08:16 +00:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
if (DNS_REQUEST_COMPLETE(request)) {
/* The request callback was already called */
return;
}
switch (eresult) {
case ISC_R_TIMEDOUT:
if (request->udpcount > 1 && !dns_request_usedtcp(request)) {
Ensure that dns_request_createvia() has a retry limit There are a couple of problems with dns_request_createvia(): a UDP retry count of zero means unlimited retries (it should mean no retries), and the overall request timeout is not enforced. The combination of these bugs means that requests can be retried forever. This change alters calls to dns_request_createvia() to avoid the infinite retry bug by providing an explicit retry count. Previously, the calls specified infinite retries and relied on the limit implied by the overall request timeout and the UDP timeout (which did not work because the overall timeout is not enforced). The `udpretries` argument is also changed to be the number of retries; previously, zero was interpreted as infinity because of an underflow to UINT_MAX, which appeared to be a mistake. And `mdig` is updated to match the change in retry accounting. The bug could be triggered by zone maintenance queries, including NOTIFY messages, DS parental checks, refresh SOA queries and stub zone nameserver lookups. It could also occur with `nsupdate -r 0`. (But `mdig` had its own code to avoid the bug.)
2022-04-01 13:46:39 +01:00
request->udpcount -= 1;
dispatch: Fix several connect-related issues - startrecv() and getnext() have been rewritten. - Don't set TCP flag when connecting a UDP dispatch. - Prevent TCP connections from trying to connect twice. - dns_dispatch_gettcp() can now find a matching TCP dispatch that has not yet fully connected, and attach to it. when the connection is completed, the connect callbacks are run for all of the pending entries. - An atomic 'state' variable is now used for connection state instead of attributes. - When dns_dispatch_cancel() is called on a TCP dispatch entry, only that one entry is canceled. the dispatch itself should not be shut down until there are no dispatch entries left associated with it. - Other incidental cleanup, including removing DNS_DISPATCHATTR_IPV4 and _IPV6 (they were being set in the dispatch attributes but never used), cleaning up dns_requestmgr_create(), and renaming dns_dispatch_read() to the more descriptive dns_dispatch_resume().
2021-08-03 18:24:27 -07:00
dns_dispatch_resume(request->dispentry,
request->timeout);
dispatch: Remove 'timeout' callback - It is no longer necessary to pass a 'timeout' callback to dns_dispatch_addresponse(); timeouts are handled directly by the 'response' callback instead. - The netmgr handle is no longer passed to dispatch callbacks, since they don't (and can't) use it. instead, dispatch_cb_t now takes a result code, region, and argument. - Cleaned up timeout-related tests in dispatch_test.c
2021-08-03 15:27:06 +02:00
if (!DNS_REQUEST_SENDING(request)) {
req_send(request);
}
return;
}
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
break;
case ISC_R_SUCCESS:
/* Copy region to request. */
isc_buffer_allocate(request->mctx, &request->answer,
region->length);
eresult = isc_buffer_copyregion(request->answer, region);
if (eresult != ISC_R_SUCCESS) {
isc_buffer_free(&request->answer);
}
break;
default:
break;
dispatch: Refactor to eliminate dns_dispatchevent - Responses received by the dispatch are no longer sent to the caller via a task event, but via a netmgr-style recv callback. the 'action' parameter to dns_dispatch_addresponse() is now called 'response' and is called directly from udp_recv() or tcp_recv() when a valid response has been received. - All references to isc_task and isc_taskmgr have been removed from dispatch functions. - All references to dns_dispatchevent_t have been removed and the type has been deleted. - Added a task to the resolver response context, to be used for fctx events. - When the caller cancels an operation, the response handler will be called with ISC_R_CANCELED; it can abort immediately since the caller will presumably have taken care of cleanup already. - Cleaned up attach/detach in resquery and request.
2021-07-26 20:23:18 -07:00
}
checkpoint
2000-03-13 20:43:39 +00:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
req_sendevent(request, eresult);
}
dispatch: Remove 'timeout' callback - It is no longer necessary to pass a 'timeout' callback to dns_dispatch_addresponse(); timeouts are handled directly by the 'response' callback instead. - The netmgr handle is no longer passed to dispatch callbacks, since they don't (and can't) use it. instead, dispatch_cb_t now takes a result code, region, and argument. - Cleaned up timeout-related tests in dispatch_test.c
2021-08-03 15:27:06 +02:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
static void
req_sendevent_cb(void *arg) {
dns_request_t *request = arg;
checkpoint
2000-03-13 20:43:39 +00:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
request->cb(request);
dns_request_unref(request);
}
dispatch: Clean up connect and recv callbacks - disp_connected() has been split into two functions, udp_connected() (which takes 'resp' as an argument) and tcp_connected() (which takes 'disp', and calls the connect callbacks for all pending resps). - In dns_dispatch_connect(), if a connection is already open, we need to detach the dispentry immediately because we won't be running tcp_connected(). - dns_disptach_cancel() also now calls the connect callbacks for pending TCP responses, and the response callbacks for open TCP connections waiting on read. - If udp_connected() runs after dns_dispatch_cancel() has been called, ensure that the caller's connect callback is run. - If a UDP connection fails with EADDRINUSE, we try again up to five times with a different local port number before giving up. - If a TCP connection is canceled while still pending connection, the connect timeout may still fire. we attach the dispatch before connecting to ensure that it won't be detached too soon in this case. - The dispentry is no longer removed from the pending list when deactivating, so that the connect callback can still be run if dns_dispatch_removeresponse() was run while the connecting was pending. - Rewrote dns_dispatch_gettcp() to avoid a data race. - startrecv() and dispatch_getnext() can be called with a NULL resp when using TCP. - Refactored udp_recv() and tcp_recv() and added result logging. - EOF is now treated the same as CANCELED in response callbacks. - ISC_R_SHUTTINGDOWN is sent to the reponse callbacks for all resps if tcp_recv() is triggered by a netmgr shutdown. (response callbacks are *not* sent by udp_recv() in this case.)
2021-08-04 13:14:11 -07:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
static void
req_cleanup(dns_request_t *request) {
if (ISC_LINK_LINKED(request, link)) {
ISC_LIST_UNLINK(request->requestmgr->requests[request->tid],
request, link);
}
dispatch: Clean up connect and recv callbacks - disp_connected() has been split into two functions, udp_connected() (which takes 'resp' as an argument) and tcp_connected() (which takes 'disp', and calls the connect callbacks for all pending resps). - In dns_dispatch_connect(), if a connection is already open, we need to detach the dispentry immediately because we won't be running tcp_connected(). - dns_disptach_cancel() also now calls the connect callbacks for pending TCP responses, and the response callbacks for open TCP connections waiting on read. - If udp_connected() runs after dns_dispatch_cancel() has been called, ensure that the caller's connect callback is run. - If a UDP connection fails with EADDRINUSE, we try again up to five times with a different local port number before giving up. - If a TCP connection is canceled while still pending connection, the connect timeout may still fire. we attach the dispatch before connecting to ensure that it won't be detached too soon in this case. - The dispentry is no longer removed from the pending list when deactivating, so that the connect callback can still be run if dns_dispatch_removeresponse() was run while the connecting was pending. - Rewrote dns_dispatch_gettcp() to avoid a data race. - startrecv() and dispatch_getnext() can be called with a NULL resp when using TCP. - Refactored udp_recv() and tcp_recv() and added result logging. - EOF is now treated the same as CANCELED in response callbacks. - ISC_R_SHUTTINGDOWN is sent to the reponse callbacks for all resps if tcp_recv() is triggered by a netmgr shutdown. (response callbacks are *not* sent by udp_recv() in this case.)
2021-08-04 13:14:11 -07:00
if (request->dispentry != NULL) {
refactor dispatch cancellation Renamed some functions for clarity and readability: - dns_dispatch_addresponse() -> dns_dispatch_add() - dns_dispatch_removeresponse() -> dns_dispatch_done() The dns_dispatch_cancel() function now calls dns_dispatch_done() directly, so it is no longer ever necessary to call both functions. dns_dispatch_cancel() is used to terminate dispatch connections that are still pending, while dns_dispatch_done() is used when they are complete.
2021-10-03 15:15:50 -07:00
dns_dispatch_done(&request->dispentry);
dispatch: Clean up connect and recv callbacks - disp_connected() has been split into two functions, udp_connected() (which takes 'resp' as an argument) and tcp_connected() (which takes 'disp', and calls the connect callbacks for all pending resps). - In dns_dispatch_connect(), if a connection is already open, we need to detach the dispentry immediately because we won't be running tcp_connected(). - dns_disptach_cancel() also now calls the connect callbacks for pending TCP responses, and the response callbacks for open TCP connections waiting on read. - If udp_connected() runs after dns_dispatch_cancel() has been called, ensure that the caller's connect callback is run. - If a UDP connection fails with EADDRINUSE, we try again up to five times with a different local port number before giving up. - If a TCP connection is canceled while still pending connection, the connect timeout may still fire. we attach the dispatch before connecting to ensure that it won't be detached too soon in this case. - The dispentry is no longer removed from the pending list when deactivating, so that the connect callback can still be run if dns_dispatch_removeresponse() was run while the connecting was pending. - Rewrote dns_dispatch_gettcp() to avoid a data race. - startrecv() and dispatch_getnext() can be called with a NULL resp when using TCP. - Refactored udp_recv() and tcp_recv() and added result logging. - EOF is now treated the same as CANCELED in response callbacks. - ISC_R_SHUTTINGDOWN is sent to the reponse callbacks for all resps if tcp_recv() is triggered by a netmgr shutdown. (response callbacks are *not* sent by udp_recv() in this case.)
2021-08-04 13:14:11 -07:00
}
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
if (request->dispatch != NULL) {
dns_dispatch_detach(&request->dispatch);
}
checkpoint
2000-03-13 20:43:39 +00:00
}
checkpoint
2000-03-20 12:22:02 +00:00
static void
req_sendevent(dns_request_t *request, isc_result_t result) {
Added REQUIRE's
2000-04-28 22:07:29 +00:00
REQUIRE(VALID_REQUEST(request));
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
REQUIRE(request->tid == isc_tid());
REQUIRE(!DNS_REQUEST_COMPLETE(request));
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
request->flags |= DNS_REQUEST_F_COMPLETE;
simplify sending request events The function send_if_done() was just a front-end for req_sendevents().
2021-10-03 17:24:35 -07:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
req_cleanup(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
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
req_log(ISC_LOG_DEBUG(3), "%s: request %p: %s", __func__, request,
isc_result_totext(result));
Add attach/detach for the dns_dispatch_send() The order in which the netievents are processed on the network manager loop is not guaranteed. Therefore the recv/read callback can come earlier than the send/write callback. The dns_request API wasn't ready for this reordering and it was destroying the dns_request_t object before the send callback has been called. Add additional attach/detach in the req_send()/req_senddone() functions to make sure we don't destroy the dns_request_t while it's still being references by asynchronous call.
2022-03-03 13:30:24 +01:00
refactor dns_request to use loopmgr callbacks dns_request_create() and _createraw() now take a 'loop' parameter and run the callback event on the specified loop. as the task manager is no longer used, it has been removed from the dns_requestmgr structure. the dns_resolver_taskmgr() function is also no longer used and has been removed.
2022-10-25 22:56:48 -07:00
request->result = result;
checkpoint
2000-03-20 12:22:02 +00:00
dns_request_cancel needs to be callable from any thread Check the tid and cancel the request immediately or pass it to the appropriate loop for processing. Call request->cb directly from req_sendevent as it is now always called with the correct tid.
2023-12-06 11:34:52 +11:00
/*
* Do not call request->cb directly as it introduces a dead lock
* between dns_zonemgr_shutdown and sendtoprimary in lib/dns/zone.c
* zone->lock.
*/
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
dns_request_ref(request);
isc_async_run(request->loop, req_sendevent_cb, request);
Refactor dispatch, resolver and request Since every dispsock was associated with a dispentry anyway (though not always vice versa), the members of dispsock have been combined into dispentry, which is now reference-counted. dispentry objects are now attached before connecting and detached afterward to prevent races between the connect callback and dns_dispatch_removeresponse(). Dispatch and dispatchmgr objects are now reference counted as well, and the shutdown process has been simplified. reference counting of resquery and request objects has also been cleaned up significantly. dns_dispatch_cancel() now flags a dispentry as having been canceled, so that if the connect callback runs after cancellation, it will not initiate a read. The isblackholed() function has been simplified.
2021-05-25 22:54:17 -07:00
}
checkpoint
2000-03-20 12:22:02 +00:00
static void
req_destroy(dns_request_t *request) {
Added REQUIRE's
2000-04-28 22:07:29 +00:00
REQUIRE(VALID_REQUEST(request));
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
REQUIRE(request->tid == isc_tid());
refactor dns_request to use loopmgr callbacks dns_request_create() and _createraw() now take a 'loop' parameter and run the callback event on the specified loop. as the task manager is no longer used, it has been removed from the dns_requestmgr structure. the dns_resolver_taskmgr() function is also no longer used and has been removed.
2022-10-25 22:56:48 -07:00
REQUIRE(!ISC_LINK_LINKED(request, link));
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
req_log(ISC_LOG_DEBUG(3), "%s: request %p", __func__, request);
checkpoint
2000-03-20 12:22:02 +00:00
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
/*
* These should have been cleaned up before the
* completion event was sent.
*/
INSIST(!ISC_LINK_LINKED(request, link));
INSIST(request->dispentry == NULL);
INSIST(request->dispatch == NULL);
checkpoint
2000-03-20 12:22:02 +00:00
request->magic = 0;
if (request->query != NULL) {
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
}
checkpoint
2000-03-20 12:22:02 +00:00
if (request->answer != NULL) {
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
}
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
if (request->tsig != NULL) {
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
}
tsig keys were not properly ref counted
2000-07-21 23:00:31 +00:00
if (request->tsigkey != NULL) {
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
}
remove more duplicated code
2001-01-23 19:50:10 +00:00
if (request->requestmgr != NULL) {
Refactor dispatch, resolver and request Since every dispsock was associated with a dispentry anyway (though not always vice versa), the members of dispsock have been combined into dispentry, which is now reference-counted. dispentry objects are now attached before connecting and detached afterward to prevent races between the connect callback and dns_dispatch_removeresponse(). Dispatch and dispatchmgr objects are now reference counted as well, and the shutdown process has been simplified. reference counting of resquery and request objects has also been cleaned up significantly. dns_dispatch_cancel() now flags a dispentry as having been canceled, so that if the connect callback runs after cancellation, it will not initiate a read. The isblackholed() function has been simplified.
2021-05-25 22:54:17 -07:00
dns_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
}
refactor dns_request to use loopmgr callbacks dns_request_create() and _createraw() now take a 'loop' parameter and run the callback event on the specified loop. as the task manager is no longer used, it has been removed from the dns_requestmgr structure. the dns_resolver_taskmgr() function is also no longer used and has been removed.
2022-10-25 22:56:48 -07:00
void *
dns_request_getarg(dns_request_t *request) {
REQUIRE(VALID_REQUEST(request));
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
REQUIRE(request->tid == isc_tid());
refactor dns_request to use loopmgr callbacks dns_request_create() and _createraw() now take a 'loop' parameter and run the callback event on the specified loop. as the task manager is no longer used, it has been removed from the dns_requestmgr structure. the dns_resolver_taskmgr() function is also no longer used and has been removed.
2022-10-25 22:56:48 -07:00
return request->arg;
}
isc_result_t
dns_request_getresult(dns_request_t *request) {
REQUIRE(VALID_REQUEST(request));
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
REQUIRE(request->tid == isc_tid());
refactor dns_request to use loopmgr callbacks dns_request_create() and _createraw() now take a 'loop' parameter and run the callback event on the specified loop. as the task manager is no longer used, it has been removed from the dns_requestmgr structure. the dns_resolver_taskmgr() function is also no longer used and has been removed.
2022-10-25 22:56:48 -07:00
return request->result;
}
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
#if DNS_REQUEST_TRACE
ISC_REFCOUNT_TRACE_IMPL(dns_request, req_destroy);
#else
refactor dns_request to use loopmgr callbacks dns_request_create() and _createraw() now take a 'loop' parameter and run the callback event on the specified loop. as the task manager is no longer used, it has been removed from the dns_requestmgr structure. the dns_resolver_taskmgr() function is also no longer used and has been removed.
2022-10-25 22:56:48 -07:00
ISC_REFCOUNT_IMPL(dns_request, req_destroy);
Pin dns_request to the associated loop When dns_request was canceled via dns_requestmgr_shutdown() the cancel event would be propagated on different loop (loop 0) than the loop where request was created on. In turn this would propagate down to isc_netmgr where we require all the events to be called from the matching isc_loop. Pin the dns_requests to the loops and ensure that all the events are called on the associated loop. This in turn allows us to remove the hashed locks on the requests and change the single .requests list to be a per-loop list for the request accounting. Additionally, do some extra cleanup because some race condititions are now not possible as all events on the dns_request are serialized.
2023-07-25 10:30:09 +02:00
#endif
refactor dns_request to use loopmgr callbacks dns_request_create() and _createraw() now take a 'loop' parameter and run the callback event on the specified loop. as the task manager is no longer used, it has been removed from the dns_requestmgr structure. the dns_resolver_taskmgr() function is also no longer used and has been removed.
2022-10-25 22:56:48 -07:00
convert TRACE -> logging: ISC_LOG_DEBUG(3)
2000-05-09 05:12:49 +00:00
static void
req_log(int level, const char *fmt, ...) {
va_list ap;
va_start(ap, fmt);
Remove logging context (isc_log_t) from the public namespace Now that the logging uses single global context, remove the isc_log_t from the public namespace.
2024-08-13 18:20:26 +02:00
isc_log_vwrite(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