Skip to content

Commit

Permalink
rename socket to conn for error codes
Browse files Browse the repository at this point in the history
  • Loading branch information
@bradh352
bradh352 committed Aug 13, 2024
1 parent 75efd6b commit 02cc75f
Show file tree
Hide file tree
Showing 7 changed files with 246 additions and 241 deletions.
174 changes: 84 additions & 90 deletions src/lib/ares__socket.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -175,43 +175,43 @@ struct iovec {
};
#endif

static ares_socket_err_t ares__socket_deref_error(int err)
static ares_conn_err_t ares__socket_deref_error(int err)
{
switch (err) {
#if defined(EWOULDBLOCK)
case EWOULDBLOCK:
return ARES_SOCKET_ERR_WOULDBLOCK;
return ARES_CONN_ERR_WOULDBLOCK;
#endif
#if defined(EAGAIN) && (!defined(EWOULDBLOCK) || EAGAIN != EWOULDBLOCK)
case EAGAIN:
return ARES_SOCKET_ERR_WOULDBLOCK;
return ARES_CONN_ERR_WOULDBLOCK;
#endif
case EINPROGRESS:
return ARES_SOCKET_ERR_WOULDBLOCK;
return ARES_CONN_ERR_WOULDBLOCK;
case ENETDOWN:
return ARES_SOCKET_ERR_NETDOWN;
return ARES_CONN_ERR_NETDOWN;
case ENETUNREACH:
return ARES_SOCKET_ERR_NETUNREACH;
return ARES_CONN_ERR_NETUNREACH;
case ECONNABORTED:
return ARES_SOCKET_ERR_CONNABORTED;
return ARES_CONN_ERR_CONNABORTED;
case ECONNRESET:
return ARES_SOCKET_ERR_CONNRESET;
return ARES_CONN_ERR_CONNRESET;
case ECONNREFUSED:
return ARES_SOCKET_ERR_CONNREFUSED;
return ARES_CONN_ERR_CONNREFUSED;
case ETIMEDOUT:
return ARES_SOCKET_ERR_CONNTIMEDOUT;
return ARES_CONN_ERR_CONNTIMEDOUT;
case EHOSTDOWN:
return ARES_SOCKET_ERR_HOSTDOWN;
return ARES_CONN_ERR_HOSTDOWN;
case EHOSTUNREACH:
return ARES_SOCKET_ERR_HOSTUNREACH;
return ARES_CONN_ERR_HOSTUNREACH;
case EINTR:
return ARES_SOCKET_ERR_INTERRUPT;
return ARES_CONN_ERR_INTERRUPT;
case EAFNOSUPPORT:
return ARES_SOCKET_ERR_AFNOSUPPORT;
return ARES_CONN_ERR_AFNOSUPPORT;
default:
break;
}
return ARES_SOCKET_ERR_FAILURE;
return ARES_CONN_ERR_FAILURE;
}

