git-market/curl-curl
1
0
Fork 0
mirror of https://github.com/curl/curl.git synced 2026-04-11 12:01:42 +08:00
Code Issues Actions 14 Packages Projects Releases Wiki Activity

lib: turn state.url into a struct bufref

Browse Source 
Closes #19827
This commit is contained in:
Patrick Monnerat 2025-12-03 23:15:18 +01:00 committed by Daniel Stenberg
parent f39b8a1174
commit 36542b7349
No known key found for this signature in database
GPG Key ID: 5CC908FDB71E12C2
16 changed files with 67 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
lib/cookie.c
View File

@ -40,6 +40,7 @@
#include "rename.h"
#include "strdup.h"
#include "llist.h"
#include "bufref.h"
#include "curlx/strparse.h"
static void strstore(char **str, const char *newstr, size_t len);
@ -1622,7 +1623,7 @@ void Curl_flush_cookies(struct Curl_easy *data, bool cleanup)
set), as otherwise the cookies were not completely initialized and there
might be cookie files that were not loaded so saving the file is the wrong
thing. */
if(data->set.str[STRING_COOKIEJAR] && data->state.url) {
if(data->set.str[STRING_COOKIEJAR] && Curl_bufref_ptr(&data->state.url)) {
/* if we have a destination file for all the cookies to get dumped to */
CURLcode result = cookie_output(data, data->cookies,
data->set.str[STRING_COOKIEJAR]);

3
lib/curl_rtmp.c
View File

@ -33,6 +33,7 @@
#include "curlx/nonblock.h" /* for curlx_nonblock */
#include "progress.h" /* for Curl_pgrsSetUploadSize */
#include "transfer.h"
#include "bufref.h"
#include "curlx/warnless.h"
#include <curl/curl.h>
#include <librtmp/rtmp.h>
@ -233,7 +234,7 @@ static CURLcode rtmp_setup_connection(struct Curl_easy *data,
RTMP_Init(r);
RTMP_SetBufferMS(r, DEF_BUFTIME);
if(!RTMP_SetupURL(r, data->state.url))
if(!RTMP_SetupURL(r, CURL_UNCONST(Curl_bufref_ptr(&data->state.url))))
/* rtmp_conn_dtor() performs the cleanup */
return CURLE_URL_MALFORMAT;
return CURLE_OK;

12
lib/easy.c
View File

@ -75,6 +75,7 @@
#include "system_win32.h"
#include "http2.h"
#include "curlx/dynbuf.h"
#include "bufref.h"
#include "altsvc.h"
#include "hsts.h"
@ -975,6 +976,7 @@ CURL *curl_easy_duphandle(CURL *d)
Curl_hash_init(&outcurl->meta_hash, 23,
Curl_hash_str, curlx_str_key_compare, dupeasy_meta_freeentry);
curlx_dyn_init(&outcurl->state.headerb, CURL_MAX_HTTP_HEADER);
Curl_bufref_init(&outcurl->state.url);
Curl_netrc_init(&outcurl->state.netrc);
/* the connection pool is setup on demand */
@ -1014,12 +1016,10 @@ CURL *curl_easy_duphandle(CURL *d)
}
#endif
if(data->state.url) {
outcurl->state.url = curlx_strdup(data->state.url);
if(!outcurl->state.url)
goto fail;
outcurl->state.url_alloc = TRUE;
}
if(Curl_bufref_ptr(&data->state.url))
Curl_bufref_set(&outcurl->state.url,
curlx_strdup(Curl_bufref_ptr(&data->state.url)), 0,
curl_free);
if(data->state.referer) {
outcurl->state.referer = curlx_strdup(data->state.referer);

7
lib/getinfo.c
View File

@ -32,6 +32,7 @@
#include "vtls/vtls.h"
#include "connect.h" /* Curl_getconnectinfo() */
#include "progress.h"
#include "bufref.h"
#include "curlx/strparse.h"
/*
@ -91,8 +92,10 @@ static CURLcode getinfo_char(struct Curl_easy *data, CURLINFO info,
const char **param_charp)
{
switch(info) {
case CURLINFO_EFFECTIVE_URL:
*param_charp = data->state.url ? data->state.url : "";
case CURLINFO_EFFECTIVE_URL: {
const char *s = Curl_bufref_ptr(&data->state.url);
*param_charp = s ? s : "";
}
break;
case CURLINFO_EFFECTIVE_METHOD: {
const char *m = data->set.str[STRING_CUSTOMREQUEST];

22
lib/http.c
View File

@ -84,6 +84,7 @@
#include "altsvc.h"
#include "hsts.h"
#include "ws.h"
#include "bufref.h"
#include "curl_ctype.h"
#include "curlx/strparse.h"
@ -610,7 +611,8 @@ CURLcode Curl_http_auth_act(struct Curl_easy *data)
we must make sure to free it before allocating a new one. As figured
out in bug #2284386 */
curlx_free(data->req.newurl);
data->req.newurl = curlx_strdup(data->state.url); /* clone URL */
/* clone URL */
data->req.newurl = curlx_strdup(Curl_bufref_ptr(&data->state.url));
if(!data->req.newurl)
return CURLE_OUT_OF_MEMORY;
}
@ -623,7 +625,8 @@ CURLcode Curl_http_auth_act(struct Curl_easy *data)
we did not try HEAD or GET */
if((data->state.httpreq != HTTPREQ_GET) &&
(data->state.httpreq != HTTPREQ_HEAD)) {
data->req.newurl = curlx_strdup(data->state.url); /* clone URL */
/* clone URL */
data->req.newurl = curlx_strdup(Curl_bufref_ptr(&data->state.url));
if(!data->req.newurl)
return CURLE_OUT_OF_MEMORY;
data->state.authhost.done = TRUE;
@ -909,7 +912,7 @@ static CURLcode auth_spnego(struct Curl_easy *data,
&conn->http_negotiate_state;
if(!result) {
curlx_free(data->req.newurl);
data->req.newurl = curlx_strdup(data->state.url);
data->req.newurl = curlx_strdup(Curl_bufref_ptr(&data->state.url));
if(!data->req.newurl)
return CURLE_OUT_OF_MEMORY;
data->state.authproblem = FALSE;
@ -1243,7 +1246,8 @@ CURLcode Curl_http_follow(struct Curl_easy *data, const char *newurl,
if(!u)
return CURLE_OUT_OF_MEMORY;
uc = curl_url_set(u, CURLUPART_URL, data->state.url, 0);
uc = curl_url_set(u, CURLUPART_URL,
Curl_bufref_ptr(&data->state.url), 0);
if(!uc)
uc = curl_url_set(u, CURLUPART_FRAGMENT, NULL, 0);
if(!uc)
@ -1365,13 +1369,9 @@ CURLcode Curl_http_follow(struct Curl_easy *data, const char *newurl,
if(disallowport)
data->state.allow_port = FALSE;
if(data->state.url_alloc)
Curl_safefree(data->state.url);
data->state.url = follow_url;
data->state.url_alloc = TRUE;
Curl_bufref_set(&data->state.url, follow_url, 0, curl_free);
rewind_result = Curl_req_soft_reset(&data->req, data);
infof(data, "Issue another request to this URL: '%s'", data->state.url);
infof(data, "Issue another request to this URL: '%s'", follow_url);
if((data->set.http_follow_mode == CURLFOLLOW_FIRSTONLY) &&
data->set.str[STRING_CUSTOMREQUEST] &&
!data->state.http_ignorecustom) {
@ -4054,7 +4054,7 @@ static CURLcode http_on_response(struct Curl_easy *data,
data->state.disableexpect = TRUE;
Curl_req_abort_sending(data);
DEBUGASSERT(!data->req.newurl);
data->req.newurl = curlx_strdup(data->state.url);
data->req.newurl = curlx_strdup(Curl_bufref_ptr(&data->state.url));
if(!data->req.newurl) {
result = CURLE_OUT_OF_MEMORY;
goto out;

8
lib/http2.c
View File

@ -44,6 +44,7 @@
#include "rand.h"
#include "curlx/strparse.h"
#include "transfer.h"
#include "bufref.h"
#include "curlx/dynbuf.h"
#include "curlx/warnless.h"
#include "headers.h"
@ -920,10 +921,7 @@ fail:
if(rc)
return rc;
if(data->state.url_alloc)
curlx_free(data->state.url);
data->state.url_alloc = TRUE;
data->state.url = url;
Curl_bufref_set(&data->state.url, url, 0, curl_free);
return 0;
}
@ -2316,7 +2314,7 @@ static CURLcode h2_submit(struct h2_stream_ctx **pstream,
size_t acc = 0, i;
infof(data, "[HTTP/2] [%d] OPENED stream for %s",
stream_id, data->state.url);
stream_id, Curl_bufref_ptr(&data->state.url));
for(i = 0; i < nheader; ++i) {
acc += nva[i].namelen + nva[i].valuelen;

5
lib/ldap.c
View File

@ -89,6 +89,7 @@
#include "progress.h"
#include "transfer.h"
#include "curlx/strparse.h"
#include "bufref.h"
#include "curl_ldap.h"
#include "curlx/multibyte.h"
#include "curlx/base64.h"
@ -338,10 +339,10 @@ static CURLcode ldap_do(struct Curl_easy *data, bool *done)
*done = TRUE; /* unconditionally */
infof(data, "LDAP local: LDAP Vendor = %s ; LDAP Version = %d",
LDAP_VENDOR_NAME, LDAP_VENDOR_VERSION);
infof(data, "LDAP local: %s", data->state.url);
infof(data, "LDAP local: %s", Curl_bufref_ptr(&data->state.url));
#ifdef HAVE_LDAP_URL_PARSE
rc = ldap_url_parse(data->state.url, &ludp);
rc = ldap_url_parse(Curl_bufref_ptr(&data->state.url), &ludp);
#else
rc = ldap_url_parse_low(data, conn, &ludp);
#endif

5
lib/multi.c
View File

@ -53,6 +53,7 @@
#include "socketpair.h"
#include "socks.h"
#include "urlapi-int.h"
#include "bufref.h"
/* initial multi->xfers table size for a full multi */
#define CURL_XFER_TABLE_SIZE 512
@ -2006,7 +2007,7 @@ static CURLMcode state_performing(struct Curl_easy *data,
data->state.errorbuf = FALSE;
if(!newurl)
/* typically for HTTP_1_1_REQUIRED error on first flight */
newurl = curlx_strdup(data->state.url);
newurl = curlx_strdup(Curl_bufref_ptr(&data->state.url));
if(!newurl) {
result = CURLE_OUT_OF_MEMORY;
}
@ -4066,7 +4067,7 @@ static void multi_xfer_dump(struct Curl_multi *multi, uint32_t mid,
", url=%s\n",
mid,
(data->magic == CURLEASY_MAGIC_NUMBER) ? "GOOD" : "BAD!",
(void *)data, data->id, data->state.url);
(void *)data, data->id, Curl_bufref_ptr(&data->state.url));
}
}

5
lib/openldap.c
View File

@ -52,6 +52,7 @@
#include "connect.h"
#include "curl_sasl.h"
#include "strcase.h"
#include "bufref.h"
/*
* Uncommenting this will enable the built-in debug logging of the openldap
@ -272,7 +273,7 @@ static CURLcode oldap_url_parse(struct Curl_easy *data, LDAPURLDesc **ludp)
*ludp = NULL;
if(!data->state.up.user && !data->state.up.password &&
!data->state.up.options)
rc = ldap_url_parse(data->state.url, ludp);
rc = ldap_url_parse(Curl_bufref_ptr(&data->state.url), ludp);
if(rc != LDAP_URL_SUCCESS) {
const char *msg = "url parsing problem";
@ -988,7 +989,7 @@ static CURLcode oldap_do(struct Curl_easy *data, bool *done)
if(!li)
return CURLE_FAILED_INIT;
infof(data, "LDAP local: %s", data->state.url);
infof(data, "LDAP local: %s", Curl_bufref_ptr(&data->state.url));
result = oldap_url_parse(data, &lud);
if(result)

14
lib/setopt.c
View File

@ -54,6 +54,7 @@
#include "tftp.h"
#include "strdup.h"
#include "escape.h"
#include "bufref.h"
static CURLcode setopt_set_timeout_sec(timediff_t *ptimeout_ms, long secs)
{
@ -1971,12 +1972,8 @@ static CURLcode setopt_cptr(struct Curl_easy *data, CURLoption option,
/*
* The URL to fetch.
*/
if(data->state.url_alloc) {
Curl_safefree(data->state.url);
data->state.url_alloc = FALSE;
}
result = Curl_setstropt(&s->str[STRING_SET_URL], ptr);
data->state.url = s->str[STRING_SET_URL];
Curl_bufref_set(&data->state.url, s->str[STRING_SET_URL], 0, NULL);
break;
case CURLOPT_USERPWD:
@ -2063,12 +2060,7 @@ static CURLcode setopt_cptr(struct Curl_easy *data, CURLoption option,
/*
* pass CURLU to set URL
*/
if(data->state.url_alloc) {
Curl_safefree(data->state.url);
data->state.url_alloc = FALSE;
}
else
data->state.url = NULL;
Curl_bufref_free(&data->state.url);
Curl_safefree(s->str[STRING_SET_URL]);
s->uh = (CURLU *)ptr;
break;

11
lib/transfer.c
View File

@ -79,6 +79,7 @@
#include "hsts.h"
#include "setopt.h"
#include "headers.h"
#include "bufref.h"
#include "curlx/warnless.h"
#if !defined(CURL_DISABLE_HTTP) || !defined(CURL_DISABLE_SMTP) || \
@ -484,13 +485,7 @@ CURLcode Curl_pretransfer(struct Curl_easy *data)
}
}
/* since the URL may have been redirected in a previous use of this handle */
if(data->state.url_alloc) {
Curl_safefree(data->state.url);
data->state.url_alloc = FALSE;
}
data->state.url = data->set.str[STRING_SET_URL];
Curl_bufref_set(&data->state.url, data->set.str[STRING_SET_URL], 0, NULL);
if(data->set.postfields && data->set.set_resume_from) {
/* we cannot */
@ -676,7 +671,7 @@ CURLcode Curl_retry_request(struct Curl_easy *data, char **url)
}
infof(data, "Connection died, retrying a fresh connect (retry count: %d)",
data->state.retrycount);
*url = curlx_strdup(data->state.url);
*url = curlx_strdup(Curl_bufref_ptr(&data->state.url));
if(!*url)
return CURLE_OUT_OF_MEMORY;

37
lib/url.c
View File

@ -73,6 +73,7 @@
#include "netrc.h"
#include "formdata.h"
#include "mime.h"
#include "bufref.h"
#include "vtls/vtls.h"
#include "hostip.h"
#include "transfer.h"
@ -184,11 +185,7 @@ void Curl_freeset(struct Curl_easy *data)
data->state.referer_alloc = FALSE;
}
data->state.referer = NULL;
if(data->state.url_alloc) {
Curl_safefree(data->state.url);
data->state.url_alloc = FALSE;
}
data->state.url = NULL;
Curl_bufref_free(&data->state.url);
Curl_mime_cleanpart(&data->set.mimepost);
@ -516,6 +513,7 @@ CURLcode Curl_open(struct Curl_easy **curl)
Curl_hash_init(&data->meta_hash, 23,
Curl_hash_str, curlx_str_key_compare, easy_meta_freeentry);
curlx_dyn_init(&data->state.headerb, CURL_MAX_HTTP_HEADER);
Curl_bufref_init(&data->state.url);
Curl_req_init(&data->req);
Curl_initinfo(data);
#ifndef CURL_DISABLE_HTTP
@ -1769,22 +1767,19 @@ static CURLcode parseurlandfillconn(struct Curl_easy *data,
return CURLE_OUT_OF_MEMORY;
if(data->set.str[STRING_DEFAULT_PROTOCOL] &&
!Curl_is_absolute_url(data->state.url, NULL, 0, TRUE)) {
!Curl_is_absolute_url(Curl_bufref_ptr(&data->state.url), NULL, 0, TRUE)) {
char *url = curl_maprintf("%s://%s",
data->set.str[STRING_DEFAULT_PROTOCOL],
data->state.url);
Curl_bufref_ptr(&data->state.url));
if(!url)
return CURLE_OUT_OF_MEMORY;
if(data->state.url_alloc)
curlx_free(data->state.url);
data->state.url = url;
data->state.url_alloc = TRUE;
Curl_bufref_set(&data->state.url, url, 0, curl_free);
}
if(!use_set_uh) {
char *newurl;
uc = curl_url_set(uh, CURLUPART_URL, data->state.url, (unsigned int)
(CURLU_GUESS_SCHEME |
uc = curl_url_set(uh, CURLUPART_URL, Curl_bufref_ptr(&data->state.url),
(unsigned int) (CURLU_GUESS_SCHEME |
CURLU_NON_SUPPORT_SCHEME |
(data->set.disallow_username_in_url ?
CURLU_DISALLOW_USER : 0) |
@ -1798,10 +1793,7 @@ static CURLcode parseurlandfillconn(struct Curl_easy *data,
uc = curl_url_get(uh, CURLUPART_URL, &newurl, 0);
if(uc)
return Curl_uc_to_curlcode(uc);
if(data->state.url_alloc)
curlx_free(data->state.url);
data->state.url = newurl;
data->state.url_alloc = TRUE;
Curl_bufref_set(&data->state.url, newurl, 0, curl_free);
}
uc = curl_url_get(uh, CURLUPART_SCHEME, &data->state.up.scheme, 0);
@ -1855,8 +1847,7 @@ static CURLcode parseurlandfillconn(struct Curl_easy *data,
uc = curl_url_set(uh, CURLUPART_SCHEME, "https", 0);
if(uc)
return Curl_uc_to_curlcode(uc);
if(data->state.url_alloc)
Curl_safefree(data->state.url);
Curl_bufref_free(&data->state.url);
/* after update, get the updated version */
uc = curl_url_get(uh, CURLUPART_URL, &url, 0);
if(uc)
@ -1866,10 +1857,8 @@ static CURLcode parseurlandfillconn(struct Curl_easy *data,
curlx_free(url);
return Curl_uc_to_curlcode(uc);
}
data->state.url = url;
data->state.url_alloc = TRUE;
infof(data, "Switched from HTTP to HTTPS due to HSTS => %s",
data->state.url);
Curl_bufref_set(&data->state.url, url, 0, curl_free);
infof(data, "Switched from HTTP to HTTPS due to HSTS => %s", url);
}
}
#endif
@ -3396,7 +3385,7 @@ static CURLcode create_conn(struct Curl_easy *data,
/*************************************************************
* Check input data
*************************************************************/
if(!data->state.url) {
if(!Curl_bufref_ptr(&data->state.url)) {
result = CURLE_URL_MALFORMAT;
goto out;
}

4
lib/urldata.h
View File

@ -154,6 +154,7 @@ typedef unsigned int curl_prot_t;
#include "hash.h"
#include "splay.h"
#include "curlx/dynbuf.h"
#include "bufref.h"
#include "dynhds.h"
#include "request.h"
#include "ratelimit.h"
@ -1025,7 +1026,7 @@ struct UrlState {
void *in; /* CURLOPT_READDATA */
CURLU *uh; /* URL handle for the current parsed URL */
struct urlpieces up;
char *url; /* work URL, copied from UserDefined */
struct bufref url; /* work URL, initially copied from UserDefined */
char *referer; /* referer string */
struct curl_slist *resolve; /* set to point to the set.resolve list when
this should be dealt with in pretransfer */
@ -1122,7 +1123,6 @@ struct UrlState {
#ifdef CURL_LIST_ONLY_PROTOCOL
BIT(list_only); /* list directory contents */
#endif
BIT(url_alloc); /* URL string is malloc()'ed */
BIT(referer_alloc); /* referer string is malloc()ed */
BIT(wildcard_resolve); /* Set to true if any resolve change is a wildcard */
BIT(upload); /* upload request */

3
lib/vquic/curl_ngtcp2.c
View File

@ -61,6 +61,7 @@
#include "../select.h"
#include "../curlx/inet_pton.h"
#include "../transfer.h"
#include "../bufref.h"
#include "vquic.h"
#include "vquic_int.h"
#include "vquic-tls.h"
@ -1631,7 +1632,7 @@ static CURLcode h3_stream_open(struct Curl_cfilter *cf,
if(Curl_trc_is_verbose(data)) {
infof(data, "[HTTP/3] [%" PRId64 "] OPENED stream for %s",
stream->id, data->state.url);
stream->id, Curl_bufref_ptr(&data->state.url));
for(i = 0; i < nheader; ++i) {
infof(data, "[HTTP/3] [%" PRId64 "] [%.*s: %.*s]", stream->id,
(int)nva[i].namelen, nva[i].name,

3
lib/vquic/curl_osslq.c
View File

@ -54,6 +54,7 @@
#include "../vtls/openssl.h"
#include "curl_osslq.h"
#include "../url.h"
#include "../bufref.h"
#include "../curlx/warnless.h"
#include "../curlx/strerr.h"
@ -1985,7 +1986,7 @@ static CURLcode h3_stream_open(struct Curl_cfilter *cf,
if(Curl_trc_is_verbose(data)) {
infof(data, "[HTTP/3] [%" PRId64 "] OPENED stream for %s",
stream->s.id, data->state.url);
stream->s.id, Curl_bufref_ptr(&data->state.url));
for(i = 0; i < nheader; ++i) {
infof(data, "[HTTP/3] [%" PRId64 "] [%.*s: %.*s]",
stream->s.id,

7
lib/vquic/curl_quiche.c
View File

@ -46,6 +46,7 @@
#include "curl_quiche.h"
#include "../transfer.h"
#include "../url.h"
#include "../bufref.h"
#include "../curlx/inet_pton.h"
#include "../curlx/warnless.h"
#include "../vtls/openssl.h"
@ -1023,8 +1024,8 @@ static CURLcode h3_open_stream(struct Curl_cfilter *cf,
goto out;
}
else {
CURL_TRC_CF(data, cf, "send_request(%s) -> %" PRId64,
data->state.url, rv);
CURL_TRC_CF(data, cf, "send_request(%s) -> %" PRIu64,
Curl_bufref_ptr(&data->state.url), rv);
}
result = CURLE_SEND_ERROR;
goto out;
@ -1038,7 +1039,7 @@ static CURLcode h3_open_stream(struct Curl_cfilter *cf,
if(Curl_trc_is_verbose(data)) {
infof(data, "[HTTP/3] [%" PRIu64 "] OPENED stream for %s",
stream->id, data->state.url);
stream->id, Curl_bufref_ptr(&data->state.url));
for(i = 0; i < nheader; ++i) {
infof(data, "[HTTP/3] [%" PRIu64 "] [%.*s: %.*s]", stream->id,
(int)nva[i].name_len, nva[i].name,