Changelog
+Daniel S (31 Jan 2008)
+- Dmitry Kurochkin moved several struct fields from the connectdata struct to
+ the SingleRequest one to make pipelining better. It is a bit tricky to keep
+ them in the right place, to keep things related to the actual request or to
+ the actual connection in the right place.
+
Daniel S (29 Jan 2008)
- Dmitry Kurochkin fixed Curl_done() for pipelining, as it could previously
crash!
/* If we have selected NOBODY and HEADER, it means that we only want file
information. Which for FILE can't be much more than the file size and
date. */
- if(conn->bits.no_body && data->set.include_header && fstated) {
+ if(data->set.opt_no_body && data->set.include_header && fstated) {
CURLcode result;
snprintf(buf, sizeof(data->state.buffer),
"Content-Length: %" FORMAT_OFF_T "\r\n", expected_size);
/* If we have selected NOBODY and HEADER, it means that we only want file
information. Which in FTP can't be much more than the file size and
date. */
- if(conn->bits.no_body && ftpc->file &&
+ if(data->set.opt_no_body && ftpc->file &&
ftp_need_type(conn, data->set.prefer_ascii)) {
/* The SIZE command is _not_ RFC 959 specified, and therefor many servers
may not support it! It is however the only way we have to get a file's
/* If we asked for a time of the file and we actually got one as well,
we "emulate" a HTTP-style header in our output. */
- if(conn->bits.no_body &&
+ if(data->set.opt_no_body &&
ftpc->file &&
data->set.get_filetime &&
(data->info.filetime>=0) ) {
DEBUGF(infof(conn->data, "DO phase starts\n"));
- if(conn->bits.no_body) {
+ if(conn->data->set.opt_no_body) {
/* requested no body means no transfer... */
struct FTP *ftp = conn->data->state.proto.ftp;
ftp->transfer = FTPTRANSFER_INFO;
return 0;
/* make sure that a HTTP request is never sent away chunked! */
- conn->bits.forbidchunk = (bool)(http->sending == HTTPSEND_REQUEST);
+ conn->data->req.forbidchunk = (bool)(http->sending == HTTPSEND_REQUEST);
if(http->postsize <= (curl_off_t)fullsize) {
memcpy(buffer, http->postdata, (size_t)http->postsize);
if(data->set.str[STRING_CUSTOMREQUEST])
request = data->set.str[STRING_CUSTOMREQUEST];
else {
- if(conn->bits.no_body)
+ if(data->set.opt_no_body)
request = (char *)"HEAD";
else {
DEBUGASSERT((httpreq > HTTPREQ_NONE) && (httpreq < HTTPREQ_LAST));
ptr = checkheaders(data, "Transfer-Encoding:");
if(ptr) {
/* Some kind of TE is requested, check if 'chunked' is chosen */
- conn->bits.upload_chunky =
+ data->req.upload_chunky =
Curl_compareheader(ptr, "Transfer-Encoding:", "chunked");
}
else {
- if(httpreq == HTTPREQ_GET)
- conn->bits.upload_chunky = FALSE;
- if(conn->bits.upload_chunky)
+ if((conn->protocol&PROT_HTTP) &&
+ data->set.upload &&
+ (data->set.infilesize == -1) &&
+ (data->set.httpversion != CURL_HTTP_VERSION_1_0)) {
+ /* HTTP, upload, unknown file size and not HTTP 1.0 */
+ data->req.upload_chunky = TRUE;
+ }
+ else {
+ /* else, no chunky upload */
+ data->req.upload_chunky = FALSE;
+ }
+
+ if(data->req.upload_chunky)
te = "Transfer-Encoding: chunked\r\n";
}
http->sending = HTTPSEND_BODY;
- if(!conn->bits.upload_chunky) {
+ if(!data->req.upload_chunky) {
/* only add Content-Length if not uploading chunked */
result = add_bufferf(req_buffer,
"Content-Length: %" FORMAT_OFF_T "\r\n",
else
postsize = data->set.infilesize;
- if((postsize != -1) && !conn->bits.upload_chunky) {
+ if((postsize != -1) && !data->req.upload_chunky) {
/* only add Content-Length if not uploading chunked */
result = add_bufferf(req_buffer,
"Content-Length: %" FORMAT_OFF_T "\r\n",
data->set.postfieldsize:
(data->set.postfields? (curl_off_t)strlen(data->set.postfields):0);
- if(!conn->bits.upload_chunky) {
+ if(!data->req.upload_chunky) {
/* We only set Content-Length and allow a custom Content-Length if
we don't upload data chunked, as RFC2616 forbids us to set both
kinds of headers (Transfer-Encoding: chunked and Content-Length) */
if(result)
return result;
- if(!conn->bits.upload_chunky) {
+ if(!data->req.upload_chunky) {
/* We're not sending it 'chunked', append it to the request
already now to reduce the number if send() calls */
result = add_buffer(req_buffer, data->set.postfields,
if(*datap == 0x0a) {
/* we're now expecting data to come, unless size was zero! */
if(0 == ch->datasize) {
- if(conn->bits.trailerhdrpresent!=TRUE) {
+ if(k->trailerhdrpresent!=TRUE) {
/* No Trailer: header found - revert to original Curl processing */
ch->state = CHUNK_STOPCR;
size_t buffersize = (size_t)bytes;
int nread;
- if(conn->bits.upload_chunky) {
+ if(data->req.upload_chunky) {
/* if chunked Transfer-Encoding */
buffersize -= (8 + 2 + 2); /* 32bit hex + CRLF + CRLF */
data->req.upload_fromhere += 10; /* 32bit hex + CRLF */
/* the read function returned a too large value */
return CURLE_READ_ERROR;
- if(!conn->bits.forbidchunk && conn->bits.upload_chunky) {
+ if(!data->req.forbidchunk && data->req.upload_chunky) {
/* if chunked Transfer-Encoding */
char hexbuffer[11];
int hexlen = snprintf(hexbuffer, sizeof(hexbuffer),
else {
k->header = FALSE; /* no more header to parse! */
- if((k->size == -1) && !conn->bits.chunk && !conn->bits.close &&
+ if((k->size == -1) && !k->chunk && !conn->bits.close &&
(k->httpversion >= 11) ) {
/* On HTTP 1.1, when connection is not to get closed, but no
Content-Length nor Content-Encoding chunked have been
* If we requested a "no body", this is a good time to get
* out and return home.
*/
- if(conn->bits.no_body)
+ if(data->set.opt_no_body)
stop_reading = TRUE;
else {
/* If we know the expected size of this document, we set the
Content-Length: headers if we are now receiving data
using chunked Transfer-Encoding.
*/
- if(conn->bits.chunk)
+ if(k->chunk)
k->size=-1;
}
* with the previously mentioned size. There can be any amount
* of chunks, and a chunk-data set to zero signals the
* end-of-chunks. */
- conn->bits.chunk = TRUE; /* chunks coming our way */
+ k->chunk = TRUE; /* chunks coming our way */
/* init our chunky engine */
Curl_httpchunk_init(conn);
*
* It seems both Trailer: and Trailers: occur in the wild.
*/
- conn->bits.trailerhdrpresent = TRUE;
+ k->trailerhdrpresent = TRUE;
}
else if(checkprefix("Content-Encoding:", k->p) &&
}
#ifndef CURL_DISABLE_HTTP
- if(conn->bits.chunk) {
+ if(k->chunk) {
/*
* Here comes a chunked transfer flying and we need to decode this
* properly. While the name says read, this function both reads
Curl_pgrsSetDownloadCounter(data, k->bytecount);
- if(!conn->bits.chunk && (nread || k->badheader || is_empty_data)) {
+ if(!k->chunk && (nread || k->badheader || is_empty_data)) {
/* If this is chunky transfer, it was already written */
if(k->badheader && !k->ignorebody) {
* returning.
*/
- if(!(conn->bits.no_body) && (k->size != -1) &&
+ if(!(data->set.opt_no_body) && (k->size != -1) &&
(k->bytecount != k->size) &&
#ifdef CURL_DO_LINEEND_CONV
/* Most FTP servers don't adjust their file SIZE response for CRLFs,
k->size - k->bytecount);
return CURLE_PARTIAL_FILE;
}
- else if(!(conn->bits.no_body) &&
- conn->bits.chunk &&
+ else if(!(data->set.opt_no_body) &&
+ k->chunk &&
(conn->chunk.state != CHUNK_STOP)) {
/*
* In chunked mode, return an error if the connection is closed prior to
return CURLE_OK;
/* we want header and/or body, if neither then don't do this! */
- if(!conn->bits.getheader && conn->bits.no_body)
+ if(!k->getheader && data->set.opt_no_body)
return CURLE_OK;
while(!done) {
if((data->req.bytecount +
data->req.headerbytecount == 0) &&
conn->bits.reuse &&
- !conn->bits.no_body) {
+ !data->set.opt_no_body) {
/* We got no data, we attempted to re-use a connection and yet we want a
"body". This might happen if the connection was left alive when we were
done using it before, but that was closed when we wanted to read from
CURL_SOCKET_BAD : conn->sock[sockindex];
conn->writesockfd = writesockindex == -1 ?
CURL_SOCKET_BAD:conn->sock[writesockindex];
- conn->bits.getheader = getheader;
+ k->getheader = getheader;
k->size = size;
k->bytecountp = bytecountp;
necessary input is not always known in do_complete() as this function may
be called after that */
- if(!conn->bits.getheader) {
+ if(!k->getheader) {
k->header = FALSE;
if(size > 0)
Curl_pgrsSetDownloadSize(data, size);
}
/* we want header and/or body, if neither then don't do this! */
- if(conn->bits.getheader || !conn->bits.no_body) {
+ if(k->getheader || !data->set.opt_no_body) {
if(conn->sockfd != CURL_SOCKET_BAD) {
k->keepon |= KEEP_READ;
conn->bits.user_passwd = (bool)(NULL != data->set.str[STRING_USERPWD]);
conn->bits.proxy_user_passwd = (bool)(NULL != data->set.str[STRING_PROXYUSERPWD]);
- conn->bits.no_body = data->set.opt_no_body;
conn->bits.tunnel_proxy = data->set.tunnel_thru_httpproxy;
conn->bits.ftp_use_epsv = data->set.ftp_use_epsv;
conn->bits.ftp_use_eprt = data->set.ftp_use_eprt;
else
free(old_conn->host.rawalloc); /* free the newly allocated name buffer */
- /* get the newly set value, not the old one */
- conn->bits.no_body = old_conn->bits.no_body;
-
/* re-use init */
conn->bits.reuse = TRUE; /* yes, we're re-using here */
conn->seek_func = data->set.seek_func;
conn->seek_client = data->set.seek_client;
- if((conn->protocol&PROT_HTTP) &&
- data->set.upload &&
- (data->set.infilesize == -1) &&
- (data->set.httpversion != CURL_HTTP_VERSION_1_0)) {
- /* HTTP, upload, unknown file size and not HTTP 1.0 */
- conn->bits.upload_chunky = TRUE;
- }
- else {
- /* else, no chunky upload */
- conn->bits.upload_chunky = FALSE;
- }
-
#ifndef USE_ARES
/*************************************************************
* Set timeout if that is being used, and we're not using an asynchronous
*/
static void do_complete(struct connectdata *conn)
{
- conn->bits.chunk=FALSE;
- conn->bits.trailerhdrpresent=FALSE;
+ conn->data->req.chunk=FALSE;
+ conn->data->req.trailerhdrpresent=FALSE;
conn->data->req.maxfd = (conn->sockfd>conn->writesockfd?
conn->sockfd:conn->writesockfd)+1;
struct ConnectBits {
bool close; /* if set, we close the connection after this request */
bool reuse; /* if set, this is a re-used connection */
- bool chunk; /* if set, this is a chunked transfer-encoding */
bool proxy; /* if set, this transfer is done through a proxy - any type */
bool httpproxy; /* if set, this transfer is done through a http proxy */
bool user_passwd; /* do we use user+password for this connection? */
bool do_more; /* this is set TRUE if the ->curl_do_more() function is
supposed to be called, after ->curl_do() */
- bool upload_chunky; /* set TRUE if we are doing chunked transfer-encoding
- on upload */
- bool getheader; /* TRUE if header parsing is wanted */
-
- bool forbidchunk; /* used only to explicitly forbid chunk-upload for
- specific upload buffers. See readmoredata() in
- http.c for details. */
-
bool tcpconnect; /* the TCP layer (or simimlar) is connected, this is set
the first time on the first connect function call */
bool protoconnstart;/* the protocol layer has STARTED its operation after
bool retry; /* this connection is about to get closed and then
re-attempted at another connection. */
- bool no_body; /* CURLOPT_NO_BODY (or similar) was set */
bool tunnel_proxy; /* if CONNECT is used to "tunnel" through the proxy.
This is implicit when SSL-protocols are used through
proxies, but can also be enabled explicitly by
requests */
bool netrc; /* name+password provided by netrc */
- bool trailerhdrpresent; /* Set when Trailer: header found in HTTP response.
- Required to determine whether to look for trailers
- in case of Transfer-Encoding: chunking */
bool done; /* set to FALSE when Curl_do() is called and set to TRUE
when Curl_done() is called, to prevent Curl_done() to
get invoked twice when the multi interface is
and the 'upload_present' contains the number of bytes available at this
position */
char *upload_fromhere;
+
+ bool chunk; /* if set, this is a chunked transfer-encoding */
+ bool upload_chunky; /* set TRUE if we are doing chunked transfer-encoding
+ on upload */
+ bool getheader; /* TRUE if header parsing is wanted */
+
+ bool forbidchunk; /* used only to explicitly forbid chunk-upload for
+ specific upload buffers. See readmoredata() in
+ http.c for details. */
+ bool trailerhdrpresent; /* Set when Trailer: header found in HTTP response.
+ Required to determine whether to look for trailers
+ in case of Transfer-Encoding: chunking */
};
/*
projects / platform / upstream / curl.git / commitdiff