romenskiy2012/curl
1
0
Fork 0
mirror of https://github.com/curl/curl.git synced 2026-06-17 04:15:37 +03:00
Code Issues Projects Releases Packages Wiki Activity

socket: use name sockerr for socket error variables

Browse source 
Also:
- add comment explaining a `sockerr = errno` (vs. `SOCKERRNO`)
  assigment.

Closes #21998
This commit is contained in:
Viktor Szakats 2026-06-12 23:42:50 +02:00
parent fb83911aa6
commit fe2df80a5a
No known key found for this signature in database
15 changed files with 205 additions and 202 deletions
Download patch file Download diff file Expand all files Collapse all files

14
lib/asyn-thrdd.c
View file

@ -111,7 +111,7 @@ struct async_thrdd_item {
#ifdef CURLVERBOSE
char description[CURL_ASYN_ITEM_DESC_LEN];
#endif
int sock_error;
int sockerr;
uint32_t mid;
uint32_t resolv_id;
uint16_t port;
@ -372,9 +372,9 @@ static void async_thrdd_item_process(void *arg)
rc = Curl_getaddrinfo_ex(item->hostname, service, &hints, &item->res);
if(rc) {
item->sock_error = SOCKERRNO ? SOCKERRNO : rc;
if(item->sock_error == 0)
item->sock_error = RESOLVER_ENOMEM;
item->sockerr = SOCKERRNO ? SOCKERRNO : rc;
if(item->sockerr == 0)
item->sockerr = RESOLVER_ENOMEM;
}
else {
Curl_addrinfo_set_port(item->res, item->port);
@ -399,9 +399,9 @@ static void async_thrdd_item_process(void *arg)
#endif
item->res = Curl_ipv4_resolve_r(item->hostname, item->port);
if(!item->res) {
item->sock_error = SOCKERRNO;
if(item->sock_error == 0)
item->sock_error = RESOLVER_ENOMEM;
item->sockerr = SOCKERRNO;
if(item->sockerr == 0)
item->sockerr = RESOLVER_ENOMEM;
}
}

87
lib/cf-socket.c
View file

@ -652,7 +652,7 @@ static CURLcode bindlocal(struct Curl_easy *data, struct connectdata *conn,
const char *host_input = data->set.str[STRING_BINDHOST];
const char *iface = iface_input ? iface_input : dev;
const char *host = host_input ? host_input : dev;
int error;
int sockerr;
#ifdef IP_BIND_ADDRESS_NO_PORT
int on = 1;
#endif
@ -715,9 +715,9 @@ static CURLcode bindlocal(struct Curl_easy *data, struct connectdata *conn,
if(iface_input && !host_input) {
/* Do not fall back to treating it as a hostname */
char buffer[STRERROR_LEN];
data->state.os_errno = error = SOCKERRNO;
data->state.os_errno = sockerr = SOCKERRNO;
failf(data, "Could not bind to interface '%s' with errno %d: %s",
iface, error, curlx_strerror(error, buffer, sizeof(buffer)));
iface, sockerr, curlx_strerror(sockerr, buffer, sizeof(buffer)));
return CURLE_INTERFACE_FAILED;
}
break;
@ -819,9 +819,9 @@ static CURLcode bindlocal(struct Curl_easy *data, struct connectdata *conn,
generic resolve error. */
char buffer[STRERROR_LEN];
data->state.errorbuf = FALSE;
data->state.os_errno = error = SOCKERRNO;
data->state.os_errno = sockerr = SOCKERRNO;
failf(data, "Could not bind to '%s' with errno %d: %s", host,
error, curlx_strerror(error, buffer, sizeof(buffer)));
sockerr, curlx_strerror(sockerr, buffer, sizeof(buffer)));
return CURLE_INTERFACE_FAILED;
}
}
@ -870,9 +870,9 @@ static CURLcode bindlocal(struct Curl_easy *data, struct connectdata *conn,
}
{
char buffer[STRERROR_LEN];
data->state.os_errno = error = SOCKERRNO;
data->state.os_errno = sockerr = SOCKERRNO;
failf(data, "bind failed with errno %d: %s",
error, curlx_strerror(error, buffer, sizeof(buffer)));
sockerr, curlx_strerror(sockerr, buffer, sizeof(buffer)));
}
return CURLE_INTERFACE_FAILED;
@ -882,12 +882,12 @@ static CURLcode bindlocal(struct Curl_easy *data, struct connectdata *conn,
/*
* verifyconnect() returns TRUE if the connect really has happened.
*/
static bool verifyconnect(curl_socket_t sockfd, int *error)
static bool verifyconnect(curl_socket_t sockfd, int *psockerr)
{
bool rc = TRUE;
#ifdef SO_ERROR
int err = 0;
curl_socklen_t errSize = sizeof(err);
int sockerr = 0;
curl_socklen_t errSize = sizeof(sockerr);
#ifdef _WIN32
/*
@ -908,27 +908,27 @@ static bool verifyconnect(curl_socket_t sockfd, int *error)
SleepEx(0, FALSE);
#endif
if(getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void *)&err, &errSize))
err = SOCKERRNO;
if(getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void *)&sockerr, &errSize))
sockerr = SOCKERRNO;
#if defined(EBADIOCTL) && defined(__minix)
/* Minix 3.1.x does not support getsockopt on UDP sockets */
if(EBADIOCTL == err) {
if(EBADIOCTL == sockerr) {
SET_SOCKERRNO(0);
err = 0;
sockerr = 0;
}
#endif
if((err == 0) || (SOCKEISCONN == err))
if((sockerr == 0) || (SOCKEISCONN == sockerr))
/* we are connected, awesome! */
rc = TRUE;
else
/* This was not a successful connect */
rc = FALSE;
if(error)
*error = err;
if(psockerr)
*psockerr = sockerr;
#else
(void)sockfd;
if(error)
*error = SOCKERRNO;
if(psockerr)
*psockerr = SOCKERRNO;
#endif
return rc;
}
@ -937,19 +937,19 @@ static bool verifyconnect(curl_socket_t sockfd, int *error)
* Determine the curl code for a socket connect() == -1 with errno.
*/
static CURLcode socket_connect_result(struct Curl_easy *data,
const char *ipaddress, int error)
const char *ipaddress, int sockerr)
{
if(error == SOCKEINPROGRESS || SOCK_EAGAIN(error))
if(sockerr == SOCKEINPROGRESS || SOCK_EAGAIN(sockerr))
return CURLE_OK;
/* unknown error, fallthrough and try another address! */
{
VERBOSE(char buffer[STRERROR_LEN]);
infof(data, "Immediate connect fail for %s: %s", ipaddress,
curlx_strerror(error, buffer, sizeof(buffer)));
curlx_strerror(sockerr, buffer, sizeof(buffer)));
NOVERBOSE((void)ipaddress);
}
data->state.os_errno = error;
data->state.os_errno = sockerr;
/* connect failed */
return CURLE_COULDNT_CONNECT;
}
@ -966,7 +966,7 @@ struct cf_socket_ctx {
struct curltime last_sndbuf_query_at; /* when SO_SNDBUF last queried */
ULONG sndbuf_size; /* the last set SO_SNDBUF size */
#endif
int error; /* errno of last failure or 0 */
int sockerr; /* socket error of last failure or 0 */
#ifdef DEBUGBUILD
int wblock_percent; /* percent of writes doing EAGAIN */
int wpartial_percent; /* percent of bytes written in send */
@ -1087,9 +1087,9 @@ static void set_local_ip(struct Curl_cfilter *cf,
memset(&ssloc, 0, sizeof(ssloc));
if(getsockname(ctx->sock, (struct sockaddr *)&ssloc, &slen)) {
VERBOSE(int error = SOCKERRNO);
VERBOSE(int sockerr = SOCKERRNO);
infof(data, "getsockname() failed with errno %d: %s",
error, curlx_strerror(error, buffer, sizeof(buffer)));
sockerr, curlx_strerror(sockerr, buffer, sizeof(buffer)));
}
else if(!sockaddr2string((struct sockaddr *)&ssloc, slen,
ctx->ip.local_ip, &ctx->ip.local_port)) {
@ -1114,7 +1114,10 @@ static CURLcode set_remote_ip(struct Curl_cfilter *cf,
ctx->ip.remote_ip, &ctx->ip.remote_port)) {
char buffer[STRERROR_LEN];
ctx->error = errno;
/* using bare errno instead of SOCKERRNO is safe here, because
sockaddr2string() calls curlx_inet_ntop(), and they both report failures
via errno (even on Windows builds). */
ctx->sockerr = errno;
/* malformed address or bug in inet_ntop, try next address */
failf(data, "curl_sa_addr inet_ntop() failed with errno %d: %s",
errno, curlx_strerror(errno, buffer, sizeof(buffer)));
@ -1258,7 +1261,7 @@ static CURLcode cf_socket_open(struct Curl_cfilter *cf,
error = curlx_nonblock(ctx->sock, TRUE);
if(error < 0) {
result = CURLE_UNSUPPORTED_PROTOCOL;
ctx->error = SOCKERRNO;
ctx->sockerr = SOCKERRNO;
goto out;
}
#else
@ -1268,7 +1271,7 @@ static CURLcode cf_socket_open(struct Curl_cfilter *cf,
error = curlx_nonblock(ctx->sock, TRUE);
if(error < 0) {
result = CURLE_UNSUPPORTED_PROTOCOL;
ctx->error = SOCKERRNO;
ctx->sockerr = SOCKERRNO;
goto out;
}
}
@ -1361,7 +1364,7 @@ static CURLcode cf_tcp_connect(struct Curl_cfilter *cf,
*done = FALSE; /* a negative world view is best */
if(ctx->sock == CURL_SOCKET_BAD) {
int error;
int sockerr;
result = cf_socket_open(cf, data);
if(result)
@ -1374,13 +1377,13 @@ static CURLcode cf_tcp_connect(struct Curl_cfilter *cf,
/* Connect TCP socket */
rc = do_connect(cf, data, (bool)cf->conn->bits.tcp_fastopen);
error = SOCKERRNO;
sockerr = SOCKERRNO;
set_local_ip(cf, data);
CURL_TRC_CF(data, cf, "local address %s port %d...",
ctx->ip.local_ip, ctx->ip.local_port);
if(rc == -1) {
ctx->error = error;
result = socket_connect_result(data, ctx->ip.remote_ip, error);
ctx->sockerr = sockerr;
result = socket_connect_result(data, ctx->ip.remote_ip, sockerr);
goto out;
}
}
@ -1400,7 +1403,7 @@ static CURLcode cf_tcp_connect(struct Curl_cfilter *cf,
return CURLE_OK;
}
else if(rc == CURL_CSELECT_OUT || cf->conn->bits.tcp_fastopen) {
if(verifyconnect(ctx->sock, &ctx->error)) {
if(verifyconnect(ctx->sock, &ctx->sockerr)) {
/* we are connected with TCP, awesome! */
ctx->connected_at = *Curl_pgrs_now(data);
set_local_ip(cf, data);
@ -1412,7 +1415,7 @@ static CURLcode cf_tcp_connect(struct Curl_cfilter *cf,
}
else if(rc & CURL_CSELECT_ERR) {
CURL_TRC_CF(data, cf, "poll/select error on fd=%" FMT_SOCKET_T, ctx->sock);
(void)verifyconnect(ctx->sock, &ctx->error);
(void)verifyconnect(ctx->sock, &ctx->sockerr);
result = CURLE_COULDNT_CONNECT;
}
@ -1420,10 +1423,10 @@ out:
if(result) {
VERBOSE(char buffer[STRERROR_LEN]);
set_local_ip(cf, data);
if(ctx->error) {
data->state.os_errno = ctx->error;
SET_SOCKERRNO(ctx->error);
VERBOSE(curlx_strerror(ctx->error, buffer, sizeof(buffer)));
if(ctx->sockerr) {
data->state.os_errno = ctx->sockerr;
SET_SOCKERRNO(ctx->sockerr);
VERBOSE(curlx_strerror(ctx->sockerr, buffer, sizeof(buffer)));
}
else {
VERBOSE(curlx_strcopy(buffer, sizeof(buffer), STRCONST("peer closed")));
@ -1435,7 +1438,7 @@ out:
infof(data, "connect to %s port %u from %s port %d failed: %s",
ctx->ip.remote_ip, ctx->ip.remote_port,
ctx->ip.local_ip, ctx->ip.local_port,
curlx_strerror(ctx->error, buffer, sizeof(buffer)));
curlx_strerror(ctx->sockerr, buffer, sizeof(buffer)));
*done = FALSE;
}
return result;
@ -2108,9 +2111,9 @@ static void cf_tcp_set_accepted_remote_ip(struct Curl_cfilter *cf,
plen = sizeof(ssrem);
memset(&ssrem, 0, plen);
if(getpeername(ctx->sock, (struct sockaddr *)&ssrem, &plen)) {
int error = SOCKERRNO;
int sockerr = SOCKERRNO;
failf(data, "getpeername() failed with errno %d: %s",
error, curlx_strerror(error, buffer, sizeof(buffer)));
sockerr, curlx_strerror(sockerr, buffer, sizeof(buffer)));
return;
}
if(!sockaddr2string((struct sockaddr *)&ssrem, plen,

18
lib/ftp.c
View file

@ -1083,7 +1083,7 @@ static CURLcode ftp_port_open_socket(struct Curl_easy *data,
curl_socket_t *portsockp)
{
char buffer[STRERROR_LEN];
int error = 0;
int sockerr = 0;
const struct Curl_addrinfo *ai;
CURLcode result = CURLE_FTP_PORT_FAILED;
@ -1095,14 +1095,14 @@ static CURLcode ftp_port_open_socket(struct Curl_easy *data,
if(result == CURLE_OUT_OF_MEMORY)
return result;
result = CURLE_FTP_PORT_FAILED;
error = SOCKERRNO;
sockerr = SOCKERRNO;
continue;
}
break;
}
if(!ai) {
failf(data, "socket failure: %s",
curlx_strerror(error, buffer, sizeof(buffer)));
curlx_strerror(sockerr, buffer, sizeof(buffer)));
return CURLE_FTP_PORT_FAILED;
}
*aip = ai;
@ -1131,7 +1131,7 @@ static CURLcode ftp_port_bind_socket(struct Curl_easy *data,
#endif
char buffer[STRERROR_LEN];
unsigned short port;
int error;
int sockerr;
memcpy(sa, ai->ai_addr, ai->ai_addrlen);
*sslen_io = ai->ai_addrlen;
@ -1144,13 +1144,13 @@ static CURLcode ftp_port_bind_socket(struct Curl_easy *data,
sa6->sin6_port = htons(port);
#endif
if(bind(portsock, sa, *sslen_io)) {
error = SOCKERRNO;
if(non_local && (error == SOCKEADDRNOTAVAIL)) {
sockerr = SOCKERRNO;
if(non_local && (sockerr == SOCKEADDRNOTAVAIL)) {
/* The requested bind address is not local. Use the address used for
* the control connection instead and restart the port loop.
*/
infof(data, "bind(port=%hu) on non-local address failed: %s", port,
curlx_strerror(error, buffer, sizeof(buffer)));
curlx_strerror(sockerr, buffer, sizeof(buffer)));
*sslen_io = sizeof(*ss);
if(getsockname(conn->sock[FIRSTSOCKET], sa, sslen_io)) {
@ -1162,9 +1162,9 @@ static CURLcode ftp_port_bind_socket(struct Curl_easy *data,
non_local = FALSE; /* do not try this again */
continue;
}
if(error != SOCKEADDRINUSE && error != SOCKEACCES) {
if(sockerr != SOCKEADDRINUSE && sockerr != SOCKEACCES) {
failf(data, "bind(port=%hu) failed: %s", port,
curlx_strerror(error, buffer, sizeof(buffer)));
curlx_strerror(sockerr, buffer, sizeof(buffer)));
return CURLE_FTP_PORT_FAILED;
}
}

14
lib/socketpair.c
View file

@ -302,7 +302,7 @@ int Curl_wakeup_init(curl_socket_t socks[2], bool nonblocking)
int Curl_wakeup_signal(curl_socket_t socks[2])
{
int err = 0;
int sockerr = 0;
#ifdef USE_EVENTFD
const uint64_t buf[1] = { 1 };
#else
@ -310,19 +310,19 @@ int Curl_wakeup_signal(curl_socket_t socks[2])
#endif
while(1) {
err = 0;
sockerr = 0;
if(wakeup_write(socks[1], buf, sizeof(buf)) < 0) {
err = SOCKERRNO;
sockerr = SOCKERRNO;
#ifndef USE_WINSOCK
if(err == SOCKEINTR)
if(sockerr == SOCKEINTR)
continue;
#endif
if(SOCK_EAGAIN(err))
err = 0; /* wakeup is already ongoing */
if(SOCK_EAGAIN(sockerr))
sockerr = 0; /* wakeup is already ongoing */
}
break;
}
return err;
return sockerr;
}
CURLcode Curl_wakeup_consume(curl_socket_t socks[2], bool all)

6
lib/telnet.c
View file

@ -1372,9 +1372,9 @@ static CURLcode telnet_do(struct Curl_easy *data, bool *done)
case WAIT_OBJECT_0: {
events.lNetworkEvents = 0;
if(WSAEnumNetworkEvents(sockfd, event_handle, &events) != 0) {
int err = SOCKERRNO;
if(err != SOCKEINPROGRESS) {
infof(data, "WSAEnumNetworkEvents failed (%d)", err);
int sockerr = SOCKERRNO;
if(sockerr != SOCKEINPROGRESS) {
infof(data, "WSAEnumNetworkEvents failed (%d)", sockerr);
keepon = FALSE;
result = CURLE_READ_ERROR;
}

4
lib/tftp.c
View file

@ -1197,9 +1197,9 @@ static CURLcode tftp_multi_statemach(struct Curl_easy *data, bool *done)
if(rc == -1) {
/* bail out */
int error = SOCKERRNO;
int sockerr = SOCKERRNO;
char buffer[STRERROR_LEN];
failf(data, "%s", curlx_strerror(error, buffer, sizeof(buffer)));
failf(data, "%s", curlx_strerror(sockerr, buffer, sizeof(buffer)));
state->event = TFTP_EVENT_ERROR;
}
else if(rc) {