More modularization for sockets/connections (#876)
Split socket from connection functions for a more clear delineation in functionality. This is needed to support future DNS over TLS. Also makes the new ares_process_fds() return a status code so we can detect out of memory conditions, this too is going to be needed for handling TLS which is more likely to run into such a situation. Finally, add in a new ares_htable_vpstr_t type and functions which will be needed as part of TLS session lookups. Authored-By: Brad House (@bradh352)coverity_scan
Brad House
7 months ago
committed by
GitHub
parent
3b80588384
commit
e0ef6a8a7a
15 changed files with 1199 additions and 676 deletions
@ -0,0 +1,506 @@ |
|||||||
|
/* MIT License
|
||||||
|
* |
||||||
|
* Copyright (c) Massachusetts Institute of Technology |
||||||
|
* Copyright (c) The c-ares project and its contributors |
||||||
|
* |
||||||
|
* Permission is hereby granted, free of charge, to any person obtaining a copy |
||||||
|
* of this software and associated documentation files (the "Software"), to deal |
||||||
|
* in the Software without restriction, including without limitation the rights |
||||||
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||||
|
* copies of the Software, and to permit persons to whom the Software is |
||||||
|
* furnished to do so, subject to the following conditions: |
||||||
|
* |
||||||
|
* The above copyright notice and this permission notice (including the next |
||||||
|
* paragraph) shall be included in all copies or substantial portions of the |
||||||
|
* Software. |
||||||
|
* |
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||||
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||||
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||||
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||||
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||||
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
||||||
|
* SOFTWARE. |
||||||
|
* |
||||||
|
* SPDX-License-Identifier: MIT |
||||||
|
*/ |
||||||
|
#include "ares_private.h" |
||||||
|
|
||||||
|
void ares_conn_sock_state_cb_update(ares_conn_t *conn, |
||||||
|
ares_conn_state_flags_t flags) |
||||||
|
{ |
||||||
|
ares_channel_t *channel = conn->server->channel; |
||||||
|
|
||||||
|
if ((conn->state_flags & ARES_CONN_STATE_CBFLAGS) != flags && |
||||||
|
channel->sock_state_cb) { |
||||||
|
channel->sock_state_cb(channel->sock_state_cb_data, conn->fd, |
||||||
|
flags & ARES_CONN_STATE_READ ? 1 : 0, |
||||||
|
flags & ARES_CONN_STATE_WRITE ? 1 : 0); |
||||||
|
} |
||||||
|
|
||||||
|
conn->state_flags &= ~((unsigned int)ARES_CONN_STATE_CBFLAGS); |
||||||
|
conn->state_flags |= flags; |
||||||
|
} |
||||||
|
|
||||||
|
ares_conn_err_t ares_conn_read(ares_conn_t *conn, void *data, size_t len, |
||||||
|
size_t *read_bytes) |
||||||
|
{ |
||||||
|
ares_channel_t *channel = conn->server->channel; |
||||||
|
ares_conn_err_t err; |
||||||
|
|
||||||
|
if (!(conn->flags & ARES_CONN_FLAG_TCP)) { |
||||||
|
struct sockaddr_storage sa_storage; |
||||||
|
ares_socklen_t salen = sizeof(sa_storage); |
||||||
|
|
||||||
|
memset(&sa_storage, 0, sizeof(sa_storage)); |
||||||
|
|
||||||
|
err = |
||||||
|
ares_socket_recvfrom(channel, conn->fd, ARES_FALSE, data, len, 0, |
||||||
|
(struct sockaddr *)&sa_storage, &salen, read_bytes); |
||||||
|
|
||||||
|
#ifdef HAVE_RECVFROM |
||||||
|
if (err == ARES_CONN_ERR_SUCCESS && |
||||||
|
!ares_sockaddr_addr_eq((struct sockaddr *)&sa_storage, |
||||||
|
&conn->server->addr)) { |
||||||
|
err = ARES_CONN_ERR_WOULDBLOCK; |
||||||
|
} |
||||||
|
#endif |
||||||
|
} else { |
||||||
|
err = ares_socket_recv(channel, conn->fd, ARES_TRUE, data, len, read_bytes); |
||||||
|
} |
||||||
|
|
||||||
|
/* Toggle connected state if needed */ |
||||||
|
if (err == ARES_CONN_ERR_SUCCESS) { |
||||||
|
conn->state_flags |= ARES_CONN_STATE_CONNECTED; |
||||||
|
} |
||||||
|
|
||||||
|
return err; |
||||||
|
} |
||||||
|
|
||||||
|
/* Use like:
|
||||||
|
* struct sockaddr_storage sa_storage; |
||||||
|
* ares_socklen_t salen = sizeof(sa_storage); |
||||||
|
* struct sockaddr *sa = (struct sockaddr *)&sa_storage; |
||||||
|
* ares_conn_set_sockaddr(conn, sa, &salen); |
||||||
|
*/ |
||||||
|
static ares_status_t ares_conn_set_sockaddr(const ares_conn_t *conn, |
||||||
|
struct sockaddr *sa, |
||||||
|
ares_socklen_t *salen) |
||||||
|
{ |
||||||
|
const ares_server_t *server = conn->server; |
||||||
|
unsigned short port = |
||||||
|
conn->flags & ARES_CONN_FLAG_TCP ? server->tcp_port : server->udp_port; |
||||||
|
struct sockaddr_in *sin; |
||||||
|
struct sockaddr_in6 *sin6; |
||||||
|
|
||||||
|
switch (server->addr.family) { |
||||||
|
case AF_INET: |
||||||
|
sin = (struct sockaddr_in *)(void *)sa; |
||||||
|
if (*salen < (ares_socklen_t)sizeof(*sin)) { |
||||||
|
return ARES_EFORMERR; |
||||||
|
} |
||||||
|
*salen = sizeof(*sin); |
||||||
|
memset(sin, 0, sizeof(*sin)); |
||||||
|
sin->sin_family = AF_INET; |
||||||
|
sin->sin_port = htons(port); |
||||||
|
memcpy(&sin->sin_addr, &server->addr.addr.addr4, sizeof(sin->sin_addr)); |
||||||
|
return ARES_SUCCESS; |
||||||
|
case AF_INET6: |
||||||
|
sin6 = (struct sockaddr_in6 *)(void *)sa; |
||||||
|
if (*salen < (ares_socklen_t)sizeof(*sin6)) { |
||||||
|
return ARES_EFORMERR; |
||||||
|
} |
||||||
|
*salen = sizeof(*sin6); |
||||||
|
memset(sin6, 0, sizeof(*sin6)); |
||||||
|
sin6->sin6_family = AF_INET6; |
||||||
|
sin6->sin6_port = htons(port); |
||||||
|
memcpy(&sin6->sin6_addr, &server->addr.addr.addr6, |
||||||
|
sizeof(sin6->sin6_addr)); |
||||||
|
#ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID |
||||||
|
sin6->sin6_scope_id = server->ll_scope; |
||||||
|
#endif |
||||||
|
return ARES_SUCCESS; |
||||||
|
default: |
||||||
|
break; |
||||||
|
} |
||||||
|
|
||||||
|
return ARES_EBADFAMILY; |
||||||
|
} |
||||||
|
|
||||||
|
static ares_status_t ares_conn_set_self_ip(ares_conn_t *conn, ares_bool_t early) |
||||||
|
{ |
||||||
|
struct sockaddr_storage sa_storage; |
||||||
|
int rv; |
||||||
|
ares_socklen_t len = sizeof(sa_storage); |
||||||
|
|
||||||
|
/* We call this twice on TFO, if we already have the IP we can go ahead and
|
||||||
|
* skip processing */ |
||||||
|
if (!early && conn->self_ip.family != AF_UNSPEC) { |
||||||
|
return ARES_SUCCESS; |
||||||
|
} |
||||||
|
|
||||||
|
memset(&sa_storage, 0, sizeof(sa_storage)); |
||||||
|
|
||||||
|
rv = getsockname(conn->fd, (struct sockaddr *)(void *)&sa_storage, &len); |
||||||
|
if (rv != 0) { |
||||||
|
/* During TCP FastOpen, we can't get the IP this early since connect()
|
||||||
|
* may not be called. That's ok, we'll try again later */ |
||||||
|
if (early && conn->flags & ARES_CONN_FLAG_TCP && |
||||||
|
conn->flags & ARES_CONN_FLAG_TFO) { |
||||||
|
memset(&conn->self_ip, 0, sizeof(conn->self_ip)); |
||||||
|
return ARES_SUCCESS; |
||||||
|
} |
||||||
|
return ARES_ECONNREFUSED; |
||||||
|
} |
||||||
|
|
||||||
|
if (!ares_sockaddr_to_ares_addr(&conn->self_ip, NULL, |
||||||
|
(struct sockaddr *)(void *)&sa_storage)) { |
||||||
|
return ARES_ECONNREFUSED; |
||||||
|
} |
||||||
|
|
||||||
|
return ARES_SUCCESS; |
||||||
|
} |
||||||
|
|
||||||
|
ares_conn_err_t ares_conn_write(ares_conn_t *conn, const void *data, size_t len, |
||||||
|
size_t *written) |
||||||
|
{ |
||||||
|
ares_channel_t *channel = conn->server->channel; |
||||||
|
ares_bool_t is_tfo = ARES_FALSE; |
||||||
|
ares_conn_err_t err = ARES_CONN_ERR_SUCCESS; |
||||||
|
|
||||||
|
*written = 0; |
||||||
|
|
||||||
|
/* Don't try to write if not doing initial TFO and not connected */ |
||||||
|
if (conn->flags & ARES_CONN_FLAG_TCP && |
||||||
|
!(conn->state_flags & ARES_CONN_STATE_CONNECTED) && |
||||||
|
!(conn->flags & ARES_CONN_FLAG_TFO_INITIAL)) { |
||||||
|
return ARES_CONN_ERR_WOULDBLOCK; |
||||||
|
} |
||||||
|
|
||||||
|
if (conn->flags & ARES_CONN_FLAG_TFO_INITIAL) { |
||||||
|
struct sockaddr_storage sa_storage; |
||||||
|
ares_socklen_t salen = sizeof(sa_storage); |
||||||
|
struct sockaddr *sa = (struct sockaddr *)&sa_storage; |
||||||
|
|
||||||
|
conn->flags &= ~((unsigned int)ARES_CONN_FLAG_TFO_INITIAL); |
||||||
|
is_tfo = ARES_TRUE; |
||||||
|
|
||||||
|
if (ares_conn_set_sockaddr(conn, sa, &salen) != ARES_SUCCESS) { |
||||||
|
return ARES_CONN_ERR_FAILURE; |
||||||
|
} |
||||||
|
|
||||||
|
err = |
||||||
|
ares_socket_write_tfo(channel, conn->fd, data, len, written, sa, salen); |
||||||
|
if (err != ARES_CONN_ERR_SUCCESS) { |
||||||
|
goto done; |
||||||
|
} |
||||||
|
|
||||||
|
/* If using TFO, we might not have been able to get an IP earlier, since
|
||||||
|
* we hadn't informed the OS of the destination. When using sendto() |
||||||
|
* now we have so we should be able to fetch it */ |
||||||
|
ares_conn_set_self_ip(conn, ARES_FALSE); |
||||||
|
goto done; |
||||||
|
} |
||||||
|
|
||||||
|
err = ares_socket_write(channel, conn->fd, data, len, written); |
||||||
|
if (err != ARES_CONN_ERR_SUCCESS) { |
||||||
|
goto done; |
||||||
|
} |
||||||
|
|
||||||
|
done: |
||||||
|
if (err == ARES_CONN_ERR_SUCCESS && len == *written) { |
||||||
|
/* Wrote all data, make sure we're not listening for write events unless
|
||||||
|
* using TFO, in which case we'll need a write event to know when |
||||||
|
* we're connected. */ |
||||||
|
ares_conn_sock_state_cb_update( |
||||||
|
conn, ARES_CONN_STATE_READ | |
||||||
|
(is_tfo ? ARES_CONN_STATE_WRITE : ARES_CONN_STATE_NONE)); |
||||||
|
} else if (err == ARES_CONN_ERR_WOULDBLOCK) { |
||||||
|
/* Need to wait on more buffer space to write */ |
||||||
|
ares_conn_sock_state_cb_update(conn, ARES_CONN_STATE_READ | |
||||||
|
ARES_CONN_STATE_WRITE); |
||||||
|
} |
||||||
|
|
||||||
|
return err; |
||||||
|
} |
||||||
|
|
||||||
|
ares_status_t ares_conn_flush(ares_conn_t *conn) |
||||||
|
{ |
||||||
|
const unsigned char *data; |
||||||
|
size_t data_len; |
||||||
|
size_t count; |
||||||
|
ares_conn_err_t err; |
||||||
|
ares_status_t status; |
||||||
|
ares_bool_t tfo = ARES_FALSE; |
||||||
|
|
||||||
|
if (conn == NULL) { |
||||||
|
return ARES_EFORMERR; |
||||||
|
} |
||||||
|
|
||||||
|
if (conn->flags & ARES_CONN_FLAG_TFO_INITIAL) { |
||||||
|
tfo = ARES_TRUE; |
||||||
|
} |
||||||
|
|
||||||
|
do { |
||||||
|
if (ares_buf_len(conn->out_buf) == 0) { |
||||||
|
status = ARES_SUCCESS; |
||||||
|
goto done; |
||||||
|
} |
||||||
|
|
||||||
|
if (conn->flags & ARES_CONN_FLAG_TCP) { |
||||||
|
data = ares_buf_peek(conn->out_buf, &data_len); |
||||||
|
} else { |
||||||
|
unsigned short msg_len; |
||||||
|
|
||||||
|
/* Read length, then provide buffer without length */ |
||||||
|
ares_buf_tag(conn->out_buf); |
||||||
|
status = ares_buf_fetch_be16(conn->out_buf, &msg_len); |
||||||
|
if (status != ARES_SUCCESS) { |
||||||
|
return status; |
||||||
|
} |
||||||
|
ares_buf_tag_rollback(conn->out_buf); |
||||||
|
|
||||||
|
data = ares_buf_peek(conn->out_buf, &data_len); |
||||||
|
if (data_len < (size_t)(msg_len + 2)) { |
||||||
|
status = ARES_EFORMERR; |
||||||
|
goto done; |
||||||
|
} |
||||||
|
data += 2; |
||||||
|
data_len = msg_len; |
||||||
|
} |
||||||
|
|
||||||
|
err = ares_conn_write(conn, data, data_len, &count); |
||||||
|
if (err != ARES_CONN_ERR_SUCCESS) { |
||||||
|
if (err != ARES_CONN_ERR_WOULDBLOCK) { |
||||||
|
status = ARES_ECONNREFUSED; |
||||||
|
goto done; |
||||||
|
} |
||||||
|
status = ARES_SUCCESS; |
||||||
|
goto done; |
||||||
|
} |
||||||
|
|
||||||
|
/* UDP didn't send the length prefix so augment that here */ |
||||||
|
if (!(conn->flags & ARES_CONN_FLAG_TCP)) { |
||||||
|
count += 2; |
||||||
|
} |
||||||
|
|
||||||
|
/* Strip data written from the buffer */ |
||||||
|
ares_buf_consume(conn->out_buf, count); |
||||||
|
status = ARES_SUCCESS; |
||||||
|
|
||||||
|
/* Loop only for UDP since we have to send per-packet. We already
|
||||||
|
* sent everything we could if using tcp */ |
||||||
|
} while (!(conn->flags & ARES_CONN_FLAG_TCP)); |
||||||
|
|
||||||
|
done: |
||||||
|
if (status == ARES_SUCCESS) { |
||||||
|
ares_conn_state_flags_t flags = ARES_CONN_STATE_READ; |
||||||
|
|
||||||
|
/* When using TFO, the we need to enabling waiting on a write event to
|
||||||
|
* be notified of when a connection is actually established */ |
||||||
|
if (tfo) { |
||||||
|
flags |= ARES_CONN_STATE_WRITE; |
||||||
|
} |
||||||
|
|
||||||
|
/* If using TCP and not all data was written (partial write), that means
|
||||||
|
* we need to also wait on a write event */ |
||||||
|
if (conn->flags & ARES_CONN_FLAG_TCP && ares_buf_len(conn->out_buf)) { |
||||||
|
flags |= ARES_CONN_STATE_WRITE; |
||||||
|
} |
||||||
|
|
||||||
|
ares_conn_sock_state_cb_update(conn, flags); |
||||||
|
} |
||||||
|
|
||||||
|
return status; |
||||||
|
} |
||||||
|
|
||||||
|
static ares_status_t ares_conn_connect(ares_conn_t *conn, struct sockaddr *sa, |
||||||
|
ares_socklen_t salen) |
||||||
|
{ |
||||||
|
ares_conn_err_t err; |
||||||
|
|
||||||
|
err = ares_socket_connect( |
||||||
|
conn->server->channel, conn->fd, |
||||||
|
(conn->flags & ARES_CONN_FLAG_TFO) ? ARES_TRUE : ARES_FALSE, sa, salen); |
||||||
|
|
||||||
|
if (err != ARES_CONN_ERR_WOULDBLOCK && err != ARES_CONN_ERR_SUCCESS) { |
||||||
|
return ARES_ECONNREFUSED; |
||||||
|
} |
||||||
|
return ARES_SUCCESS; |
||||||
|
} |
||||||
|
|
||||||
|
ares_status_t ares_open_connection(ares_conn_t **conn_out, |
||||||
|
ares_channel_t *channel, |
||||||
|
ares_server_t *server, ares_bool_t is_tcp) |
||||||
|
{ |
||||||
|
ares_status_t status; |
||||||
|
struct sockaddr_storage sa_storage; |
||||||
|
ares_socklen_t salen = sizeof(sa_storage); |
||||||
|
struct sockaddr *sa = (struct sockaddr *)&sa_storage; |
||||||
|
ares_conn_t *conn; |
||||||
|
ares_llist_node_t *node = NULL; |
||||||
|
int stype = is_tcp ? SOCK_STREAM : SOCK_DGRAM; |
||||||
|
ares_conn_state_flags_t state_flags; |
||||||
|
|
||||||
|
*conn_out = NULL; |
||||||
|
|
||||||
|
conn = ares_malloc(sizeof(*conn)); |
||||||
|
if (conn == NULL) { |
||||||
|
return ARES_ENOMEM; /* LCOV_EXCL_LINE: OutOfMemory */ |
||||||
|
} |
||||||
|
|
||||||
|
memset(conn, 0, sizeof(*conn)); |
||||||
|
conn->fd = ARES_SOCKET_BAD; |
||||||
|
conn->server = server; |
||||||
|
conn->queries_to_conn = ares_llist_create(NULL); |
||||||
|
conn->flags = is_tcp ? ARES_CONN_FLAG_TCP : ARES_CONN_FLAG_NONE; |
||||||
|
conn->out_buf = ares_buf_create(); |
||||||
|
conn->in_buf = ares_buf_create(); |
||||||
|
|
||||||
|
if (conn->queries_to_conn == NULL || conn->out_buf == NULL || |
||||||
|
conn->in_buf == NULL) { |
||||||
|
/* LCOV_EXCL_START: OutOfMemory */ |
||||||
|
status = ARES_ENOMEM; |
||||||
|
goto done; |
||||||
|
/* LCOV_EXCL_STOP */ |
||||||
|
} |
||||||
|
|
||||||
|
/* Enable TFO if the OS supports it and we were passed in data to send during
|
||||||
|
* the connect. It might be disabled later if an error is encountered. Make |
||||||
|
* sure a user isn't overriding anything. */ |
||||||
|
if (conn->flags & ARES_CONN_FLAG_TCP && ares_socket_tfo_supported(channel)) { |
||||||
|
conn->flags |= ARES_CONN_FLAG_TFO; |
||||||
|
} |
||||||
|
|
||||||
|
/* Convert into the struct sockaddr structure needed by the OS */ |
||||||
|
status = ares_conn_set_sockaddr(conn, sa, &salen); |
||||||
|
if (status != ARES_SUCCESS) { |
||||||
|
goto done; |
||||||
|
} |
||||||
|
|
||||||
|
/* Acquire a socket. */ |
||||||
|
if (ares_socket_open(&conn->fd, channel, server->addr.family, stype, 0) != |
||||||
|
ARES_CONN_ERR_SUCCESS) { |
||||||
|
status = ARES_ECONNREFUSED; |
||||||
|
goto done; |
||||||
|
} |
||||||
|
|
||||||
|
/* Configure it. */ |
||||||
|
status = ares_socket_configure( |
||||||
|
channel, server->addr.family, |
||||||
|
(conn->flags & ARES_CONN_FLAG_TCP) ? ARES_TRUE : ARES_FALSE, conn->fd); |
||||||
|
if (status != ARES_SUCCESS) { |
||||||
|
goto done; |
||||||
|
} |
||||||
|
|
||||||
|
/* Enable TFO if possible */ |
||||||
|
if (conn->flags & ARES_CONN_FLAG_TFO) { |
||||||
|
if (ares_socket_enable_tfo(channel, conn->fd) != ARES_CONN_ERR_SUCCESS) { |
||||||
|
conn->flags &= ~((unsigned int)ARES_CONN_FLAG_TFO); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if (channel->sock_config_cb) { |
||||||
|
int err = |
||||||
|
channel->sock_config_cb(conn->fd, stype, channel->sock_config_cb_data); |
||||||
|
if (err < 0) { |
||||||
|
status = ARES_ECONNREFUSED; |
||||||
|
goto done; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/* Connect */ |
||||||
|
status = ares_conn_connect(conn, sa, salen); |
||||||
|
if (status != ARES_SUCCESS) { |
||||||
|
goto done; |
||||||
|
} |
||||||
|
|
||||||
|
if (channel->sock_create_cb) { |
||||||
|
int err = |
||||||
|
channel->sock_create_cb(conn->fd, stype, channel->sock_create_cb_data); |
||||||
|
if (err < 0) { |
||||||
|
status = ARES_ECONNREFUSED; |
||||||
|
goto done; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/* Let the connection know we haven't written our first packet yet for TFO */ |
||||||
|
if (conn->flags & ARES_CONN_FLAG_TFO) { |
||||||
|
conn->flags |= ARES_CONN_FLAG_TFO_INITIAL; |
||||||
|
} |
||||||
|
|
||||||
|
/* Need to store our own ip for DNS cookie support */ |
||||||
|
status = ares_conn_set_self_ip(conn, ARES_TRUE); |
||||||
|
if (status != ARES_SUCCESS) { |
||||||
|
goto done; /* LCOV_EXCL_LINE: UntestablePath */ |
||||||
|
} |
||||||
|
|
||||||
|
/* TCP connections are thrown to the end as we don't spawn multiple TCP
|
||||||
|
* connections. UDP connections are put on front where the newest connection |
||||||
|
* can be quickly pulled */ |
||||||
|
if (is_tcp) { |
||||||
|
node = ares_llist_insert_last(server->connections, conn); |
||||||
|
} else { |
||||||
|
node = ares_llist_insert_first(server->connections, conn); |
||||||
|
} |
||||||
|
if (node == NULL) { |
||||||
|
/* LCOV_EXCL_START: OutOfMemory */ |
||||||
|
status = ARES_ENOMEM; |
||||||
|
goto done; |
||||||
|
/* LCOV_EXCL_STOP */ |
||||||
|
} |
||||||
|
|
||||||
|
/* Register globally to quickly map event on file descriptor to connection
|
||||||
|
* node object */ |
||||||
|
if (!ares_htable_asvp_insert(channel->connnode_by_socket, conn->fd, node)) { |
||||||
|
/* LCOV_EXCL_START: OutOfMemory */ |
||||||
|
status = ARES_ENOMEM; |
||||||
|
goto done; |
||||||
|
/* LCOV_EXCL_STOP */ |
||||||
|
} |
||||||
|
|
||||||
|
state_flags = ARES_CONN_STATE_READ; |
||||||
|
|
||||||
|
/* Get notified on connect if using TCP */ |
||||||
|
if (conn->flags & ARES_CONN_FLAG_TCP) { |
||||||
|
state_flags |= ARES_CONN_STATE_WRITE; |
||||||
|
} |
||||||
|
|
||||||
|
/* Dot no attempt to update sock state callbacks on TFO until *after* the
|
||||||
|
* initial write is performed. Due to the notification event, its possible |
||||||
|
* an erroneous read can come in before the attempt to write the data which |
||||||
|
* might be used to set the ip address */ |
||||||
|
if (!(conn->flags & ARES_CONN_FLAG_TFO_INITIAL)) { |
||||||
|
ares_conn_sock_state_cb_update(conn, state_flags); |
||||||
|
} |
||||||
|
|
||||||
|
if (is_tcp) { |
||||||
|
server->tcp_conn = conn; |
||||||
|
} |
||||||
|
|
||||||
|
done: |
||||||
|
if (status != ARES_SUCCESS) { |
||||||
|
ares_llist_node_claim(node); |
||||||
|
ares_llist_destroy(conn->queries_to_conn); |
||||||
|
ares_socket_close(channel, conn->fd); |
||||||
|
ares_buf_destroy(conn->out_buf); |
||||||
|
ares_buf_destroy(conn->in_buf); |
||||||
|
ares_free(conn); |
||||||
|
} else { |
||||||
|
*conn_out = conn; |
||||||
|
} |
||||||
|
return status; |
||||||
|
} |
||||||
|
|
||||||
|
ares_conn_t *ares_conn_from_fd(ares_channel_t *channel, ares_socket_t fd) |
||||||
|
{ |
||||||
|
ares_llist_node_t *node; |
||||||
|
|
||||||
|
node = ares_htable_asvp_get_direct(channel->connnode_by_socket, fd); |
||||||
|
if (node == NULL) { |
||||||
|
return NULL; |
||||||
|
} |
||||||
|
|
||||||
|
return ares_llist_node_val(node); |
||||||
|
} |
||||||
|
|
||||||
@ -0,0 +1,79 @@ |
|||||||
|
/* MIT License
|
||||||
|
* |
||||||
|
* Copyright (c) 2024 Brad House |
||||||
|
* |
||||||
|
* Permission is hereby granted, free of charge, to any person obtaining a copy |
||||||
|
* of this software and associated documentation files (the "Software"), to deal |
||||||
|
* in the Software without restriction, including without limitation the rights |
||||||
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||||
|
* copies of the Software, and to permit persons to whom the Software is |
||||||
|
* furnished to do so, subject to the following conditions: |
||||||
|
* |
||||||
|
* The above copyright notice and this permission notice (including the next |
||||||
|
* paragraph) shall be included in all copies or substantial portions of the |
||||||
|
* Software. |
||||||
|
* |
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||||
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||||
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||||
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||||
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||||
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
||||||
|
* SOFTWARE. |
||||||
|
* |
||||||
|
* SPDX-License-Identifier: MIT |
||||||
|
*/ |
||||||
|
|
||||||
|
#ifndef __ARES_SOCKET_H |
||||||
|
#define __ARES_SOCKET_H |
||||||
|
|
||||||
|
/*! Socket errors */ |
||||||
|
typedef enum { |
||||||
|
ARES_CONN_ERR_SUCCESS = 0, /*!< Success */ |
||||||
|
ARES_CONN_ERR_WOULDBLOCK = 1, /*!< Operation would block */ |
||||||
|
ARES_CONN_ERR_CONNCLOSED = 2, /*!< Connection closed (gracefully) */ |
||||||
|
ARES_CONN_ERR_CONNABORTED = 3, /*!< Connection Aborted */ |
||||||
|
ARES_CONN_ERR_CONNRESET = 4, /*!< Connection Reset */ |
||||||
|
ARES_CONN_ERR_CONNREFUSED = 5, /*!< Connection Refused */ |
||||||
|
ARES_CONN_ERR_CONNTIMEDOUT = 6, /*!< Connection Timed Out */ |
||||||
|
ARES_CONN_ERR_HOSTDOWN = 7, /*!< Host Down */ |
||||||
|
ARES_CONN_ERR_HOSTUNREACH = 8, /*!< Host Unreachable */ |
||||||
|
ARES_CONN_ERR_NETDOWN = 9, /*!< Network Down */ |
||||||
|
ARES_CONN_ERR_NETUNREACH = 10, /*!< Network Unreachable */ |
||||||
|
ARES_CONN_ERR_INTERRUPT = 11, /*!< Call interrupted by signal, repeat */ |
||||||
|
ARES_CONN_ERR_AFNOSUPPORT = 12, /*!< Address family not supported */ |
||||||
|
ARES_CONN_ERR_BADADDR = 13, /*!< Bad Address / Unavailable */ |
||||||
|
ARES_CONN_ERR_NOMEM = 14, /*!< Out of memory */ |
||||||
|
ARES_CONN_ERR_INVALID = 15, /*!< Invalid Usage */ |
||||||
|
ARES_CONN_ERR_TOOLARGE = 16, /*!< Request size too large */ |
||||||
|
ARES_CONN_ERR_NOTIMP = 17, /*!< Not implemented */ |
||||||
|
ARES_CONN_ERR_FAILURE = 99 /*!< Generic failure */ |
||||||
|
} ares_conn_err_t; |
||||||
|
|
||||||
|
ares_bool_t ares_socket_tfo_supported(const ares_channel_t *channel); |
||||||
|
|
||||||
|
ares_bool_t ares_sockaddr_addr_eq(const struct sockaddr *sa, |
||||||
|
const struct ares_addr *aa); |
||||||
|
ares_status_t ares_socket_configure(ares_channel_t *channel, int family, |
||||||
|
ares_bool_t is_tcp, ares_socket_t fd); |
||||||
|
ares_conn_err_t ares_socket_enable_tfo(const ares_channel_t *channel, |
||||||
|
ares_socket_t fd); |
||||||
|
ares_conn_err_t ares_socket_open(ares_socket_t *sock, ares_channel_t *channel, |
||||||
|
int af, int type, int protocol); |
||||||
|
ares_bool_t ares_socket_try_again(int errnum); |
||||||
|
void ares_socket_close(ares_channel_t *channel, ares_socket_t s); |
||||||
|
ares_conn_err_t ares_socket_connect(ares_channel_t *channel, |
||||||
|
ares_socket_t sockfd, ares_bool_t is_tfo, |
||||||
|
const struct sockaddr *addr, |
||||||
|
ares_socklen_t addrlen); |
||||||
|
ares_bool_t ares_sockaddr_to_ares_addr(struct ares_addr *ares_addr, |
||||||
|
unsigned short *port, |
||||||
|
const struct sockaddr *sockaddr); |
||||||
|
ares_conn_err_t ares_socket_write(ares_channel_t *channel, ares_socket_t fd, |
||||||
|
const void *data, size_t len, |
||||||
|
size_t *written); |
||||||
|
ares_conn_err_t ares_socket_write_tfo(ares_channel_t *channel, ares_socket_t fd, |
||||||
|
const void *data, size_t len, |
||||||
|
size_t *written, struct sockaddr *sa, |
||||||
|
ares_socklen_t salen); |
||||||
|
#endif |
||||||
@ -0,0 +1,186 @@ |
|||||||
|
/* MIT License
|
||||||
|
* |
||||||
|
* Copyright (c) 2024 Brad House |
||||||
|
* |
||||||
|
* Permission is hereby granted, free of charge, to any person obtaining a copy |
||||||
|
* of this software and associated documentation files (the "Software"), to deal |
||||||
|
* in the Software without restriction, including without limitation the rights |
||||||
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||||
|
* copies of the Software, and to permit persons to whom the Software is |
||||||
|
* furnished to do so, subject to the following conditions: |
||||||
|
* |
||||||
|
* The above copyright notice and this permission notice (including the next |
||||||
|
* paragraph) shall be included in all copies or substantial portions of the |
||||||
|
* Software. |
||||||
|
* |
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||||
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||||
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||||
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||||
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||||
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
||||||
|
* SOFTWARE. |
||||||
|
* |
||||||
|
* SPDX-License-Identifier: MIT |
||||||
|
*/ |
||||||
|
#include "ares_private.h" |
||||||
|
#include "ares_htable.h" |
||||||
|
#include "ares_htable_vpstr.h" |
||||||
|
|
||||||
|
struct ares_htable_vpstr { |
||||||
|
ares_htable_t *hash; |
||||||
|
}; |
||||||
|
|
||||||
|
typedef struct { |
||||||
|
void *key; |
||||||
|
char *val; |
||||||
|
ares_htable_vpstr_t *parent; |
||||||
|
} ares_htable_vpstr_bucket_t; |
||||||
|
|
||||||
|
void ares_htable_vpstr_destroy(ares_htable_vpstr_t *htable) |
||||||
|
{ |
||||||
|
if (htable == NULL) { |
||||||
|
return; /* LCOV_EXCL_LINE: DefensiveCoding */ |
||||||
|
} |
||||||
|
|
||||||
|
ares_htable_destroy(htable->hash); |
||||||
|
ares_free(htable); |
||||||
|
} |
||||||
|
|
||||||
|
static unsigned int hash_func(const void *key, unsigned int seed) |
||||||
|
{ |
||||||
|
return ares_htable_hash_FNV1a((const unsigned char *)&key, sizeof(key), seed); |
||||||
|
} |
||||||
|
|
||||||
|
static const void *bucket_key(const void *bucket) |
||||||
|
{ |
||||||
|
const ares_htable_vpstr_bucket_t *arg = bucket; |
||||||
|
return arg->key; |
||||||
|
} |
||||||
|
|
||||||
|
static void bucket_free(void *bucket) |
||||||
|
{ |
||||||
|
ares_htable_vpstr_bucket_t *arg = bucket; |
||||||
|
|
||||||
|
ares_free(arg->val); |
||||||
|
|
||||||
|
ares_free(arg); |
||||||
|
} |
||||||
|
|
||||||
|
static ares_bool_t key_eq(const void *key1, const void *key2) |
||||||
|
{ |
||||||
|
if (key1 == key2) { |
||||||
|
return ARES_TRUE; |
||||||
|
} |
||||||
|
|
||||||
|
return ARES_FALSE; |
||||||
|
} |
||||||
|
|
||||||
|
ares_htable_vpstr_t *ares_htable_vpstr_create(void) |
||||||
|
{ |
||||||
|
ares_htable_vpstr_t *htable = ares_malloc(sizeof(*htable)); |
||||||
|
if (htable == NULL) { |
||||||
|
goto fail; /* LCOV_EXCL_LINE: OutOfMemory */ |
||||||
|
} |
||||||
|
|
||||||
|
htable->hash = ares_htable_create(hash_func, bucket_key, bucket_free, key_eq); |
||||||
|
if (htable->hash == NULL) { |
||||||
|
goto fail; /* LCOV_EXCL_LINE: OutOfMemory */ |
||||||
|
} |
||||||
|
|
||||||
|
return htable; |
||||||
|
|
||||||
|
/* LCOV_EXCL_START: OutOfMemory */ |
||||||
|
fail: |
||||||
|
if (htable) { |
||||||
|
ares_htable_destroy(htable->hash); |
||||||
|
ares_free(htable); |
||||||
|
} |
||||||
|
return NULL; |
||||||
|
/* LCOV_EXCL_STOP */ |
||||||
|
} |
||||||
|
|
||||||
|
ares_bool_t ares_htable_vpstr_insert(ares_htable_vpstr_t *htable, void *key, |
||||||
|
const char *val) |
||||||
|
{ |
||||||
|
ares_htable_vpstr_bucket_t *bucket = NULL; |
||||||
|
|
||||||
|
if (htable == NULL) { |
||||||
|
goto fail; |
||||||
|
} |
||||||
|
|
||||||
|
bucket = ares_malloc(sizeof(*bucket)); |
||||||
|
if (bucket == NULL) { |
||||||
|
goto fail; |
||||||
|
} |
||||||
|
|
||||||
|
bucket->parent = htable; |
||||||
|
bucket->key = key; |
||||||
|
bucket->val = ares_strdup(val); |
||||||
|
if (bucket->val == NULL) { |
||||||
|
goto fail; |
||||||
|
} |
||||||
|
|
||||||
|
if (!ares_htable_insert(htable->hash, bucket)) { |
||||||
|
goto fail; |
||||||
|
} |
||||||
|
|
||||||
|
return ARES_TRUE; |
||||||
|
|
||||||
|
fail: |
||||||
|
if (bucket) { |
||||||
|
ares_free(bucket->val); |
||||||
|
ares_free(bucket); |
||||||
|
} |
||||||
|
return ARES_FALSE; |
||||||
|
} |
||||||
|
|
||||||
|
ares_bool_t ares_htable_vpstr_get(const ares_htable_vpstr_t *htable, |
||||||
|
const void *key, const char **val) |
||||||
|
{ |
||||||
|
ares_htable_vpstr_bucket_t *bucket = NULL; |
||||||
|
|
||||||
|
if (val) { |
||||||
|
*val = NULL; |
||||||
|
} |
||||||
|
|
||||||
|
if (htable == NULL) { |
||||||
|
return ARES_FALSE; |
||||||
|
} |
||||||
|
|
||||||
|
bucket = ares_htable_get(htable->hash, key); |
||||||
|
if (bucket == NULL) { |
||||||
|
return ARES_FALSE; |
||||||
|
} |
||||||
|
|
||||||
|
if (val) { |
||||||
|
*val = bucket->val; |
||||||
|
} |
||||||
|
return ARES_TRUE; |
||||||
|
} |
||||||
|
|
||||||
|
const char *ares_htable_vpstr_get_direct(const ares_htable_vpstr_t *htable, |
||||||
|
const void *key) |
||||||
|
{ |
||||||
|
const char *val = NULL; |
||||||
|
ares_htable_vpstr_get(htable, key, &val); |
||||||
|
return val; |
||||||
|
} |
||||||
|
|
||||||
|
ares_bool_t ares_htable_vpstr_remove(ares_htable_vpstr_t *htable, |
||||||
|
const void *key) |
||||||
|
{ |
||||||
|
if (htable == NULL) { |
||||||
|
return ARES_FALSE; |
||||||
|
} |
||||||
|
|
||||||
|
return ares_htable_remove(htable->hash, key); |
||||||
|
} |
||||||
|
|
||||||
|
size_t ares_htable_vpstr_num_keys(const ares_htable_vpstr_t *htable) |
||||||
|
{ |
||||||
|
if (htable == NULL) { |
||||||
|
return 0; |
||||||
|
} |
||||||
|
return ares_htable_num_keys(htable->hash); |
||||||
|
} |
||||||
@ -0,0 +1,111 @@ |
|||||||
|
/* MIT License
|
||||||
|
* |
||||||
|
* Copyright (c) 2024 Brad House |
||||||
|
* |
||||||
|
* Permission is hereby granted, free of charge, to any person obtaining a copy |
||||||
|
* of this software and associated documentation files (the "Software"), to deal |
||||||
|
* in the Software without restriction, including without limitation the rights |
||||||
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||||
|
* copies of the Software, and to permit persons to whom the Software is |
||||||
|
* furnished to do so, subject to the following conditions: |
||||||
|
* |
||||||
|
* The above copyright notice and this permission notice (including the next |
||||||
|
* paragraph) shall be included in all copies or substantial portions of the |
||||||
|
* Software. |
||||||
|
* |
||||||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||||
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||||
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||||
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||||
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||||
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
||||||
|
* SOFTWARE. |
||||||
|
* |
||||||
|
* SPDX-License-Identifier: MIT |
||||||
|
*/ |
||||||
|
#ifndef __ARES__HTABLE_VPSTR_H |
||||||
|
#define __ARES__HTABLE_VPSTR_H |
||||||
|
|
||||||
|
/*! \addtogroup ares_htable_vpstr HashTable with void pointer Key and string
|
||||||
|
* value |
||||||
|
* |
||||||
|
* This data structure wraps the base ares_htable data structure in order to |
||||||
|
* split the key and value data types as void pointer and string, respectively. |
||||||
|
* |
||||||
|
* Average time complexity: |
||||||
|
* - Insert: O(1) |
||||||
|
* - Search: O(1) |
||||||
|
* - Delete: O(1) |
||||||
|
* |
||||||
|
* @{ |
||||||
|
*/ |
||||||
|
|
||||||
|
struct ares_htable_vpstr; |
||||||
|
|
||||||
|
/*! Opaque data type for void pointer key, string value hash table
|
||||||
|
* implementation */ |
||||||
|
typedef struct ares_htable_vpstr ares_htable_vpstr_t; |
||||||
|
|
||||||
|
/*! Destroy hashtable
|
||||||
|
* |
||||||
|
* \param[in] htable Initialized hashtable |
||||||
|
*/ |
||||||
|
CARES_EXTERN void ares_htable_vpstr_destroy(ares_htable_vpstr_t *htable); |
||||||
|
|
||||||
|
/*! Create void pointer key, string value hash table
|
||||||
|
* |
||||||
|
*/ |
||||||
|
CARES_EXTERN ares_htable_vpstr_t *ares_htable_vpstr_create(void); |
||||||
|
|
||||||
|
/*! Insert key/value into hash table
|
||||||
|
* |
||||||
|
* \param[in] htable Initialized hash table |
||||||
|
* \param[in] key key to associate with value |
||||||
|
* \param[in] val value to store (duplicates). |
||||||
|
* \return ARES_TRUE on success, ARES_FALSE on failure or out of memory |
||||||
|
*/ |
||||||
|
CARES_EXTERN ares_bool_t ares_htable_vpstr_insert(ares_htable_vpstr_t *htable, |
||||||
|
void *key, const char *val); |
||||||
|
|
||||||
|
/*! Retrieve value from hashtable based on key
|
||||||
|
* |
||||||
|
* \param[in] htable Initialized hash table |
||||||
|
* \param[in] key key to use to search |
||||||
|
* \param[out] val Optional. Pointer to store value. |
||||||
|
* \return ARES_TRUE on success, ARES_FALSE on failure |
||||||
|
*/ |
||||||
|
CARES_EXTERN ares_bool_t ares_htable_vpstr_get( |
||||||
|
const ares_htable_vpstr_t *htable, const void *key, const char **val); |
||||||
|
|
||||||
|
/*! Retrieve value from hashtable directly as return value. Caveat to this
|
||||||
|
* function over ares_htable_vpstr_get() is that if a NULL value is stored |
||||||
|
* you cannot determine if the key is not found or the value is NULL. |
||||||
|
* |
||||||
|
* \param[in] htable Initialized hash table |
||||||
|
* \param[in] key key to use to search |
||||||
|
* \return value associated with key in hashtable or NULL |
||||||
|
*/ |
||||||
|
CARES_EXTERN const char * |
||||||
|
ares_htable_vpstr_get_direct(const ares_htable_vpstr_t *htable, |
||||||
|
const void *key); |
||||||
|
|
||||||
|
/*! Remove a value from the hashtable by key
|
||||||
|
* |
||||||
|
* \param[in] htable Initialized hash table |
||||||
|
* \param[in] key key to use to search |
||||||
|
* \return ARES_TRUE if found, ARES_FALSE if not |
||||||
|
*/ |
||||||
|
CARES_EXTERN ares_bool_t ares_htable_vpstr_remove(ares_htable_vpstr_t *htable, |
||||||
|
const void *key); |
||||||
|
|
||||||
|
/*! Retrieve the number of keys stored in the hash table
|
||||||
|
* |
||||||
|
* \param[in] htable Initialized hash table |
||||||
|
* \return count |
||||||
|
*/ |
||||||
|
CARES_EXTERN size_t |
||||||
|
ares_htable_vpstr_num_keys(const ares_htable_vpstr_t *htable); |
||||||
|
|
||||||
|
/*! @} */ |
||||||
|
|
||||||
|
#endif /* __ARES__HTABLE_VPSTR_H */ |
||||||
Loading…
Reference in new issue