romenskiy2012/curl
1
0
Fork 0
mirror of https://github.com/curl/curl.git synced 2026-08-25 07:43:32 +03:00
Code Issues Projects Releases Packages Wiki Activity

curlx_inet_ntop: return CURLcode, drop setting errno

Browse source 
To simplify and to remove an exception where `errno` was reused to
return a socket error codes on Windows.

The error was used by one call site (`sockaddr2string()` in
`cf-socket.c`), but it was in practice always propagated as
`SOCKEAFNOSUPPORT` to callers.

Also:
- cf-socket: update 3 error messages to show `CURLcode` accordingly.
- if2ip: handle `curlx_inet_ntop()` error in `Curl_if2ip()`.
- dnsd: display `CURLcode` on two errors.

Follow-up to 39dec13ec0 #22170

Closes #22229
This commit is contained in:
Viktor Szakats 2026-06-30 18:10:23 +02:00
parent c2da5c7e66
commit bb406386d9
No known key found for this signature in database
11 changed files with 81 additions and 110 deletions
Download patch file Download diff file Expand all files Collapse all files

69
lib/cf-socket.c
View file

@ -86,14 +86,15 @@
#endif
/* retrieves ip address and port from a sockaddr structure. note it calls
* curlx_inet_ntop which sets errno on fail, not SOCKERRNO.
* curlx_inet_ntop() and returns CURLcode.
* @unittest 1607
*/
UNITTEST bool sockaddr2string(struct sockaddr *sa, curl_socklen_t salen,
char *addr, uint16_t *port);
UNITTEST bool sockaddr2string(struct sockaddr *sa, curl_socklen_t salen,
char *addr, uint16_t *port)
UNITTEST CURLcode sockaddr2string(struct sockaddr *sa, curl_socklen_t salen,
char *addr, uint16_t *port);
UNITTEST CURLcode sockaddr2string(struct sockaddr *sa, curl_socklen_t salen,
char *addr, uint16_t *port)
{
CURLcode result;
struct sockaddr_in *si = NULL;
#ifdef USE_IPV6
struct sockaddr_in6 *si6 = NULL;
@ -107,17 +108,21 @@ UNITTEST bool sockaddr2string(struct sockaddr *sa, curl_socklen_t salen,
switch(sa->sa_family) {
case AF_INET:
si = (struct sockaddr_in *)(void *)sa;
if(curlx_inet_ntop(sa->sa_family, &si->sin_addr, addr, MAX_IPADR_LEN)) {
result = curlx_inet_ntop(sa->sa_family, &si->sin_addr, addr,
MAX_IPADR_LEN);
if(!result) {
*port = ntohs(si->sin_port);
return TRUE;
return result;
}
break;
#ifdef USE_IPV6
case AF_INET6:
si6 = (struct sockaddr_in6 *)(void *)sa;
if(curlx_inet_ntop(sa->sa_family, &si6->sin6_addr, addr, MAX_IPADR_LEN)) {
result = curlx_inet_ntop(sa->sa_family, &si6->sin6_addr, addr,
MAX_IPADR_LEN);
if(!result) {
*port = ntohs(si6->sin6_port);
return TRUE;
return result;
}
break;
#endif
@ -130,16 +135,16 @@ UNITTEST bool sockaddr2string(struct sockaddr *sa, curl_socklen_t salen,
else
addr[0] = 0; /* socket with no name */
*port = 0;
return TRUE;
return CURLE_OK;
#endif
default:
result = CURLE_UNSUPPORTED_PROTOCOL;
break;
}
addr[0] = '\0';
*port = 0;
errno = SOCKEAFNOSUPPORT;
return FALSE;
return result;
}
static void tcpnodelay(struct Curl_cfilter *cf,
@ -1087,18 +1092,19 @@ static void set_local_ip(struct Curl_cfilter *cf,
/* TFTP does not connect, so it cannot get the IP like this */
struct Curl_sockaddr_storage ssloc;
curl_socklen_t slen = sizeof(struct Curl_sockaddr_storage);
VERBOSE(char buffer[STRERROR_LEN]);
memset(&ssloc, 0, sizeof(ssloc));
if(getsockname(ctx->sock, (struct sockaddr *)&ssloc, &slen)) {
VERBOSE(char buffer[STRERROR_LEN]);
VERBOSE(int sockerr = SOCKERRNO);
infof(data, "getsockname() failed with errno %d: %s",
sockerr, curlx_strerror(sockerr, buffer, sizeof(buffer)));
}
else if(!sockaddr2string((struct sockaddr *)&ssloc, slen,
ctx->ip.local_ip, &ctx->ip.local_port)) {
infof(data, "ssloc inet_ntop() failed with errno %d: %s",
errno, curlx_strerror(errno, buffer, sizeof(buffer)));
else {
CURLcode result = sockaddr2string((struct sockaddr *)&ssloc, slen,
ctx->ip.local_ip, &ctx->ip.local_port);
if(result)
infof(data, "ssloc inet_ntop() failed with %d", (int)result);
}
}
#else
@ -1110,21 +1116,17 @@ static CURLcode set_remote_ip(struct Curl_cfilter *cf,
struct Curl_easy *data)
{
struct cf_socket_ctx *ctx = cf->ctx;
CURLcode result;
/* store remote address and port used in this connection attempt */
ctx->ip.transport = ctx->transport;
if(!sockaddr2string(&ctx->addr.curl_sa_addr,
(curl_socklen_t)ctx->addr.addrlen,
ctx->ip.remote_ip, &ctx->ip.remote_port)) {
char buffer[STRERROR_LEN];
/* 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;
result = sockaddr2string(&ctx->addr.curl_sa_addr,
(curl_socklen_t)ctx->addr.addrlen,
ctx->ip.remote_ip, &ctx->ip.remote_port);
if(result) {
ctx->sockerr = SOCKEAFNOSUPPORT;
/* 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)));
failf(data, "curl_sa_addr inet_ntop() failed with %d", (int)result);
return CURLE_FAILED_INIT;
}
return CURLE_OK;
@ -2156,7 +2158,7 @@ static void cf_tcp_set_accepted_remote_ip(struct Curl_cfilter *cf,
{
struct cf_socket_ctx *ctx = cf->ctx;
#ifdef HAVE_GETPEERNAME
char buffer[STRERROR_LEN];
CURLcode result;
struct Curl_sockaddr_storage ssrem;
curl_socklen_t plen;
@ -2165,15 +2167,16 @@ 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)) {
char buffer[STRERROR_LEN];
int sockerr = SOCKERRNO;
failf(data, "getpeername() failed with errno %d: %s",
sockerr, curlx_strerror(sockerr, buffer, sizeof(buffer)));
return;
}
if(!sockaddr2string((struct sockaddr *)&ssrem, plen,
ctx->ip.remote_ip, &ctx->ip.remote_port)) {
failf(data, "ssrem inet_ntop() failed with errno %d: %s",
errno, curlx_strerror(errno, buffer, sizeof(buffer)));
result = sockaddr2string((struct sockaddr *)&ssrem, plen,
ctx->ip.remote_ip, &ctx->ip.remote_port);
if(result) {
failf(data, "ssrem inet_ntop() failed with %d", (int)result);
return;
}
#else

50
lib/curlx/inet_ntop.c
View file

@ -48,12 +48,12 @@
/*
* Format an IPv4 address, more or less like inet_ntop().
*
* Returns `dst' (as a const)
* Returns CURLcode.
* Note:
* - uses no static variables
* - takes an unsigned char* not an in_addr as input
*/
static char *inet_ntop4(const unsigned char *src, char *dst, size_t size)
static CURLcode inet_ntop4(const unsigned char *src, char *dst, size_t size)
{
char tmp[sizeof("255.255.255.255")];
size_t len;
@ -68,22 +68,16 @@ static char *inet_ntop4(const unsigned char *src, char *dst, size_t size)
((int)((unsigned char)src[3])) & 0xff);
len = strlen(tmp);
if(len == 0 || len >= size) {
#ifdef USE_WINSOCK
errno = WSAEINVAL;
#else
errno = ENOSPC;
#endif
return NULL;
}
if(len == 0 || len >= size)
return CURLE_TOO_LARGE;
curlx_strcopy(dst, size, tmp, len);
return dst;
return CURLE_OK;
}
/*
* Convert IPv6 binary address into presentation (printable) format.
*/
static char *inet_ntop6(const unsigned char *src, char *dst, size_t size)
static CURLcode inet_ntop6(const unsigned char *src, char *dst, size_t size)
{
/*
* Note that int32_t and int16_t need only be "at least" large enough
@ -152,9 +146,9 @@ static char *inet_ntop6(const unsigned char *src, char *dst, size_t size)
*/
if(i == 6 && best.base == 0 &&
(best.len == 6 || (best.len == 5 && words[5] == 0xffff))) {
if(!inet_ntop4(src + 12, tp, sizeof(tmp) - (tp - tmp))) {
return NULL;
}
CURLcode result = inet_ntop4(src + 12, tp, sizeof(tmp) - (tp - tmp));
if(result)
return result;
tp += strlen(tp);
break;
}
@ -181,31 +175,18 @@ static char *inet_ntop6(const unsigned char *src, char *dst, size_t size)
*tp++ = ':';
/* Check for overflow, copy, and we are done. */
if((size_t)(tp - tmp) >= size) {
#ifdef USE_WINSOCK
errno = WSAEINVAL;
#else
errno = ENOSPC;
#endif
return NULL;
}
if((size_t)(tp - tmp) >= size)
return CURLE_TOO_LARGE;
curlx_strcopy(dst, size, tmp, tp - tmp);
return dst;
return CURLE_OK;
}
/*
* Convert a network format address to presentation format.
*
* Returns pointer to presentation format address (`buf').
* Returns NULL on error and errno set with the specific
* error, EAFNOSUPPORT or ENOSPC.
*
* On Windows we store the error in the thread errno, not in the Winsock error
* code. This is to avoid losing the actual last Winsock error. When this
* function returns NULL, check errno not SOCKERRNO.
* Copies result to 'buf' and returns CURLcode.
*/
char *curlx_inet_ntop(int af, const void *src, char *buf, size_t size)
CURLcode curlx_inet_ntop(int af, const void *src, char *buf, size_t size)
{
switch(af) {
case AF_INET:
@ -213,7 +194,6 @@ char *curlx_inet_ntop(int af, const void *src, char *buf, size_t size)
case AF_INET6:
return inet_ntop6((const unsigned char *)src, buf, size);
default:
errno = SOCKEAFNOSUPPORT;
return NULL;
return CURLE_UNSUPPORTED_PROTOCOL;
}
}

2
lib/curlx/inet_ntop.h
View file

@ -25,6 +25,6 @@
***************************************************************************/
#include "curl_setup.h"
char *curlx_inet_ntop(int af, const void *src, char *buf, size_t size);
CURLcode curlx_inet_ntop(int af, const void *src, char *buf, size_t size);
#endif /* HEADER_CURL_INET_NTOP_H */

8
lib/ftp.c
View file

@ -1022,7 +1022,7 @@ static CURLcode ftp_port_default_host(struct Curl_easy *data,
struct sockaddr_in6 * const sa6 = (void *)sa;
#endif
char buffer[STRERROR_LEN];
const char *r;
CURLcode result;
*sslenp = sizeof(*ss);
if(getsockname(conn->sock[FIRSTSOCKET], sa, sslenp)) {
@ -1033,14 +1033,14 @@ static CURLcode ftp_port_default_host(struct Curl_easy *data,
switch(sa->sa_family) {
#ifdef USE_IPV6
case AF_INET6:
r = curlx_inet_ntop(sa->sa_family, &sa6->sin6_addr, hbuf, hbuflen);
result = curlx_inet_ntop(sa->sa_family, &sa6->sin6_addr, hbuf, hbuflen);
break;
#endif
default:
r = curlx_inet_ntop(sa->sa_family, &sa4->sin_addr, hbuf, hbuflen);
result = curlx_inet_ntop(sa->sa_family, &sa4->sin_addr, hbuf, hbuflen);
break;
}
if(!r)
if(result)
return CURLE_FTP_PORT_FAILED;
*hostp = hbuf;

12
lib/if2ip.c
View file

@ -112,9 +112,9 @@ if2ip_result_t Curl_if2ip(int af,
if(iface->ifa_addr->sa_family == af) {
if(curl_strequal(iface->ifa_name, interf)) {
void *addr;
const char *ip;
char scope[12] = "";
char ipstr[64];
CURLcode result;
#ifdef USE_IPV6
if(af == AF_INET6) {
#ifdef HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID
@ -155,8 +155,8 @@ if2ip_result_t Curl_if2ip(int af,
addr =
&((struct sockaddr_in *)(void *)iface->ifa_addr)->sin_addr;
res = IF2IP_FOUND;
ip = curlx_inet_ntop(af, addr, ipstr, sizeof(ipstr));
curl_msnprintf(buf, buf_size, "%s%s", ip, scope);
result = curlx_inet_ntop(af, addr, ipstr, sizeof(ipstr));
curl_msnprintf(buf, buf_size, "%s%s", result ? "" : ipstr, scope);
break;
}
}
@ -188,7 +188,7 @@ if2ip_result_t Curl_if2ip(int af,
struct sockaddr_in *s;
curl_socket_t dummy;
size_t len;
const char *r;
CURLcode result;
#ifdef USE_IPV6
(void)remote_scope;
@ -228,10 +228,10 @@ if2ip_result_t Curl_if2ip(int af,
s = (struct sockaddr_in *)(void *)&req.ifr_addr;
memcpy(&in, &s->sin_addr, sizeof(in));
r = curlx_inet_ntop(s->sin_family, &in, buf, buf_size);
result = curlx_inet_ntop(s->sin_family, &in, buf, buf_size);
sclose(dummy);
if(!r)
if(result)
return IF2IP_NOT_FOUND;
return IF2IP_FOUND;
}

2
lib/urlapi.c
View file

@ -467,7 +467,7 @@ UNITTEST CURLUcode ipv6_parse(struct Curl_URL *u, char *hostname,
hostname[hlen] = 0; /* end the address there */
if(curlx_inet_pton(AF_INET6, hostname, dest) != 1)
return CURLUE_BAD_IPV6;
if(curlx_inet_ntop(AF_INET6, dest, hostname, hlen + 1)) {
if(!curlx_inet_ntop(AF_INET6, dest, hostname, hlen + 1)) {
hlen = strlen(hostname); /* might be shorter now */
hostname[hlen + 1] = 0;
}

2
lib/vdns/httpsrr.c
View file

@ -82,7 +82,7 @@ static CURLcode httpsrr_print_addr(struct dynbuf *dyn,
CURLcode result = CURLE_OK;
for(i = 0; (i < (total_len / alen)) && !result; ++i) {
if(!curlx_inet_ntop(ai_family, addr + (i * alen), buf, sizeof(buf)))
if(curlx_inet_ntop(ai_family, addr + (i * alen), buf, sizeof(buf)))
result = curlx_dyn_add(dyn, "<error parsing address>");
else
result = curlx_dyn_addf(dyn, "%s%s", sep, buf);