static ares_bool_t same_address(const struct sockaddr *sa,
Expand Down Expand Up @@ -244,26 +244,25 @@ static ares_bool_t same_address(const struct sockaddr *sa,
return ARES_FALSE; /* different */
}

void ares__conn_sock_state_cb_update(ares_conn_t *conn,
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);
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_socket_err_t ares__socket_recv(ares_channel_t *channel, ares_socket_t s,
ares_bool_t is_tcp,
void *data, size_t data_len,
size_t *read_bytes)
ares_conn_err_t ares__socket_recv(ares_channel_t *channel, ares_socket_t s,
ares_bool_t is_tcp, void *data,
size_t data_len, size_t *read_bytes)
{
ares_ssize_t rv;

Expand All @@ -279,35 +278,33 @@ ares_socket_err_t ares__socket_recv(ares_channel_t *channel, ares_socket_t s,

if (rv > 0) {
*read_bytes = (size_t)rv;
return ARES_SOCKET_ERR_SUCCESS;
return ARES_CONN_ERR_SUCCESS;
}

if (rv == 0) {
/* UDP allows 0-byte packets and is connectionless, so this is success */
if (!is_tcp) {
return ARES_SOCKET_ERR_SUCCESS;
return ARES_CONN_ERR_SUCCESS;
} else {
return ARES_SOCKET_ERR_CONNCLOSED;
return ARES_CONN_ERR_CONNCLOSED;
}
}

/* If we're here, rv<0 */
return ares__socket_deref_error(SOCKERRNO);
}


ares_socket_err_t ares__socket_recvfrom(ares_channel_t *channel,
ares_socket_t s,
ares_bool_t is_tcp,
void *data, size_t data_len, int flags,
struct sockaddr *from,
ares_socklen_t *from_len,
size_t *read_bytes)
ares_conn_err_t ares__socket_recvfrom(ares_channel_t *channel, ares_socket_t s,
ares_bool_t is_tcp, void *data,
size_t data_len, int flags,
struct sockaddr *from,
ares_socklen_t *from_len,
size_t *read_bytes)
{
ares_ssize_t rv;
if (channel->sock_funcs && channel->sock_funcs->arecvfrom) {
rv = channel->sock_funcs->arecvfrom(s, data, data_len, flags, from,
from_len, channel->sock_func_cb_data);
from_len, channel->sock_func_cb_data);
} else {
#ifdef HAVE_RECVFROM
rv = (ares_ssize_t)recvfrom(s, data, (RECVFROM_TYPE_ARG3)data_len, flags,
Expand All @@ -319,58 +316,57 @@ ares_socket_err_t ares__socket_recvfrom(ares_channel_t *channel,

if (rv > 0) {
*read_bytes = (size_t)rv;
return ARES_SOCKET_ERR_SUCCESS;
return ARES_CONN_ERR_SUCCESS;
}

if (rv == 0) {
/* UDP allows 0-byte packets and is connectionless, so this is success */
if (!is_tcp) {
return ARES_SOCKET_ERR_SUCCESS;
return ARES_CONN_ERR_SUCCESS;
} else {
return ARES_SOCKET_ERR_CONNCLOSED;
return ARES_CONN_ERR_CONNCLOSED;
}
}

/* If we're here, rv<0 */
return ares__socket_deref_error(SOCKERRNO);
}

ares_socket_err_t ares__conn_read(ares_conn_t *conn, void *data, size_t len,
size_t *read_bytes)
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_socket_err_t err;
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);
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_SOCKET_ERR_SUCCESS &&
if (err == ARES_CONN_ERR_SUCCESS &&
!same_address((struct sockaddr *)&sa_storage, &conn->server->addr)) {
err = ARES_SOCKET_ERR_WOULDBLOCK;
err = ARES_CONN_ERR_WOULDBLOCK;
}
#endif
} else {
err = ares__socket_recv(channel, conn->fd, ARES_TRUE, data, len,
read_bytes);
err =
ares__socket_recv(channel, conn->fd, ARES_TRUE, data, len, read_bytes);
}

/* Toggle connected state if needed */
if (err == ARES_SOCKET_ERR_SUCCESS) {
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);
Expand Down Expand Up @@ -455,23 +451,22 @@ static ares_status_t ares_conn_set_self_ip(ares_conn_t *conn, ares_bool_t early)
return ARES_SUCCESS;
}

ares_socket_err_t ares__conn_write(ares_conn_t *conn, const void *data,
size_t len, size_t *written)
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;
int flags = 0;
ares_ssize_t rv;
ares_bool_t is_tfo = ARES_FALSE;
ares_socket_err_t err = ARES_SOCKET_ERR_SUCCESS;
ares_channel_t *channel = conn->server->channel;
int flags = 0;
ares_ssize_t rv;
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 &&
if (conn->flags & ARES_CONN_FLAG_TCP &&
!(conn->state_flags & ARES_CONN_STATE_CONNECTED) &&
!(conn->flags & ARES_CONN_FLAG_TFO_INITIAL)
) {
return ARES_SOCKET_ERR_WOULDBLOCK;
!(conn->flags & ARES_CONN_FLAG_TFO_INITIAL)) {
return ARES_CONN_ERR_WOULDBLOCK;
}

#ifdef HAVE_MSG_NOSIGNAL
Expand All @@ -482,8 +477,8 @@ ares_socket_err_t ares__conn_write(ares_conn_t *conn, const void *data,
struct iovec vec;
vec.iov_base = (void *)((size_t)data); /* Cast off const */
vec.iov_len = len;
rv = channel->sock_funcs->asendv(conn->fd, &vec, 1,
channel->sock_func_cb_data);
rv = channel->sock_funcs->asendv(conn->fd, &vec, 1,
channel->sock_func_cb_data);
if (rv <= 0) {
err = ares__socket_deref_error(SOCKERRNO);
} else {
Expand All @@ -503,7 +498,7 @@ ares_socket_err_t ares__conn_write(ares_conn_t *conn, const void *data,
struct sockaddr *sa = (struct sockaddr *)&sa_storage;

if (ares__conn_set_sockaddr(conn, sa, &salen) != ARES_SUCCESS) {
return ARES_SOCKET_ERR_FAILURE;
return ARES_CONN_ERR_FAILURE;
}

rv = (ares_ssize_t)sendto((SEND_TYPE_ARG1)conn->fd, (SEND_TYPE_ARG2)data,
Expand Down Expand Up @@ -535,16 +530,17 @@ ares_socket_err_t ares__conn_write(ares_conn_t *conn, const void *data,

done:
if (conn->flags & ARES_CONN_FLAG_TCP) {
if (err == ARES_SOCKET_ERR_SUCCESS && len == *written) {
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_SOCKET_ERR_WOULDBLOCK) {
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);
ares__conn_sock_state_cb_update(conn, ARES_CONN_STATE_READ |
ARES_CONN_STATE_WRITE);
}
}

Expand Down Expand Up @@ -786,8 +782,8 @@ static ares_status_t ares__conn_connect(ares_conn_t *conn, struct sockaddr *sa,
return ARES_SUCCESS;
#elif defined(TFO_USE_CONNECTX) && TFO_USE_CONNECTX
{
int rv;
ares_socket_err_t err;
int rv;
ares_conn_err_t err;

do {
sa_endpoints_t endpoints;
Expand All @@ -796,21 +792,20 @@ static ares_status_t ares__conn_connect(ares_conn_t *conn, struct sockaddr *sa,
endpoints.sae_dstaddr = sa;
endpoints.sae_dstaddrlen = salen;

rv = connectx(conn->fd, &endpoints, SAE_ASSOCID_ANY,
CONNECT_DATA_IDEMPOTENT | CONNECT_RESUME_ON_READ_WRITE,
NULL, 0, NULL, NULL);
rv = connectx(conn->fd, &endpoints, SAE_ASSOCID_ANY,
CONNECT_DATA_IDEMPOTENT | CONNECT_RESUME_ON_READ_WRITE,
NULL, 0, NULL, NULL);

if (rv < 0) {
err = ares__socket_deref_error(SOCKERRNO);
} else {
break;
}

if (err != ARES_SOCKET_ERR_WOULDBLOCK &&
err != ARES_SOCKET_ERR_INTERRUPT) {
if (err != ARES_CONN_ERR_WOULDBLOCK && err != ARES_CONN_ERR_INTERRUPT) {
return ARES_ECONNREFUSED;
}
} while (err == ARES_SOCKET_ERR_INTERRUPT);
} while (err == ARES_CONN_ERR_INTERRUPT);
}
return ARES_SUCCESS;
#elif defined(TFO_SUPPORTED) && TFO_SUPPORTED
Expand Down Expand Up @@ -869,7 +864,7 @@ ares_status_t ares__open_connection(ares_conn_t **conn_out,

/* Acquire a socket. */
if (ares__open_socket(&conn->fd, channel, server->addr.family, stype, 0) !=
ARES_SOCKET_ERR_SUCCESS) {
ARES_CONN_ERR_SUCCESS) {
status = ARES_ECONNREFUSED;
goto done;
}
Expand Down Expand Up @@ -939,8 +934,9 @@ ares_status_t ares__open_connection(ares_conn_t **conn_out,
/* LCOV_EXCL_STOP */
}

ares__conn_sock_state_cb_update(conn, ARES_CONN_STATE_READ |
(is_tcp?ARES_CONN_STATE_WRITE:ARES_CONN_STATE_NONE));
ares__conn_sock_state_cb_update(
conn, ARES_CONN_STATE_READ |
(is_tcp ? ARES_CONN_STATE_WRITE : ARES_CONN_STATE_NONE));

if (is_tcp) {
server->tcp_conn = conn;
Expand All @@ -958,9 +954,8 @@ ares_status_t ares__open_connection(ares_conn_t **conn_out,
return status;
}

ares_socket_err_t ares__open_socket(ares_socket_t *sock,
ares_channel_t *channel, int af, int type,
int protocol)
ares_conn_err_t ares__open_socket(ares_socket_t *sock, ares_channel_t *channel,
int af, int type, int protocol)
{
ares_socket_t s;

Expand All @@ -979,16 +974,16 @@ ares_socket_err_t ares__open_socket(ares_socket_t *sock,

*sock = s;

return ARES_SOCKET_ERR_SUCCESS;
return ARES_CONN_ERR_SUCCESS;
}

ares_status_t ares__connect_socket(ares_channel_t *channel,
ares_socket_t sockfd,
const struct sockaddr *addr,
ares_socklen_t addrlen)
{
int rv;
ares_socket_err_t err;
int rv;
ares_conn_err_t err;

do {
if (channel->sock_funcs && channel->sock_funcs->aconnect) {
Expand All @@ -1004,11 +999,10 @@ ares_status_t ares__connect_socket(ares_channel_t *channel,
break;
}

if (err != ARES_SOCKET_ERR_WOULDBLOCK &&
err != ARES_SOCKET_ERR_INTERRUPT) {
if (err != ARES_CONN_ERR_WOULDBLOCK && err != ARES_CONN_ERR_INTERRUPT) {
return ARES_ECONNREFUSED;
}
} while (err == ARES_SOCKET_ERR_INTERRUPT);
} while (err == ARES_CONN_ERR_INTERRUPT);

return ARES_SUCCESS;
}
Expand Down
Loading

0 comments on commit 02cc75f

Please sign in to comment.