romenskiy2012/curl
1
0
Fork 0
mirror of https://github.com/curl/curl.git synced 2026-08-10 16:30:51 +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 #ifdef CURLVERBOSE
char description[CURL_ASYN_ITEM_DESC_LEN]; char description[CURL_ASYN_ITEM_DESC_LEN];
#endif #endif
int sock_error; int sockerr;
uint32_t mid; uint32_t mid;
uint32_t resolv_id; uint32_t resolv_id;
uint16_t port; 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); rc = Curl_getaddrinfo_ex(item->hostname, service, &hints, &item->res);
if(rc) { if(rc) {
item->sock_error = SOCKERRNO ? SOCKERRNO : rc; item->sockerr = SOCKERRNO ? SOCKERRNO : rc;
if(item->sock_error == 0) if(item->sockerr == 0)
item->sock_error = RESOLVER_ENOMEM; item->sockerr = RESOLVER_ENOMEM;
} }
else { else {
Curl_addrinfo_set_port(item->res, item->port); Curl_addrinfo_set_port(item->res, item->port);
@ -399,9 +399,9 @@ static void async_thrdd_item_process(void *arg)
#endif #endif
item->res = Curl_ipv4_resolve_r(item->hostname, item->port); item->res = Curl_ipv4_resolve_r(item->hostname, item->port);
if(!item->res) { if(!item->res) {
item->sock_error = SOCKERRNO; item->sockerr = SOCKERRNO;
if(item->sock_error == 0) if(item->sockerr == 0)
item->sock_error = RESOLVER_ENOMEM; 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 *host_input = data->set.str[STRING_BINDHOST];
const char *iface = iface_input ? iface_input : dev; const char *iface = iface_input ? iface_input : dev;
const char *host = host_input ? host_input : dev; const char *host = host_input ? host_input : dev;
int error; int sockerr;
#ifdef IP_BIND_ADDRESS_NO_PORT #ifdef IP_BIND_ADDRESS_NO_PORT
int on = 1; int on = 1;
#endif #endif
@ -715,9 +715,9 @@ static CURLcode bindlocal(struct Curl_easy *data, struct connectdata *conn,
if(iface_input && !host_input) { if(iface_input && !host_input) {
/* Do not fall back to treating it as a hostname */ /* Do not fall back to treating it as a hostname */
char buffer[STRERROR_LEN]; 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", 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; return CURLE_INTERFACE_FAILED;
} }
break; break;
@ -819,9 +819,9 @@ static CURLcode bindlocal(struct Curl_easy *data, struct connectdata *conn,
generic resolve error. */ generic resolve error. */
char buffer[STRERROR_LEN]; char buffer[STRERROR_LEN];
data->state.errorbuf = FALSE; 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, 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; return CURLE_INTERFACE_FAILED;
} }
} }
@ -870,9 +870,9 @@ static CURLcode bindlocal(struct Curl_easy *data, struct connectdata *conn,
} }
{ {
char buffer[STRERROR_LEN]; char buffer[STRERROR_LEN];
data->state.os_errno = error = SOCKERRNO; data->state.os_errno = sockerr = SOCKERRNO;
failf(data, "bind failed with errno %d: %s", 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; 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. * 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; bool rc = TRUE;
#ifdef SO_ERROR #ifdef SO_ERROR
int err = 0; int sockerr = 0;
curl_socklen_t errSize = sizeof(err); curl_socklen_t errSize = sizeof(sockerr);
#ifdef _WIN32 #ifdef _WIN32
/* /*
@ -908,27 +908,27 @@ static bool verifyconnect(curl_socket_t sockfd, int *error)
SleepEx(0, FALSE); SleepEx(0, FALSE);
#endif #endif
if(getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void *)&err, &errSize)) if(getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (void *)&sockerr, &errSize))
err = SOCKERRNO; sockerr = SOCKERRNO;
#if defined(EBADIOCTL) && defined(__minix) #if defined(EBADIOCTL) && defined(__minix)
/* Minix 3.1.x does not support getsockopt on UDP sockets */ /* Minix 3.1.x does not support getsockopt on UDP sockets */
if(EBADIOCTL == err) { if(EBADIOCTL == sockerr) {
SET_SOCKERRNO(0); SET_SOCKERRNO(0);
err = 0; sockerr = 0;
} }
#endif #endif
if((err == 0) || (SOCKEISCONN == err)) if((sockerr == 0) || (SOCKEISCONN == sockerr))
/* we are connected, awesome! */ /* we are connected, awesome! */
rc = TRUE; rc = TRUE;
else else
/* This was not a successful connect */ /* This was not a successful connect */
rc = FALSE; rc = FALSE;
if(error) if(psockerr)
*error = err; *psockerr = sockerr;
#else #else
(void)sockfd; (void)sockfd;
if(error) if(psockerr)
*error = SOCKERRNO; *psockerr = SOCKERRNO;
#endif #endif
return rc; 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. * Determine the curl code for a socket connect() == -1 with errno.
*/ */
static CURLcode socket_connect_result(struct Curl_easy *data, 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; return CURLE_OK;
/* unknown error, fallthrough and try another address! */ /* unknown error, fallthrough and try another address! */
{ {
VERBOSE(char buffer[STRERROR_LEN]); VERBOSE(char buffer[STRERROR_LEN]);
infof(data, "Immediate connect fail for %s: %s", ipaddress, infof(data, "Immediate connect fail for %s: %s", ipaddress,
curlx_strerror(error, buffer, sizeof(buffer))); curlx_strerror(sockerr, buffer, sizeof(buffer)));
NOVERBOSE((void)ipaddress); NOVERBOSE((void)ipaddress);
} }
data->state.os_errno = error; data->state.os_errno = sockerr;
/* connect failed */ /* connect failed */
return CURLE_COULDNT_CONNECT; return CURLE_COULDNT_CONNECT;
} }
@ -966,7 +966,7 @@ struct cf_socket_ctx {
struct curltime last_sndbuf_query_at; /* when SO_SNDBUF last queried */ struct curltime last_sndbuf_query_at; /* when SO_SNDBUF last queried */
ULONG sndbuf_size; /* the last set SO_SNDBUF size */ ULONG sndbuf_size; /* the last set SO_SNDBUF size */
#endif #endif
int error; /* errno of last failure or 0 */ int sockerr; /* socket error of last failure or 0 */
#ifdef DEBUGBUILD #ifdef DEBUGBUILD
int wblock_percent; /* percent of writes doing EAGAIN */ int wblock_percent; /* percent of writes doing EAGAIN */
int wpartial_percent; /* percent of bytes written in send */ 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)); memset(&ssloc, 0, sizeof(ssloc));
if(getsockname(ctx->sock, (struct sockaddr *)&ssloc, &slen)) { if(getsockname(ctx->sock, (struct sockaddr *)&ssloc, &slen)) {
VERBOSE(int error = SOCKERRNO); VERBOSE(int sockerr = SOCKERRNO);
infof(data, "getsockname() failed with errno %d: %s", 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, else if(!sockaddr2string((struct sockaddr *)&ssloc, slen,
ctx->ip.local_ip, &ctx->ip.local_port)) { 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)) { ctx->ip.remote_ip, &ctx->ip.remote_port)) {
char buffer[STRERROR_LEN]; 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 */ /* malformed address or bug in inet_ntop, try next address */
failf(data, "curl_sa_addr inet_ntop() failed with errno %d: %s", failf(data, "curl_sa_addr inet_ntop() failed with errno %d: %s",
errno, curlx_strerror(errno, buffer, sizeof(buffer))); 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); error = curlx_nonblock(ctx->sock, TRUE);
if(error < 0) { if(error < 0) {
result = CURLE_UNSUPPORTED_PROTOCOL; result = CURLE_UNSUPPORTED_PROTOCOL;
ctx->error = SOCKERRNO; ctx->sockerr = SOCKERRNO;
goto out; goto out;
} }
#else #else
@ -1268,7 +1271,7 @@ static CURLcode cf_socket_open(struct Curl_cfilter *cf,
error = curlx_nonblock(ctx->sock, TRUE); error = curlx_nonblock(ctx->sock, TRUE);
if(error < 0) { if(error < 0) {
result = CURLE_UNSUPPORTED_PROTOCOL; result = CURLE_UNSUPPORTED_PROTOCOL;
ctx->error = SOCKERRNO; ctx->sockerr = SOCKERRNO;
goto out; goto out;
} }
} }
@ -1361,7 +1364,7 @@ static CURLcode cf_tcp_connect(struct Curl_cfilter *cf,
*done = FALSE; /* a negative world view is best */ *done = FALSE; /* a negative world view is best */
if(ctx->sock == CURL_SOCKET_BAD) { if(ctx->sock == CURL_SOCKET_BAD) {
int error; int sockerr;
result = cf_socket_open(cf, data); result = cf_socket_open(cf, data);
if(result) if(result)
@ -1374,13 +1377,13 @@ static CURLcode cf_tcp_connect(struct Curl_cfilter *cf,
/* Connect TCP socket */ /* Connect TCP socket */
rc = do_connect(cf, data, (bool)cf->conn->bits.tcp_fastopen); rc = do_connect(cf, data, (bool)cf->conn->bits.tcp_fastopen);
error = SOCKERRNO; sockerr = SOCKERRNO;
set_local_ip(cf, data); set_local_ip(cf, data);
CURL_TRC_CF(data, cf, "local address %s port %d...", CURL_TRC_CF(data, cf, "local address %s port %d...",
ctx->ip.local_ip, ctx->ip.local_port); ctx->ip.local_ip, ctx->ip.local_port);
if(rc == -1) { if(rc == -1) {
ctx->error = error; ctx->sockerr = sockerr;
result = socket_connect_result(data, ctx->ip.remote_ip, error); result = socket_connect_result(data, ctx->ip.remote_ip, sockerr);
goto out; goto out;
} }
} }
@ -1400,7 +1403,7 @@ static CURLcode cf_tcp_connect(struct Curl_cfilter *cf,
return CURLE_OK; return CURLE_OK;
} }
else if(rc == CURL_CSELECT_OUT || cf->conn->bits.tcp_fastopen) { 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! */ /* we are connected with TCP, awesome! */
ctx->connected_at = *Curl_pgrs_now(data); ctx->connected_at = *Curl_pgrs_now(data);
set_local_ip(cf, 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) { else if(rc & CURL_CSELECT_ERR) {
CURL_TRC_CF(data, cf, "poll/select error on fd=%" FMT_SOCKET_T, ctx->sock); 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; result = CURLE_COULDNT_CONNECT;
} }
@ -1420,10 +1423,10 @@ out:
if(result) { if(result) {
VERBOSE(char buffer[STRERROR_LEN]); VERBOSE(char buffer[STRERROR_LEN]);
set_local_ip(cf, data); set_local_ip(cf, data);
if(ctx->error) { if(ctx->sockerr) {
data->state.os_errno = ctx->error; data->state.os_errno = ctx->sockerr;
SET_SOCKERRNO(ctx->error); SET_SOCKERRNO(ctx->sockerr);
VERBOSE(curlx_strerror(ctx->error, buffer, sizeof(buffer))); VERBOSE(curlx_strerror(ctx->sockerr, buffer, sizeof(buffer)));
} }
else { else {
VERBOSE(curlx_strcopy(buffer, sizeof(buffer), STRCONST("peer closed"))); 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", infof(data, "connect to %s port %u from %s port %d failed: %s",
ctx->ip.remote_ip, ctx->ip.remote_port, ctx->ip.remote_ip, ctx->ip.remote_port,
ctx->ip.local_ip, ctx->ip.local_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; *done = FALSE;
} }
return result; return result;
@ -2108,9 +2111,9 @@ static void cf_tcp_set_accepted_remote_ip(struct Curl_cfilter *cf,
plen = sizeof(ssrem); plen = sizeof(ssrem);
memset(&ssrem, 0, plen); memset(&ssrem, 0, plen);
if(getpeername(ctx->sock, (struct sockaddr *)&ssrem, &plen)) { if(getpeername(ctx->sock, (struct sockaddr *)&ssrem, &plen)) {
int error = SOCKERRNO; int sockerr = SOCKERRNO;
failf(data, "getpeername() failed with errno %d: %s", failf(data, "getpeername() failed with errno %d: %s",
error, curlx_strerror(error, buffer, sizeof(buffer))); sockerr, curlx_strerror(sockerr, buffer, sizeof(buffer)));
return; return;
} }
if(!sockaddr2string((struct sockaddr *)&ssrem, plen, 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) curl_socket_t *portsockp)
{ {
char buffer[STRERROR_LEN]; char buffer[STRERROR_LEN];
int error = 0; int sockerr = 0;
const struct Curl_addrinfo *ai; const struct Curl_addrinfo *ai;
CURLcode result = CURLE_FTP_PORT_FAILED; 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) if(result == CURLE_OUT_OF_MEMORY)
return result; return result;
result = CURLE_FTP_PORT_FAILED; result = CURLE_FTP_PORT_FAILED;
error = SOCKERRNO; sockerr = SOCKERRNO;
continue; continue;
} }
break; break;
} }
if(!ai) { if(!ai) {
failf(data, "socket failure: %s", failf(data, "socket failure: %s",
curlx_strerror(error, buffer, sizeof(buffer))); curlx_strerror(sockerr, buffer, sizeof(buffer)));
return CURLE_FTP_PORT_FAILED; return CURLE_FTP_PORT_FAILED;
} }
*aip = ai; *aip = ai;
@ -1131,7 +1131,7 @@ static CURLcode ftp_port_bind_socket(struct Curl_easy *data,
#endif #endif
char buffer[STRERROR_LEN]; char buffer[STRERROR_LEN];
unsigned short port; unsigned short port;
int error; int sockerr;
memcpy(sa, ai->ai_addr, ai->ai_addrlen); memcpy(sa, ai->ai_addr, ai->ai_addrlen);
*sslen_io = 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); sa6->sin6_port = htons(port);
#endif #endif
if(bind(portsock, sa, *sslen_io)) { if(bind(portsock, sa, *sslen_io)) {
error = SOCKERRNO; sockerr = SOCKERRNO;
if(non_local && (error == SOCKEADDRNOTAVAIL)) { if(non_local && (sockerr == SOCKEADDRNOTAVAIL)) {
/* The requested bind address is not local. Use the address used for /* The requested bind address is not local. Use the address used for
* the control connection instead and restart the port loop. * the control connection instead and restart the port loop.
*/ */
infof(data, "bind(port=%hu) on non-local address failed: %s", port, 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); *sslen_io = sizeof(*ss);
if(getsockname(conn->sock[FIRSTSOCKET], sa, sslen_io)) { 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 */ non_local = FALSE; /* do not try this again */
continue; continue;
} }
if(error != SOCKEADDRINUSE && error != SOCKEACCES) { if(sockerr != SOCKEADDRINUSE && sockerr != SOCKEACCES) {
failf(data, "bind(port=%hu) failed: %s", port, 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; 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 Curl_wakeup_signal(curl_socket_t socks[2])
{ {
int err = 0; int sockerr = 0;
#ifdef USE_EVENTFD #ifdef USE_EVENTFD
const uint64_t buf[1] = { 1 }; const uint64_t buf[1] = { 1 };
#else #else
@ -310,19 +310,19 @@ int Curl_wakeup_signal(curl_socket_t socks[2])
#endif #endif
while(1) { while(1) {
err = 0; sockerr = 0;
if(wakeup_write(socks[1], buf, sizeof(buf)) < 0) { if(wakeup_write(socks[1], buf, sizeof(buf)) < 0) {
err = SOCKERRNO; sockerr = SOCKERRNO;
#ifndef USE_WINSOCK #ifndef USE_WINSOCK
if(err == SOCKEINTR) if(sockerr == SOCKEINTR)
continue; continue;
#endif #endif
if(SOCK_EAGAIN(err)) if(SOCK_EAGAIN(sockerr))
err = 0; /* wakeup is already ongoing */ sockerr = 0; /* wakeup is already ongoing */
} }
break; break;
} }
return err; return sockerr;
} }
CURLcode Curl_wakeup_consume(curl_socket_t socks[2], bool all) 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: { case WAIT_OBJECT_0: {
events.lNetworkEvents = 0; events.lNetworkEvents = 0;
if(WSAEnumNetworkEvents(sockfd, event_handle, &events) != 0) { if(WSAEnumNetworkEvents(sockfd, event_handle, &events) != 0) {
int err = SOCKERRNO; int sockerr = SOCKERRNO;
if(err != SOCKEINPROGRESS) { if(sockerr != SOCKEINPROGRESS) {
infof(data, "WSAEnumNetworkEvents failed (%d)", err); infof(data, "WSAEnumNetworkEvents failed (%d)", sockerr);
keepon = FALSE; keepon = FALSE;
result = CURLE_READ_ERROR; 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) { if(rc == -1) {
/* bail out */ /* bail out */
int error = SOCKERRNO; int sockerr = SOCKERRNO;
char buffer[STRERROR_LEN]; 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; state->event = TFTP_EVENT_ERROR;
} }
else if(rc) { else if(rc) {

10
tests/libtest/first.h
View file

@ -484,12 +484,12 @@ void ws_close(CURL *curl); /* close the connection */
#define exe_select_test(A, B, C, D, E, Y, Z) \ #define exe_select_test(A, B, C, D, E, Y, Z) \
do { \ do { \
if(select_wrapper(A, B, C, D, E) == -1) { \ if(select_wrapper(A, B, C, D, E) == -1) { \
int ec = SOCKERRNO; \ int sockerr = SOCKERRNO; \
char ecbuf[STRERROR_LEN]; \ char sockerrbuf[STRERROR_LEN]; \
curl_mfprintf(stderr, \ curl_mfprintf(stderr, \
"%s:%d select() failed, with " \ "%s:%d select() failed, with errno %d (%s)\n", Y, Z, \
"errno %d (%s)\n", \ sockerr, curlx_strerror(sockerr, sockerrbuf, \
Y, Z, ec, curlx_strerror(ec, ecbuf, sizeof(ecbuf))); \ sizeof(sockerrbuf))); \
result = TEST_ERR_SELECT; \ result = TEST_ERR_SELECT; \
} \ } \
} while(0) } while(0)

18
tests/server/dnsd.c
View file

@ -742,7 +742,7 @@ static int test_dnsd(int argc, const char **argv)
curl_socket_t sock = CURL_SOCKET_BAD; curl_socket_t sock = CURL_SOCKET_BAD;
int flag; int flag;
int rc; int rc;
int error; int sockerr;
char errbuf[STRERROR_LEN]; char errbuf[STRERROR_LEN];
int result = 0; int result = 0;
struct resp *resp; struct resp *resp;
@ -840,18 +840,18 @@ static int test_dnsd(int argc, const char **argv)
#endif #endif
if(sock == CURL_SOCKET_BAD) { if(sock == CURL_SOCKET_BAD) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("Error creating socket (%d) %s", logmsg("Error creating socket (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
result = 1; result = 1;
goto dnsd_cleanup; goto dnsd_cleanup;
} }
flag = 1; flag = 1;
if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&flag, sizeof(flag))) { if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&flag, sizeof(flag))) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("setsockopt(SO_REUSEADDR) failed with error (%d) %s", logmsg("setsockopt(SO_REUSEADDR) failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
result = 1; result = 1;
goto dnsd_cleanup; goto dnsd_cleanup;
} }
@ -875,9 +875,9 @@ static int test_dnsd(int argc, const char **argv)
} }
#endif /* USE_IPV6 */ #endif /* USE_IPV6 */
if(rc) { if(rc) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("Error binding socket on port %hu (%d) %s", port, logmsg("Error binding socket on port %hu (%d) %s", port,
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
result = 1; result = 1;
goto dnsd_cleanup; goto dnsd_cleanup;
} }
@ -897,9 +897,9 @@ static int test_dnsd(int argc, const char **argv)
la_size = sizeof(localaddr.sa6); la_size = sizeof(localaddr.sa6);
#endif #endif
if(getsockname(sock, &localaddr.sa, &la_size) < 0) { if(getsockname(sock, &localaddr.sa, &la_size) < 0) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("getsockname() failed with error (%d) %s", logmsg("getsockname() failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
sclose(sock); sclose(sock);
goto dnsd_cleanup; goto dnsd_cleanup;
} }

16
tests/server/mqttd.c
View file

@ -713,7 +713,7 @@ static bool mqttd_incoming(curl_socket_t listenfd)
do { do {
ssize_t rc; ssize_t rc;
int error = 0; int sockerr = 0;
char errbuf[STRERROR_LEN]; char errbuf[STRERROR_LEN];
curl_socket_t sockfd = listenfd; curl_socket_t sockfd = listenfd;
int maxfd = (int)sockfd; int maxfd = (int)sockfd;
@ -732,20 +732,20 @@ static bool mqttd_incoming(curl_socket_t listenfd)
logmsg("signalled to die, exiting..."); logmsg("signalled to die, exiting...");
return FALSE; return FALSE;
} }
} while((rc == -1) && ((error = SOCKERRNO) == SOCKEINTR)); } while((rc == -1) && ((sockerr = SOCKERRNO) == SOCKEINTR));
if(rc < 0) { if(rc < 0) {
logmsg("select() failed with error (%d) %s", logmsg("select() failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
return FALSE; return FALSE;
} }
if(FD_ISSET(sockfd, &fds_read)) { if(FD_ISSET(sockfd, &fds_read)) {
curl_socket_t newfd = accept(sockfd, NULL, NULL); curl_socket_t newfd = accept(sockfd, NULL, NULL);
if(newfd == CURL_SOCKET_BAD) { if(newfd == CURL_SOCKET_BAD) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("accept() failed with error (%d) %s", logmsg("accept() failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
} }
else { else {
logmsg("====> Client connect, fd %ld. " logmsg("====> Client connect, fd %ld. "
@ -770,7 +770,7 @@ static int test_mqttd(int argc, const char *argv[])
int wrotepidfile = 0; int wrotepidfile = 0;
int wroteportfile = 0; int wroteportfile = 0;
bool juggle_again; bool juggle_again;
int error; int sockerr;
char errbuf[STRERROR_LEN]; char errbuf[STRERROR_LEN];
int arg = 1; int arg = 1;
@ -872,9 +872,9 @@ static int test_mqttd(int argc, const char *argv[])
sock = socket(socket_domain, SOCK_STREAM, 0); sock = socket(socket_domain, SOCK_STREAM, 0);
if(sock == CURL_SOCKET_BAD) { if(sock == CURL_SOCKET_BAD) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("Error creating socket (%d) %s", logmsg("Error creating socket (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
goto mqttd_cleanup; goto mqttd_cleanup;
} }

36
tests/server/rtspd.c
View file

@ -604,7 +604,7 @@ storerequest_cleanup:
/* return 0 on success, non-zero on failure */ /* return 0 on success, non-zero on failure */
static int rtspd_get_request(curl_socket_t sock, struct rtspd_httprequest *req) static int rtspd_get_request(curl_socket_t sock, struct rtspd_httprequest *req)
{ {
int error; int sockerr;
char errbuf[STRERROR_LEN]; char errbuf[STRERROR_LEN];
int fail = 0; int fail = 0;
int done_processing = 0; int done_processing = 0;
@ -665,9 +665,9 @@ static int rtspd_get_request(curl_socket_t sock, struct rtspd_httprequest *req)
fail = 1; fail = 1;
} }
else if(got < 0) { else if(got < 0) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("recv() returned error (%d) %s", logmsg("recv() returned error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
fail = 1; fail = 1;
} }
if(fail) { if(fail) {
@ -975,9 +975,9 @@ static int rtspd_send_doc(curl_socket_t sock, struct rtspd_httprequest *req)
break; break;
if(res) { if(res) {
/* should not happen */ /* should not happen */
error = SOCKERRNO; int sockerr = SOCKERRNO;
logmsg("curlx_wait_ms() failed with error (%d) %s", logmsg("curlx_wait_ms() failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
break; break;
} }
} }
@ -1014,7 +1014,7 @@ static int test_rtspd(int argc, const char *argv[])
unsigned short port = 8999; unsigned short port = 8999;
struct rtspd_httprequest req; struct rtspd_httprequest req;
int rc; int rc;
int error; int sockerr;
char errbuf[STRERROR_LEN]; char errbuf[STRERROR_LEN];
int arg = 1; int arg = 1;
@ -1118,17 +1118,17 @@ static int test_rtspd(int argc, const char *argv[])
#endif #endif
if(sock == CURL_SOCKET_BAD) { if(sock == CURL_SOCKET_BAD) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("Error creating socket (%d) %s", logmsg("Error creating socket (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
goto server_cleanup; goto server_cleanup;
} }
flag = 1; flag = 1;
if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&flag, sizeof(flag))) { if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&flag, sizeof(flag))) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("setsockopt(SO_REUSEADDR) failed with error (%d) %s", logmsg("setsockopt(SO_REUSEADDR) failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
goto server_cleanup; goto server_cleanup;
} }
@ -1151,9 +1151,9 @@ static int test_rtspd(int argc, const char *argv[])
} }
#endif /* USE_IPV6 */ #endif /* USE_IPV6 */
if(rc) { if(rc) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("Error binding socket on port %hu (%d) %s", port, logmsg("Error binding socket on port %hu (%d) %s", port,
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
goto server_cleanup; goto server_cleanup;
} }
@ -1172,9 +1172,9 @@ static int test_rtspd(int argc, const char *argv[])
la_size = sizeof(localaddr.sa6); la_size = sizeof(localaddr.sa6);
#endif #endif
if(getsockname(sock, &localaddr.sa, &la_size) < 0) { if(getsockname(sock, &localaddr.sa, &la_size) < 0) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("getsockname() failed with error (%d) %s", logmsg("getsockname() failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
sclose(sock); sclose(sock);
goto server_cleanup; goto server_cleanup;
} }
@ -1205,9 +1205,9 @@ static int test_rtspd(int argc, const char *argv[])
/* start accepting connections */ /* start accepting connections */
rc = listen(sock, 5); rc = listen(sock, 5);
if(rc) { if(rc) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("listen() failed with error (%d) %s", logmsg("listen() failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
goto server_cleanup; goto server_cleanup;
} }
@ -1232,9 +1232,9 @@ static int test_rtspd(int argc, const char *argv[])
if(got_exit_signal) if(got_exit_signal)
break; break;
if(msgsock == CURL_SOCKET_BAD) { if(msgsock == CURL_SOCKET_BAD) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("MAJOR ERROR, accept() failed with error (%d) %s", logmsg("MAJOR ERROR, accept() failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
break; break;
} }

20
tests/server/sockfilt.c
View file

@ -928,7 +928,7 @@ static bool juggle(curl_socket_t *sockfdp,
curl_socket_t sockfd = CURL_SOCKET_BAD; curl_socket_t sockfd = CURL_SOCKET_BAD;
int maxfd = -99; int maxfd = -99;
ssize_t rc; ssize_t rc;
int error = 0; int sockerr = 0;
char errbuf[STRERROR_LEN]; char errbuf[STRERROR_LEN];
unsigned char buffer[BUFFER_SIZE]; unsigned char buffer[BUFFER_SIZE];
@ -1014,11 +1014,11 @@ static bool juggle(curl_socket_t *sockfdp,
logmsg("signalled to die, exiting..."); logmsg("signalled to die, exiting...");
return FALSE; return FALSE;
} }
} while((rc == -1) && ((error = SOCKERRNO) == SOCKEINTR)); } while((rc == -1) && ((sockerr = SOCKERRNO) == SOCKEINTR));
if(rc < 0) { if(rc < 0) {
logmsg("select() failed with error (%d) %s", logmsg("select() failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
return FALSE; return FALSE;
} }
@ -1120,9 +1120,9 @@ static bool juggle(curl_socket_t *sockfdp,
client connecting. */ client connecting. */
curl_socket_t newfd = accept(sockfd, NULL, NULL); curl_socket_t newfd = accept(sockfd, NULL, NULL);
if(newfd == CURL_SOCKET_BAD) { if(newfd == CURL_SOCKET_BAD) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("accept() failed with error (%d) %s", logmsg("accept() failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
} }
else { else {
logmsg("====> Client connect"); logmsg("====> Client connect");
@ -1174,7 +1174,7 @@ static int test_sockfilt(int argc, const char *argv[])
int wroteportfile = 0; int wroteportfile = 0;
bool juggle_again; bool juggle_again;
int rc; int rc;
int error; int sockerr;
char errbuf[STRERROR_LEN]; char errbuf[STRERROR_LEN];
int arg = 1; int arg = 1;
enum sockmode mode = PASSIVE_LISTEN; /* default */ enum sockmode mode = PASSIVE_LISTEN; /* default */
@ -1293,9 +1293,9 @@ static int test_sockfilt(int argc, const char *argv[])
sock = socket(socket_domain, SOCK_STREAM, 0); sock = socket(socket_domain, SOCK_STREAM, 0);
if(sock == CURL_SOCKET_BAD) { if(sock == CURL_SOCKET_BAD) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("Error creating socket (%d) %s", logmsg("Error creating socket (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
write_stdout("FAIL\n", 5); write_stdout("FAIL\n", 5);
goto sockfilt_cleanup; goto sockfilt_cleanup;
} }
@ -1331,9 +1331,9 @@ static int test_sockfilt(int argc, const char *argv[])
rc = 1; rc = 1;
} }
if(rc) { if(rc) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("Error connecting to port %hu (%d) %s", server_connectport, logmsg("Error connecting to port %hu (%d) %s", server_connectport,
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
write_stdout("FAIL\n", 5); write_stdout("FAIL\n", 5);
goto sockfilt_cleanup; goto sockfilt_cleanup;
} }

21
tests/server/socksd.c
View file

@ -228,9 +228,9 @@ static curl_socket_t socksconnect(unsigned short connectport,
if(rc) { if(rc) {
char errbuf[STRERROR_LEN]; char errbuf[STRERROR_LEN];
int error = SOCKERRNO; int sockerr = SOCKERRNO;
logmsg("Failed connecting to %s:%hu (%d) %s", connectaddr, connectport, logmsg("Failed connecting to %s:%hu (%d) %s", connectaddr, connectport,
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
return CURL_SOCKET_BAD; return CURL_SOCKET_BAD;
} }
logmsg("Connected fine to %s:%d", connectaddr, connectport); logmsg("Connected fine to %s:%d", connectaddr, connectport);
@ -636,7 +636,7 @@ static bool socksd_incoming(curl_socket_t listenfd)
do { do {
int i; int i;
ssize_t rc; ssize_t rc;
int error = 0; int sockerr = 0;
char errbuf[STRERROR_LEN]; char errbuf[STRERROR_LEN];
curl_socket_t sockfd = listenfd; curl_socket_t sockfd = listenfd;
int maxfd = (int)sockfd; int maxfd = (int)sockfd;
@ -668,20 +668,20 @@ static bool socksd_incoming(curl_socket_t listenfd)
logmsg("signalled to die, exiting..."); logmsg("signalled to die, exiting...");
return FALSE; return FALSE;
} }
} while((rc == -1) && ((error = SOCKERRNO) == SOCKEINTR)); } while((rc == -1) && ((sockerr = SOCKERRNO) == SOCKEINTR));
if(rc < 0) { if(rc < 0) {
logmsg("select() failed with error (%d) %s", logmsg("select() failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
return FALSE; return FALSE;
} }
if((clients < 2) && FD_ISSET(sockfd, &fds_read)) { if((clients < 2) && FD_ISSET(sockfd, &fds_read)) {
curl_socket_t newfd = accept(sockfd, NULL, NULL); curl_socket_t newfd = accept(sockfd, NULL, NULL);
if(newfd == CURL_SOCKET_BAD) { if(newfd == CURL_SOCKET_BAD) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("accept() failed with error (%d) %s", logmsg("accept() failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
} }
else { else {
curl_socket_t remotefd; curl_socket_t remotefd;
@ -732,7 +732,6 @@ static int test_socksd(int argc, const char *argv[])
int wrotepidfile = 0; int wrotepidfile = 0;
int wroteportfile = 0; int wroteportfile = 0;
bool juggle_again; bool juggle_again;
int error;
char errbuf[STRERROR_LEN]; char errbuf[STRERROR_LEN];
int arg = 1; int arg = 1;
@ -866,9 +865,9 @@ static int test_socksd(int argc, const char *argv[])
sock = socket(socket_domain, SOCK_STREAM, 0); sock = socket(socket_domain, SOCK_STREAM, 0);
if(sock == CURL_SOCKET_BAD) { if(sock == CURL_SOCKET_BAD) {
error = SOCKERRNO; int sockerr = SOCKERRNO;
logmsg("Error creating socket (%d) %s", logmsg("Error creating socket (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
goto socks5_cleanup; goto socks5_cleanup;
} }
@ -919,7 +918,7 @@ socks5_cleanup:
#ifdef USE_UNIX_SOCKETS #ifdef USE_UNIX_SOCKETS
if(unlink_socket && socket_domain == AF_UNIX && unix_socket) { if(unlink_socket && socket_domain == AF_UNIX && unix_socket) {
error = unlink(unix_socket); int error = unlink(unix_socket);
logmsg("unlink(%s) = %d (%s)", unix_socket, logmsg("unlink(%s) = %d (%s)", unix_socket,
error, curlx_strerror(error, errbuf, sizeof(errbuf))); error, curlx_strerror(error, errbuf, sizeof(errbuf)));
} }

88
tests/server/sws.c
View file

@ -1048,9 +1048,9 @@ retry:
res = curlx_wait_ms(250); res = curlx_wait_ms(250);
if(res) { if(res) {
/* should not happen */ /* should not happen */
error = SOCKERRNO; int sockerr = SOCKERRNO;
logmsg("curlx_wait_ms() failed with error (%d) %s", logmsg("curlx_wait_ms() failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
break; break;
} }
} }
@ -1192,13 +1192,13 @@ static int sws_get_request(curl_socket_t sock, struct sws_httprequest *req)
} }
else if(got < 0) { else if(got < 0) {
char errbuf[STRERROR_LEN]; char errbuf[STRERROR_LEN];
int error = SOCKERRNO; int sockerr = SOCKERRNO;
if(SOCK_EAGAIN(error)) { if(SOCK_EAGAIN(sockerr)) {
/* nothing to read at the moment */ /* nothing to read at the moment */
return 0; return 0;
} }
logmsg("recv() returned error (%d) %s", logmsg("recv() returned error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
fail = 1; fail = 1;
} }
if(fail) { if(fail) {
@ -1246,7 +1246,7 @@ static curl_socket_t connect_to(const char *ipaddr, unsigned short port)
{ {
srvr_sockaddr_union_t serveraddr; srvr_sockaddr_union_t serveraddr;
curl_socket_t serverfd; curl_socket_t serverfd;
int error; int sockerr;
char errbuf[STRERROR_LEN]; char errbuf[STRERROR_LEN];
int rc = 0; int rc = 0;
const char *op_br = ""; const char *op_br = "";
@ -1266,9 +1266,9 @@ static curl_socket_t connect_to(const char *ipaddr, unsigned short port)
serverfd = socket(socket_domain, SOCK_STREAM, 0); serverfd = socket(socket_domain, SOCK_STREAM, 0);
if(serverfd == CURL_SOCKET_BAD) { if(serverfd == CURL_SOCKET_BAD) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("Error creating socket for server connection (%d) %s", logmsg("Error creating socket for server connection (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
return CURL_SOCKET_BAD; return CURL_SOCKET_BAD;
} }
@ -1286,9 +1286,9 @@ static curl_socket_t connect_to(const char *ipaddr, unsigned short port)
* Windows has an internal retry logic that may lead to long * Windows has an internal retry logic that may lead to long
* timeouts if the peer is not listening. */ * timeouts if the peer is not listening. */
if(curlx_nonblock(serverfd, TRUE)) { if(curlx_nonblock(serverfd, TRUE)) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("curlx_nonblock(TRUE) failed with error (%d) %s", logmsg("curlx_nonblock(TRUE) failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
sclose(serverfd); sclose(serverfd);
return CURL_SOCKET_BAD; return CURL_SOCKET_BAD;
} }
@ -1333,8 +1333,8 @@ static curl_socket_t connect_to(const char *ipaddr, unsigned short port)
} }
if(rc) { if(rc) {
error = SOCKERRNO; sockerr = SOCKERRNO;
if((error == SOCKEINPROGRESS) || SOCK_EAGAIN(error)) { if((sockerr == SOCKEINPROGRESS) || SOCK_EAGAIN(sockerr)) {
fd_set output; fd_set output;
struct timeval timeout = { 0 }; struct timeval timeout = { 0 };
timeout.tv_sec = 1; /* 1000 ms */ timeout.tv_sec = 1; /* 1000 ms */
@ -1346,13 +1346,13 @@ static curl_socket_t connect_to(const char *ipaddr, unsigned short port)
if(rc < 0 && SOCKERRNO != SOCKEINTR) if(rc < 0 && SOCKERRNO != SOCKEINTR)
goto error; goto error;
else if(rc > 0) { else if(rc > 0) {
curl_socklen_t errSize = sizeof(error); curl_socklen_t errSize = sizeof(sockerr);
if(getsockopt(serverfd, SOL_SOCKET, SO_ERROR, if(getsockopt(serverfd, SOL_SOCKET, SO_ERROR,
(void *)&error, &errSize)) (void *)&sockerr, &errSize))
error = SOCKERRNO; sockerr = SOCKERRNO;
if((error == 0) || (SOCKEISCONN == error)) if((sockerr == 0) || (SOCKEISCONN == sockerr))
goto success; goto success;
else if((error != SOCKEINPROGRESS) && !SOCK_EAGAIN(error)) else if((sockerr != SOCKEINPROGRESS) && !SOCK_EAGAIN(sockerr))
goto error; goto error;
} }
else if(!rc) { else if(!rc) {
@ -1364,7 +1364,7 @@ static curl_socket_t connect_to(const char *ipaddr, unsigned short port)
} }
error: error:
logmsg("Error connecting to server port %hu (%d) %s", port, logmsg("Error connecting to server port %hu (%d) %s", port,
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
sclose(serverfd); sclose(serverfd);
return CURL_SOCKET_BAD; return CURL_SOCKET_BAD;
} }
@ -1373,9 +1373,9 @@ success:
op_br, ipaddr, cl_br, port); op_br, ipaddr, cl_br, port);
if(curlx_nonblock(serverfd, FALSE)) { if(curlx_nonblock(serverfd, FALSE)) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("curlx_nonblock(FALSE) failed with error (%d) %s", logmsg("curlx_nonblock(FALSE) failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
sclose(serverfd); sclose(serverfd);
return CURL_SOCKET_BAD; return CURL_SOCKET_BAD;
} }
@ -1802,7 +1802,7 @@ static void http_upgrade(struct sws_httprequest *req)
static curl_socket_t accept_connection(curl_socket_t sock) static curl_socket_t accept_connection(curl_socket_t sock)
{ {
curl_socket_t msgsock = CURL_SOCKET_BAD; curl_socket_t msgsock = CURL_SOCKET_BAD;
int error; int sockerr;
char errbuf[STRERROR_LEN]; char errbuf[STRERROR_LEN];
int flag = 1; int flag = 1;
@ -1820,20 +1820,20 @@ static curl_socket_t accept_connection(curl_socket_t sock)
} }
if(msgsock == CURL_SOCKET_BAD) { if(msgsock == CURL_SOCKET_BAD) {
error = SOCKERRNO; sockerr = SOCKERRNO;
if(SOCK_EAGAIN(error)) { if(SOCK_EAGAIN(sockerr)) {
/* nothing to accept */ /* nothing to accept */
return 0; return 0;
} }
logmsg("MAJOR ERROR, accept() failed with error (%d) %s", logmsg("MAJOR ERROR, accept() failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
return CURL_SOCKET_BAD; return CURL_SOCKET_BAD;
} }
if(curlx_nonblock(msgsock, TRUE)) { if(curlx_nonblock(msgsock, TRUE)) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("curlx_nonblock failed with error (%d) %s", logmsg("curlx_nonblock failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
sclose(msgsock); sclose(msgsock);
return CURL_SOCKET_BAD; return CURL_SOCKET_BAD;
} }
@ -1843,9 +1843,9 @@ static curl_socket_t accept_connection(curl_socket_t sock)
#endif #endif
if(setsockopt(msgsock, SOL_SOCKET, SO_KEEPALIVE, if(setsockopt(msgsock, SOL_SOCKET, SO_KEEPALIVE,
(void *)&flag, sizeof(flag))) { (void *)&flag, sizeof(flag))) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("setsockopt(SO_KEEPALIVE) failed with error (%d) %s", logmsg("setsockopt(SO_KEEPALIVE) failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
sclose(msgsock); sclose(msgsock);
return CURL_SOCKET_BAD; return CURL_SOCKET_BAD;
} }
@ -1974,7 +1974,7 @@ static int test_sws(int argc, const char *argv[])
#endif #endif
struct sws_httprequest *req = NULL; struct sws_httprequest *req = NULL;
int rc = 0; int rc = 0;
int error; int sockerr;
char errbuf[STRERROR_LEN]; char errbuf[STRERROR_LEN];
int arg = 1; int arg = 1;
const char *connecthost = "127.0.0.1"; const char *connecthost = "127.0.0.1";
@ -2146,9 +2146,9 @@ static int test_sws(int argc, const char *argv[])
num_sockets = 1; num_sockets = 1;
if(sock == CURL_SOCKET_BAD) { if(sock == CURL_SOCKET_BAD) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("Error creating socket (%d) %s", logmsg("Error creating socket (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
goto sws_cleanup; goto sws_cleanup;
} }
@ -2158,18 +2158,18 @@ static int test_sws(int argc, const char *argv[])
flag = 1; flag = 1;
if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
(void *)&flag, sizeof(flag))) { (void *)&flag, sizeof(flag))) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("setsockopt(SO_REUSEADDR) failed with error (%d) %s", logmsg("setsockopt(SO_REUSEADDR) failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
goto sws_cleanup; goto sws_cleanup;
} }
#if defined(_WIN32) && defined(USE_UNIX_SOCKETS) #if defined(_WIN32) && defined(USE_UNIX_SOCKETS)
} }
#endif #endif
if(curlx_nonblock(sock, TRUE)) { if(curlx_nonblock(sock, TRUE)) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("curlx_nonblock failed with error (%d) %s", logmsg("curlx_nonblock failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
goto sws_cleanup; goto sws_cleanup;
} }
@ -2196,15 +2196,15 @@ static int test_sws(int argc, const char *argv[])
#endif /* USE_UNIX_SOCKETS */ #endif /* USE_UNIX_SOCKETS */
} }
if(rc) { if(rc) {
error = SOCKERRNO; sockerr = SOCKERRNO;
#ifdef USE_UNIX_SOCKETS #ifdef USE_UNIX_SOCKETS
if(socket_domain == AF_UNIX) if(socket_domain == AF_UNIX)
logmsg("Error binding socket on path %s (%d) %s", unix_socket, logmsg("Error binding socket on path %s (%d) %s", unix_socket,
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
else else
#endif #endif
logmsg("Error binding socket on port %hu (%d) %s", port, logmsg("Error binding socket on port %hu (%d) %s", port,
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
goto sws_cleanup; goto sws_cleanup;
} }
@ -2223,9 +2223,9 @@ static int test_sws(int argc, const char *argv[])
la_size = sizeof(localaddr.sa6); la_size = sizeof(localaddr.sa6);
#endif #endif
if(getsockname(sock, &localaddr.sa, &la_size) < 0) { if(getsockname(sock, &localaddr.sa, &la_size) < 0) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("getsockname() failed with error (%d) %s", logmsg("getsockname() failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
sclose(sock); sclose(sock);
goto sws_cleanup; goto sws_cleanup;
} }
@ -2262,9 +2262,9 @@ static int test_sws(int argc, const char *argv[])
/* start accepting connections */ /* start accepting connections */
rc = listen(sock, 50); rc = listen(sock, 50);
if(rc) { if(rc) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("listen() failed with error (%d) %s", logmsg("listen() failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
goto sws_cleanup; goto sws_cleanup;
} }
@ -2336,9 +2336,9 @@ static int test_sws(int argc, const char *argv[])
goto sws_cleanup; goto sws_cleanup;
if(rc < 0) { if(rc < 0) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("select() failed with error (%d) %s", logmsg("select() failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
goto sws_cleanup; goto sws_cleanup;
} }

18
tests/server/tftpd.c
View file

@ -1015,7 +1015,7 @@ static int test_tftpd(int argc, const char **argv)
curl_socket_t sock = CURL_SOCKET_BAD; curl_socket_t sock = CURL_SOCKET_BAD;
int flag; int flag;
int rc; int rc;
int error; int sockerr;
char errbuf[STRERROR_LEN]; char errbuf[STRERROR_LEN];
struct testcase test; struct testcase test;
int result = 0; int result = 0;
@ -1121,18 +1121,18 @@ static int test_tftpd(int argc, const char **argv)
#endif #endif
if(sock == CURL_SOCKET_BAD) { if(sock == CURL_SOCKET_BAD) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("Error creating socket (%d) %s", logmsg("Error creating socket (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
result = 1; result = 1;
goto tftpd_cleanup; goto tftpd_cleanup;
} }
flag = 1; flag = 1;
if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&flag, sizeof(flag))) { if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&flag, sizeof(flag))) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("setsockopt(SO_REUSEADDR) failed with error (%d) %s", logmsg("setsockopt(SO_REUSEADDR) failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
result = 1; result = 1;
goto tftpd_cleanup; goto tftpd_cleanup;
} }
@ -1156,9 +1156,9 @@ static int test_tftpd(int argc, const char **argv)
} }
#endif /* USE_IPV6 */ #endif /* USE_IPV6 */
if(rc) { if(rc) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("Error binding socket on port %hu (%d) %s", port, logmsg("Error binding socket on port %hu (%d) %s", port,
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
result = 1; result = 1;
goto tftpd_cleanup; goto tftpd_cleanup;
} }
@ -1178,9 +1178,9 @@ static int test_tftpd(int argc, const char **argv)
la_size = sizeof(localaddr.sa6); la_size = sizeof(localaddr.sa6);
#endif #endif
if(getsockname(sock, &localaddr.sa, &la_size) < 0) { if(getsockname(sock, &localaddr.sa, &la_size) < 0) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("getsockname() failed with error (%d) %s", logmsg("getsockname() failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
sclose(sock); sclose(sock);
goto tftpd_cleanup; goto tftpd_cleanup;
} }

37
tests/server/util.c
View file

@ -656,7 +656,6 @@ void restore_signal_handlers(bool keep_sigalrm)
int bind_unix_socket(curl_socket_t sock, const char *unix_socket, int bind_unix_socket(curl_socket_t sock, const char *unix_socket,
struct sockaddr_un *sau) struct sockaddr_un *sau)
{ {
int error;
char errbuf[STRERROR_LEN]; char errbuf[STRERROR_LEN];
int rc; int rc;
size_t len; size_t len;
@ -678,20 +677,22 @@ int bind_unix_socket(curl_socket_t sock, const char *unix_socket,
rc = bind(sock, (struct sockaddr *)sau, sizeof(struct sockaddr_un)); rc = bind(sock, (struct sockaddr *)sau, sizeof(struct sockaddr_un));
if(rc && SOCKERRNO == SOCKEADDRINUSE) { if(rc && SOCKERRNO == SOCKEADDRINUSE) {
curlx_struct_stat statbuf; curlx_struct_stat statbuf;
int sockerr;
/* socket already exists. Perhaps it is stale? */ /* socket already exists. Perhaps it is stale? */
curl_socket_t unixfd = socket(AF_UNIX, SOCK_STREAM, 0); curl_socket_t unixfd = socket(AF_UNIX, SOCK_STREAM, 0);
if(unixfd == CURL_SOCKET_BAD) { if(unixfd == CURL_SOCKET_BAD) {
sockerr = SOCKERRNO;
logmsg("Failed to create socket at %s (%d) %s", unix_socket, logmsg("Failed to create socket at %s (%d) %s", unix_socket,
SOCKERRNO, curlx_strerror(SOCKERRNO, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
return -1; return -1;
} }
/* check whether the server is alive */ /* check whether the server is alive */
rc = connect(unixfd, (struct sockaddr*)sau, sizeof(struct sockaddr_un)); rc = connect(unixfd, (struct sockaddr*)sau, sizeof(struct sockaddr_un));
error = SOCKERRNO; sockerr = SOCKERRNO;
sclose(unixfd); sclose(unixfd);
if(rc && error != SOCKECONNREFUSED) { if(rc && sockerr != SOCKECONNREFUSED) {
logmsg("Failed to connect to %s (%d) %s", unix_socket, logmsg("Failed to connect to %s (%d) %s", unix_socket,
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
return rc; return rc;
} }
/* socket server is not alive, now check if it was actually a socket. */ /* socket server is not alive, now check if it was actually a socket. */
@ -739,7 +740,7 @@ curl_socket_t sockdaemon(curl_socket_t sock,
int maxretr = 10; int maxretr = 10;
int delay = 20; int delay = 20;
int attempt = 0; int attempt = 0;
int error = 0; int sockerr = 0;
char errbuf[STRERROR_LEN]; char errbuf[STRERROR_LEN];
#ifndef USE_UNIX_SOCKETS #ifndef USE_UNIX_SOCKETS
@ -755,16 +756,16 @@ curl_socket_t sockdaemon(curl_socket_t sock,
rc = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, rc = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
(void *)&flag, sizeof(flag)); (void *)&flag, sizeof(flag));
if(rc) { if(rc) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("setsockopt(SO_REUSEADDR) failed with error (%d) %s", logmsg("setsockopt(SO_REUSEADDR) failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
if(maxretr) { if(maxretr) {
rc = curlx_wait_ms(delay); rc = curlx_wait_ms(delay);
if(rc) { if(rc) {
/* should not happen */ /* should not happen */
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("curlx_wait_ms() failed with error (%d) %s", logmsg("curlx_wait_ms() failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
sclose(sock); sclose(sock);
return CURL_SOCKET_BAD; return CURL_SOCKET_BAD;
} }
@ -782,7 +783,7 @@ curl_socket_t sockdaemon(curl_socket_t sock,
if(rc) { if(rc) {
logmsg("setsockopt(SO_REUSEADDR) failed %d times in %d ms. " logmsg("setsockopt(SO_REUSEADDR) failed %d times in %d ms. "
"Error (%d) %s", attempt, totdelay, "Error (%d) %s", attempt, totdelay,
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
logmsg("Continuing anyway..."); logmsg("Continuing anyway...");
} }
#if defined(_WIN32) && defined(USE_UNIX_SOCKETS) #if defined(_WIN32) && defined(USE_UNIX_SOCKETS)
@ -819,15 +820,15 @@ curl_socket_t sockdaemon(curl_socket_t sock,
} }
if(rc) { if(rc) {
error = SOCKERRNO; sockerr = SOCKERRNO;
#ifdef USE_UNIX_SOCKETS #ifdef USE_UNIX_SOCKETS
if(socket_domain == AF_UNIX) if(socket_domain == AF_UNIX)
logmsg("Error binding socket on path %s (%d) %s", unix_socket, logmsg("Error binding socket on path %s (%d) %s", unix_socket,
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
else else
#endif #endif
logmsg("Error binding socket on port %hu (%d) %s", *listenport, logmsg("Error binding socket on port %hu (%d) %s", *listenport,
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
sclose(sock); sclose(sock);
return CURL_SOCKET_BAD; return CURL_SOCKET_BAD;
} }
@ -849,9 +850,9 @@ curl_socket_t sockdaemon(curl_socket_t sock,
#endif #endif
la_size = sizeof(localaddr.sa4); la_size = sizeof(localaddr.sa4);
if(getsockname(sock, &localaddr.sa, &la_size) < 0) { if(getsockname(sock, &localaddr.sa, &la_size) < 0) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("getsockname() failed with error (%d) %s", logmsg("getsockname() failed with error (%d) %s",
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
sclose(sock); sclose(sock);
return CURL_SOCKET_BAD; return CURL_SOCKET_BAD;
} }
@ -887,9 +888,9 @@ curl_socket_t sockdaemon(curl_socket_t sock,
/* start accepting connections */ /* start accepting connections */
rc = listen(sock, 5); rc = listen(sock, 5);
if(rc) { if(rc) {
error = SOCKERRNO; sockerr = SOCKERRNO;
logmsg("listen(%ld, 5) failed with error (%d) %s", (long)sock, logmsg("listen(%ld, 5) failed with error (%d) %s", (long)sock,
error, curlx_strerror(error, errbuf, sizeof(errbuf))); sockerr, curlx_strerror(sockerr, errbuf, sizeof(errbuf)));
sclose(sock); sclose(sock);
return CURL_SOCKET_BAD; return CURL_SOCKET_BAD;
} }