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

lib: xfer_setup simplify

Browse source 
Make variants for transfers that send/receive or do both with just the
parameters they need. Split out the shutdown setting into a separate
function. Only FTP bothers with that.

Closes #18203
This commit is contained in:
Stefan Eissing 2025-08-06 11:56:08 +02:00 • committed by Daniel Stenberg
parent 034612cd51
commit 6cebd35b4c
No known key found for this signature in database
GPG key ID: 5CC908FDB71E12C2
15 changed files with 104 additions and 109 deletions
Download patch file Download diff file Expand all files Collapse all files

109
lib/transfer.c
View file

@ -717,99 +717,94 @@ CURLcode Curl_retry_request(struct Curl_easy *data, char **url)
return CURLE_OK;
}
/*
* xfer_setup() is called to setup basic properties for the transfer.
*/
static void xfer_setup(
struct Curl_easy *data, /* transfer */
int sockindex, /* socket index to read from or -1 */
curl_off_t size, /* -1 if unknown at this point */
bool getheader, /* TRUE if header parsing is wanted */
int writesockindex, /* socket index to write to, it may be the same we
read from. -1 disables */
bool shutdown, /* shutdown connection at transfer end. Only
* supported when sending OR receiving. */
bool shutdown_err_ignore /* errors during shutdown do not fail the
* transfer */
int send_idx, /* sockindex to send on or -1 */
int recv_idx, /* sockindex to receive on or -1 */
curl_off_t recv_size, /* how much to receive, -1 if unknown */
bool getheader /* TRUE if header parsing is wanted */
)
{
struct SingleRequest *k = &data->req;
struct connectdata *conn = data->conn;
bool want_send = Curl_req_want_send(data);
DEBUGASSERT(conn != NULL);
DEBUGASSERT((sockindex <= 1) && (sockindex >= -1));
DEBUGASSERT((writesockindex <= 1) && (writesockindex >= -1));
DEBUGASSERT(!shutdown || (sockindex == -1) || (writesockindex == -1));
/* indexes are in range */
DEBUGASSERT((send_idx <= 1) && (send_idx >= -1));
DEBUGASSERT((recv_idx <= 1) && (recv_idx >= -1));
/* if request wants to send, switching off the send direction is wrong */
DEBUGASSERT((send_idx >= 0) || !Curl_req_want_send(data));
if(Curl_conn_is_multiplex(conn, FIRSTSOCKET) || want_send) {
/* when multiplexing, the read/write sockets need to be the same! */
if(want_send)
/* special and HTTP-specific */
writesockindex = FIRSTSOCKET;
conn->recv_idx = sockindex;
conn->send_idx = writesockindex;
}
else {
conn->recv_idx = sockindex;
conn->send_idx = writesockindex;
}
conn->send_idx = send_idx;
conn->recv_idx = recv_idx;
k->getheader = getheader;
k->size = size;
k->shutdown = shutdown;
k->shutdown_err_ignore = shutdown_err_ignore;
/* without receiving, there should be not recv_size */
DEBUGASSERT((conn->recv_idx >= 0) || (recv_size == -1));
k->size = recv_size;
/* by default, we do not shutdown at the end of the transfer */
k->shutdown = FALSE;
k->shutdown_err_ignore = FALSE;
/* The code sequence below is placed in this function just because all
necessary input is not always known in do_complete() as this function may
be called after that */
if(!k->getheader) {
k->header = FALSE;
if(size > 0)
Curl_pgrsSetDownloadSize(data, size);
if(recv_size > 0)
Curl_pgrsSetDownloadSize(data, recv_size);
}
/* we want header and/or body, if neither then do not do this! */
if(k->getheader || !data->req.no_body) {
if(sockindex != -1)
if(conn->recv_idx != -1)
k->keepon |= KEEP_RECV;
if(writesockindex != -1)
if(conn->send_idx != -1)
k->keepon |= KEEP_SEND;
} /* if(k->getheader || !data->req.no_body) */
}
CURL_TRC_M(data, "transfer setup: recv_idx=%d, send_idx=%d",
CURL_TRC_M(data, "xfer_setup: recv_idx=%d, send_idx=%d",
conn->recv_idx, conn->send_idx);
}
void Curl_xfer_setup_nop(struct Curl_easy *data)
{
xfer_setup(data, -1, -1, FALSE, -1, FALSE, FALSE);
xfer_setup(data, -1, -1, -1, FALSE);
}
void Curl_xfer_setup1(struct Curl_easy *data,
int send_recv,
curl_off_t recv_size,
bool getheader)
void Curl_xfer_setup_sendrecv(struct Curl_easy *data,
int sockindex,
curl_off_t recv_size,
bool getheader)
{
int recv_index = (send_recv & CURL_XFER_RECV) ? FIRSTSOCKET : -1;
int send_index = (send_recv & CURL_XFER_SEND) ? FIRSTSOCKET : -1;
DEBUGASSERT((recv_index >= 0) || (recv_size == -1));
xfer_setup(data, recv_index, recv_size, getheader, send_index, FALSE, FALSE);
xfer_setup(data, sockindex, sockindex, recv_size, getheader);
}
void Curl_xfer_setup2(struct Curl_easy *data,
int send_recv,
curl_off_t recv_size,
bool shutdown,
bool shutdown_err_ignore)
void Curl_xfer_setup_send(struct Curl_easy *data,
int sockindex)
{
int recv_index = (send_recv & CURL_XFER_RECV) ? SECONDARYSOCKET : -1;
int send_index = (send_recv & CURL_XFER_SEND) ? SECONDARYSOCKET : -1;
DEBUGASSERT((recv_index >= 0) || (recv_size == -1));
xfer_setup(data, recv_index, recv_size, FALSE, send_index,
shutdown, shutdown_err_ignore);
xfer_setup(data, sockindex, -1, -1, FALSE);
}
void Curl_xfer_setup_recv(struct Curl_easy *data,
int sockindex,
curl_off_t recv_size,
bool getheader)
{
xfer_setup(data, -1, sockindex, recv_size, getheader);
}
void Curl_xfer_set_shutdown(struct Curl_easy *data,
bool shutdown,
bool ignore_errors)
{
/* Shutdown should only be set when the transfer only sends or receives. */
DEBUGASSERT(!shutdown ||
(data->conn->send_idx < 0) || (data->conn->recv_idx < 0));
data->req.shutdown = shutdown;
data->req.shutdown_err_ignore = ignore_errors;
}
CURLcode Curl_xfer_write_resp(struct Curl_easy *data,