mirrors/cmake
2
0 Fork 0
mirror of https://gitlab.kitware.com/cmake/cmake.git synced 2026-10-08 23:44:00 +03:00
Code Activity

curl 2026-04-29 (a05f3497)

Browse Source 
Code extracted from:

    https://github.com/curl/curl.git

at commit a05f34973e6c4bb629d018f7cb51487be1c904d8 (curl-8_20_0).
This commit is contained in:
Curl Upstream authored and Brad King committed 2026-04-29 14:17:42 -04:00
1 parent c709040e9d
commit fe97809d5a
279 files changed
+14206 -10525
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

lib/httpsrr.c
+145 -43
View File
@@ -30,6 +30,7 @@
#include "connect.h"
#include "curl_trc.h"
#include "curlx/strdup.h"
#include "curlx/inet_ntop.h"
static CURLcode httpsrr_decode_alpn(const uint8_t *cp, size_t len,
unsigned char *alpns)
@@ -68,71 +69,164 @@ static CURLcode httpsrr_decode_alpn(const uint8_t *cp, size_t len,
return CURLE_OK;
}
CURLcode Curl_httpsrr_set(struct Curl_easy *data,
struct Curl_https_rrinfo *hi,
#ifdef CURLVERBOSE
static CURLcode httpsrr_print_addr(struct dynbuf *dyn,
int ai_family,
const uint8_t *addr,
size_t total_len)
{
char buf[MAX_IPADR_LEN];
size_t i, alen = (ai_family == AF_INET6) ? 16 : 4;
const char *sep = "";
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)))
result = curlx_dyn_add(dyn, "<error parsing address>");
else
result = curlx_dyn_addf(dyn, "%s%s", sep, buf);
sep = ",";
}
return result;
}
void Curl_httpsrr_trace(struct Curl_easy *data,
struct Curl_https_rrinfo *rr)
{
struct dynbuf tmp;
CURLcode result;
if(!rr || !rr->complete) {
CURL_TRC_DNS(data, "[HTTPS-RR] not available");
return;
}
curlx_dyn_init(&tmp, 1024);
result = Curl_httpsrr_print(&tmp, rr);
if(!result)
CURL_TRC_DNS(data, "HTTPS-RR: %s", curlx_dyn_ptr(&tmp));
else
CURL_TRC_DNS(data, "Error printing HTTPS-RR information");
curlx_dyn_free(&tmp);
}
CURLcode Curl_httpsrr_print(struct dynbuf *tmp,
struct Curl_https_rrinfo *rr)
{
CURLcode result;
int i;
curlx_dyn_reset(tmp);
result = curlx_dyn_addf(tmp, "%u %s", rr->priority,
rr->target ? rr->target : ".");
if(!result && rr->mandatory)
result = curlx_dyn_add(tmp, " mandatory-keys(ignored)");
if(!result && rr->alpns[0]) {
const char *sep = "", *name;
result = curlx_dyn_add(tmp, " alpn=");
for(i = 0; !result && (i < 4); ++i) {
switch(rr->alpns[i]) {
case ALPN_h1:
name = "http/1.1";
break;
case ALPN_h2:
name = "h2";
break;
case ALPN_h3:
name = "h3";
break;
default:
name = NULL;
}
if(name) {
result = curlx_dyn_addf(tmp, "%s%s", sep, name);
sep = ",";
}
}
}
if(!result && rr->port_set) {
result = curlx_dyn_addf(tmp, " port=%u", rr->port);
}
if(!result && rr->no_def_alpn)
result = curlx_dyn_add(tmp, " no-default-alpn");
if(!result && rr->ipv6hints_len) {
result = curlx_dyn_add(tmp, " ipv6hint=");
if(!result)
result = httpsrr_print_addr(
tmp, AF_INET6, rr->ipv6hints, rr->ipv6hints_len);
}
if(!result && rr->ipv4hints_len) {
result = curlx_dyn_add(tmp, " ipv4hint=");
if(!result)
result = httpsrr_print_addr(
tmp, AF_INET, rr->ipv4hints, rr->ipv4hints_len);
}
if(!result && rr->echconfiglist_len)
result = curlx_dyn_addf(tmp, " ech=<%zu bytes>", rr->echconfiglist_len);
return result;
}
#endif /* CURLVERBOSE */
CURLcode Curl_httpsrr_set(struct Curl_https_rrinfo *rr,
uint16_t rrkey, const uint8_t *val, size_t vlen)
{
CURLcode result = CURLE_OK;
switch(rrkey) {
case HTTPS_RR_CODE_MANDATORY:
CURL_TRC_DNS(data, "HTTPS RR MANDATORY left to implement");
rr->mandatory = TRUE;
break;
case HTTPS_RR_CODE_ALPN: /* str_list */
result = httpsrr_decode_alpn(val, vlen, hi->alpns);
CURL_TRC_DNS(data, "HTTPS RR ALPN: %u %u %u %u",
hi->alpns[0], hi->alpns[1], hi->alpns[2], hi->alpns[3]);
result = httpsrr_decode_alpn(val, vlen, rr->alpns);
break;
case HTTPS_RR_CODE_NO_DEF_ALPN:
if(vlen) /* no data */
return CURLE_BAD_FUNCTION_ARGUMENT;
hi->no_def_alpn = TRUE;
CURL_TRC_DNS(data, "HTTPS RR no-def-alpn");
rr->no_def_alpn = TRUE;
break;
case HTTPS_RR_CODE_IPV4: /* addr4 list */
if(!vlen || (vlen & 3)) /* the size must be 4-byte aligned */
return CURLE_BAD_FUNCTION_ARGUMENT;
curlx_free(hi->ipv4hints);
hi->ipv4hints = curlx_memdup(val, vlen);
if(!hi->ipv4hints)
curlx_free(rr->ipv4hints);
rr->ipv4hints = curlx_memdup(val, vlen);
if(!rr->ipv4hints)
return CURLE_OUT_OF_MEMORY;
hi->ipv4hints_len = vlen;
CURL_TRC_DNS(data, "HTTPS RR IPv4");
rr->ipv4hints_len = vlen;
break;
case HTTPS_RR_CODE_ECH:
if(!vlen)
return CURLE_BAD_FUNCTION_ARGUMENT;
curlx_free(hi->echconfiglist);
hi->echconfiglist = curlx_memdup(val, vlen);
if(!hi->echconfiglist)
curlx_free(rr->echconfiglist);
rr->echconfiglist = curlx_memdup(val, vlen);
if(!rr->echconfiglist)
return CURLE_OUT_OF_MEMORY;
hi->echconfiglist_len = vlen;
CURL_TRC_DNS(data, "HTTPS RR ECH");
rr->echconfiglist_len = vlen;
break;
case HTTPS_RR_CODE_IPV6: /* addr6 list */
if(!vlen || (vlen & 15)) /* the size must be 16-byte aligned */
return CURLE_BAD_FUNCTION_ARGUMENT;
curlx_free(hi->ipv6hints);
hi->ipv6hints = curlx_memdup(val, vlen);
if(!hi->ipv6hints)
curlx_free(rr->ipv6hints);
rr->ipv6hints = curlx_memdup(val, vlen);
if(!rr->ipv6hints)
return CURLE_OUT_OF_MEMORY;
hi->ipv6hints_len = vlen;
CURL_TRC_DNS(data, "HTTPS RR IPv6");
rr->ipv6hints_len = vlen;
break;
case HTTPS_RR_CODE_PORT:
if(vlen != 2)
return CURLE_BAD_FUNCTION_ARGUMENT;
hi->port = (unsigned short)((val[0] << 8) | val[1]);
CURL_TRC_DNS(data, "HTTPS RR port %u", hi->port);
rr->port = (uint16_t)((val[0] << 8) | val[1]);
rr->port_set = TRUE;
break;
default:
CURL_TRC_DNS(data, "HTTPS RR unknown code");
/* unknown code */
break;
}
return result;
}
struct Curl_https_rrinfo *
Curl_httpsrr_dup_move(struct Curl_https_rrinfo *rrinfo)
struct Curl_https_rrinfo *Curl_httpsrr_dup_move(
struct Curl_https_rrinfo *rrinfo)
{
struct Curl_https_rrinfo *dup = curlx_memdup(rrinfo, sizeof(*rrinfo));
if(dup)
@@ -142,17 +236,27 @@ Curl_httpsrr_dup_move(struct Curl_https_rrinfo *rrinfo)
void Curl_httpsrr_cleanup(struct Curl_https_rrinfo *rrinfo)
{
Curl_safefree(rrinfo->target);
Curl_safefree(rrinfo->echconfiglist);
Curl_safefree(rrinfo->ipv4hints);
Curl_safefree(rrinfo->ipv6hints);
Curl_safefree(rrinfo->rrname);
curlx_safefree(rrinfo->target);
curlx_safefree(rrinfo->echconfiglist);
curlx_safefree(rrinfo->ipv4hints);
curlx_safefree(rrinfo->ipv6hints);
curlx_safefree(rrinfo->rrname);
rrinfo->complete = FALSE;
}
bool Curl_httpsrr_applicable(struct Curl_easy *data,
const struct Curl_https_rrinfo *rr)
{
if(!data->conn || !rr)
return FALSE;
return (!rr->target || !rr->target[0] ||
(rr->target[0] == '.' && !rr->target[1])) &&
(!rr->port_set || rr->port == data->conn->remote_port);
}
#ifdef USE_ARES
static CURLcode httpsrr_opt(struct Curl_easy *data,
const ares_dns_rr_t *rr,
static CURLcode httpsrr_opt(const ares_dns_rr_t *rr,
ares_dns_rr_key_t key, size_t idx,
struct Curl_https_rrinfo *hinfo)
{
@@ -161,11 +265,10 @@ static CURLcode httpsrr_opt(struct Curl_easy *data,
size_t len = 0;
code = ares_dns_rr_get_opt(rr, key, idx, &val, &len);
return Curl_httpsrr_set(data, hinfo, code, val, len);
return Curl_httpsrr_set(hinfo, code, val, len);
}
CURLcode Curl_httpsrr_from_ares(struct Curl_easy *data,
const ares_dns_record_t *dnsrec,
CURLcode Curl_httpsrr_from_ares(const ares_dns_record_t *dnsrec,
struct Curl_https_rrinfo *hinfo)
{
CURLcode result = CURLE_OK;
@@ -188,19 +291,18 @@ CURLcode Curl_httpsrr_from_ares(struct Curl_easy *data,
result = CURLE_OUT_OF_MEMORY;
goto out;
}
CURL_TRC_DNS(data, "HTTPS RR target: %s", hinfo->target);
}
CURL_TRC_DNS(data, "HTTPS RR priority: %u",
ares_dns_rr_get_u16(rr, ARES_RR_HTTPS_PRIORITY));
hinfo->priority = ares_dns_rr_get_u16(rr, ARES_RR_HTTPS_PRIORITY);
for(opt = 0; opt < ares_dns_rr_get_opt_cnt(rr, ARES_RR_HTTPS_PARAMS);
opt++) {
result = httpsrr_opt(data, rr, ARES_RR_HTTPS_PARAMS, opt, hinfo);
result = httpsrr_opt(rr, ARES_RR_HTTPS_PARAMS, opt, hinfo);
if(result)
break;
}
}
out:
Curl_safefree(hinfo->rrname);
hinfo->complete = !result;
curlx_safefree(hinfo->rrname);
return result;
}