moparisthebest/curl
1
0
Fork 0
mirror of https://github.com/moparisthebest/curl synced 2024-12-21 23:58:49 -05:00
Code Issues Releases Wiki Activity

struct HandleData is now called struct SingleRequest, and is only for data that

Browse Source 
is inited at the start of the DO action. I removed the Curl_transfer_keeper
struct completely, and I had to move out a few struct members (that had to
be set before DO or used after DONE) to the UrlState struct. The SingleRequest
struct is accessed with SessionHandle->req.

One of the biggest reasons for doing this was the bunch of duplicate struct
members in HandleData and Curl_transfer_keeper since it was really messy to
keep track of two variables with the same name and basically the same purpose!
This commit is contained in:
Daniel Stenberg 2007-11-24 23:16:55 +00:00
parent 5b809a3104
commit 13648f8ccd
16 changed files with 398 additions and 436 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
lib/content_encoding.c
View File

@ -77,7 +77,7 @@ exit_zlib(z_stream *z, zlibInitState *zlib_init, CURLcode result)
static CURLcode
inflate_stream(struct connectdata *conn,
struct Curl_transfer_keeper *k)
struct SingleRequest *k)
{
int allow_restart = 1;
z_stream *z = &k->z; /* zlib state structure */
@ -152,7 +152,7 @@ inflate_stream(struct connectdata *conn,
CURLcode
Curl_unencode_deflate_write(struct connectdata *conn,
struct Curl_transfer_keeper *k,
struct SingleRequest *k,
ssize_t nread)
{
z_stream *z = &k->z; /* zlib state structure */
@ -265,7 +265,7 @@ static enum {
CURLcode
Curl_unencode_gzip_write(struct connectdata *conn,
struct Curl_transfer_keeper *k,
struct SingleRequest *k,
ssize_t nread)
{
z_stream *z = &k->z; /* zlib state structure */

6
lib/content_encoding.h
View File

@ -5,7 +5,7 @@
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
* Copyright (C) 1998 - 2006, Daniel Stenberg, <daniel@haxx.se>, et al.
* Copyright (C) 1998 - 2007, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
@ -32,10 +32,10 @@
#endif
CURLcode Curl_unencode_deflate_write(struct connectdata *conn,
struct Curl_transfer_keeper *k,
struct SingleRequest *req,
ssize_t nread);
CURLcode
Curl_unencode_gzip_write(struct connectdata *conn,
struct Curl_transfer_keeper *k,
struct SingleRequest *k,
ssize_t nread);

4
lib/dict.c
View File

@ -155,8 +155,8 @@ static CURLcode Curl_dict(struct connectdata *conn, bool *done)
struct SessionHandle *data=conn->data;
curl_socket_t sockfd = conn->sock[FIRSTSOCKET];
char *path = data->reqdata.path;
curl_off_t *bytecount = &data->reqdata.keep.bytecount;
char *path = data->state.path;
curl_off_t *bytecount = &data->req.bytecount;
*done = TRUE; /* unconditionally */

12
lib/easy.c
View File

@ -528,9 +528,9 @@ void Curl_easy_addmulti(struct SessionHandle *data,
void Curl_easy_initHandleData(struct SessionHandle *data)
{
memset(&data->reqdata, 0, sizeof(struct HandleData));
memset(&data->req, 0, sizeof(struct SingleRequest));
data->reqdata.maxdownload = -1;
data->req.maxdownload = -1;
}
/*
@ -676,11 +676,11 @@ void curl_easy_reset(CURL *curl)
{
struct SessionHandle *data = (struct SessionHandle *)curl;
Curl_safefree(data->reqdata.pathbuffer);
data->reqdata.pathbuffer=NULL;
Curl_safefree(data->state.pathbuffer);
data->state.pathbuffer=NULL;
Curl_safefree(data->reqdata.proto.generic);
data->reqdata.proto.generic=NULL;
Curl_safefree(data->state.proto.generic);
data->state.proto.generic=NULL;
/* zero out UserDefined data: */
Curl_freeset(data);

46
lib/file.c
View File

@ -127,7 +127,7 @@ const struct Curl_handler Curl_handler_file = {
static CURLcode Curl_file_connect(struct connectdata *conn, bool *done)
{
struct SessionHandle *data = conn->data;
char *real_path = curl_easy_unescape(data, data->reqdata.path, 0, NULL);
char *real_path = curl_easy_unescape(data, data->state.path, 0, NULL);
struct FILEPROTO *file;
int fd;
#if defined(WIN32) || defined(MSDOS) || defined(__EMX__)
@ -142,17 +142,17 @@ static CURLcode Curl_file_connect(struct connectdata *conn, bool *done)
sessionhandle, deal with it */
Curl_reset_reqproto(conn);
if(!data->reqdata.proto.file) {
if(!data->state.proto.file) {
file = (struct FILEPROTO *)calloc(sizeof(struct FILEPROTO), 1);
if(!file) {
free(real_path);
return CURLE_OUT_OF_MEMORY;
}
data->reqdata.proto.file = file;
data->state.proto.file = file;
}
else {
/* file is not a protocol that can deal with "persistancy" */
file = data->reqdata.proto.file;
file = data->state.proto.file;
Curl_safefree(file->freepath);
if(file->fd != -1)
close(file->fd);
@ -200,7 +200,7 @@ static CURLcode Curl_file_connect(struct connectdata *conn, bool *done)
file->fd = fd;
if(!data->set.upload && (fd == -1)) {
failf(data, "Couldn't open file %s", data->reqdata.path);
failf(data, "Couldn't open file %s", data->state.path);
Curl_file_done(conn, CURLE_FILE_COULDNT_READ_FILE, FALSE);
return CURLE_FILE_COULDNT_READ_FILE;
}
@ -212,7 +212,7 @@ static CURLcode Curl_file_connect(struct connectdata *conn, bool *done)
static CURLcode Curl_file_done(struct connectdata *conn,
CURLcode status, bool premature)
{
struct FILEPROTO *file = conn->data->reqdata.proto.file;
struct FILEPROTO *file = conn->data->state.proto.file;
(void)status; /* not used */
(void)premature; /* not used */
Curl_safefree(file->freepath);
@ -231,7 +231,7 @@ static CURLcode Curl_file_done(struct connectdata *conn,
static CURLcode file_upload(struct connectdata *conn)
{
struct FILEPROTO *file = conn->data->reqdata.proto.file;
struct FILEPROTO *file = conn->data->state.proto.file;
const char *dir = strchr(file->path, DIRSEP);
FILE *fp;
CURLcode res=CURLE_OK;
@ -250,7 +250,7 @@ static CURLcode file_upload(struct connectdata *conn)
*/
conn->fread_func = data->set.fread_func;
conn->fread_in = data->set.in;
conn->data->reqdata.upload_fromhere = buf;
conn->data->req.upload_fromhere = buf;
if(!dir)
return CURLE_FILE_COULDNT_READ_FILE; /* fix: better error code */
@ -258,7 +258,7 @@ static CURLcode file_upload(struct connectdata *conn)
if(!dir[1])
return CURLE_FILE_COULDNT_READ_FILE; /* fix: better error code */
if(data->reqdata.resume_from)
if(data->state.resume_from)
fp = fopen( file->path, "ab" );
else {
int fd;
@ -287,14 +287,14 @@ static CURLcode file_upload(struct connectdata *conn)
Curl_pgrsSetUploadSize(data, data->set.infilesize);
/* treat the negative resume offset value as the case of "-" */
if(data->reqdata.resume_from < 0){
if(data->state.resume_from < 0){
if(stat(file->path, &file_stat)){
fclose(fp);
failf(data, "Can't get the size of %s", file->path);
return CURLE_WRITE_ERROR;
}
else
data->reqdata.resume_from = (curl_off_t)file_stat.st_size;
data->state.resume_from = (curl_off_t)file_stat.st_size;
}
while(res == CURLE_OK) {
@ -309,16 +309,16 @@ static CURLcode file_upload(struct connectdata *conn)
nread = (size_t)readcount;
/*skip bytes before resume point*/
if(data->reqdata.resume_from) {
if( (curl_off_t)nread <= data->reqdata.resume_from ) {
data->reqdata.resume_from -= nread;
if(data->state.resume_from) {
if( (curl_off_t)nread <= data->state.resume_from ) {
data->state.resume_from -= nread;
nread = 0;
buf2 = buf;
}
else {
buf2 = buf + data->reqdata.resume_from;
nread -= data->reqdata.resume_from;
data->reqdata.resume_from = 0;
buf2 = buf + data->state.resume_from;
nread -= data->state.resume_from;
data->state.resume_from = 0;
}
}
else
@ -385,7 +385,7 @@ static CURLcode Curl_file(struct connectdata *conn, bool *done)
return file_upload(conn);
/* get the fd from the connection phase */
fd = conn->data->reqdata.proto.file->fd;
fd = conn->data->state.proto.file->fd;
/* VMS: This only works reliable for STREAMLF files */
if( -1 != fstat(fd, &statbuf)) {
@ -434,8 +434,8 @@ static CURLcode Curl_file(struct connectdata *conn, bool *done)
return result;
}
if(data->reqdata.resume_from <= expected_size)
expected_size -= data->reqdata.resume_from;
if(data->state.resume_from <= expected_size)
expected_size -= data->state.resume_from;
else {
failf(data, "failed to resume file:// transfer");
return CURLE_BAD_DOWNLOAD_RESUME;
@ -451,9 +451,9 @@ static CURLcode Curl_file(struct connectdata *conn, bool *done)
if(fstated)
Curl_pgrsSetDownloadSize(data, expected_size);
if(data->reqdata.resume_from) {
if(data->reqdata.resume_from !=
lseek(fd, data->reqdata.resume_from, SEEK_SET))
if(data->state.resume_from) {
if(data->state.resume_from !=
lseek(fd, data->state.resume_from, SEEK_SET))
return CURLE_BAD_DOWNLOAD_RESUME;
}

157
lib/ftp.c
View File

@ -482,7 +482,7 @@ static CURLcode ftp_readresp(curl_socket_t sockfd,
int clipamount = 0;
bool restart = FALSE;
data->reqdata.keep.headerbytecount += gotbytes;
data->req.headerbytecount += gotbytes;
ftpc->nread_resp += gotbytes;
for(i = 0; i < gotbytes; ptr++, i++) {
@ -788,7 +788,7 @@ static void state(struct connectdata *conn,
static CURLcode ftp_state_user(struct connectdata *conn)
{
CURLcode result;
struct FTP *ftp = conn->data->reqdata.proto.ftp;
struct FTP *ftp = conn->data->state.proto.ftp;
/* send USER */
NBFTPSENDF(conn, "USER %s", ftp->user?ftp->user:"");
@ -1313,7 +1313,7 @@ static CURLcode ftp_state_use_pasv(struct connectdata *conn)
static CURLcode ftp_state_post_rest(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct FTP *ftp = conn->data->reqdata.proto.ftp;
struct FTP *ftp = conn->data->state.proto.ftp;
struct SessionHandle *data = conn->data;
if(ftp->transfer != FTPTRANSFER_BODY) {
@ -1337,7 +1337,7 @@ static CURLcode ftp_state_post_rest(struct connectdata *conn)
static CURLcode ftp_state_post_size(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct FTP *ftp = conn->data->reqdata.proto.ftp;
struct FTP *ftp = conn->data->state.proto.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if((ftp->transfer != FTPTRANSFER_BODY) && ftpc->file) {
@ -1358,7 +1358,7 @@ static CURLcode ftp_state_post_size(struct connectdata *conn)
static CURLcode ftp_state_post_type(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct FTP *ftp = conn->data->reqdata.proto.ftp;
struct FTP *ftp = conn->data->state.proto.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if((ftp->transfer == FTPTRANSFER_INFO) && ftpc->file) {
@ -1398,11 +1398,11 @@ static CURLcode ftp_state_post_listtype(struct connectdata *conn)
lstArg = NULL;
if((data->set.ftp_filemethod == FTPFILE_NOCWD) &&
data->reqdata.path &&
data->reqdata.path[0] &&
strchr(data->reqdata.path,'/')) {
data->state.path &&
data->state.path[0] &&
strchr(data->state.path,'/')) {
lstArg = strdup(data->reqdata.path);
lstArg = strdup(data->state.path);
if(!lstArg)
return CURLE_OUT_OF_MEMORY;
@ -1465,7 +1465,7 @@ static CURLcode ftp_state_post_stortype(struct connectdata *conn)
static CURLcode ftp_state_post_mdtm(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct FTP *ftp = conn->data->reqdata.proto.ftp;
struct FTP *ftp = conn->data->state.proto.ftp;
struct SessionHandle *data = conn->data;
struct ftp_conn *ftpc = &conn->proto.ftpc;
@ -1522,13 +1522,13 @@ static CURLcode ftp_state_ul_setup(struct connectdata *conn,
bool sizechecked)
{
CURLcode result = CURLE_OK;
struct FTP *ftp = conn->data->reqdata.proto.ftp;
struct FTP *ftp = conn->data->state.proto.ftp;
struct SessionHandle *data = conn->data;
struct ftp_conn *ftpc = &conn->proto.ftpc;
curl_off_t passed=0;
if((data->reqdata.resume_from && !sizechecked) ||
((data->reqdata.resume_from > 0) && sizechecked)) {
if((data->state.resume_from && !sizechecked) ||
((data->state.resume_from > 0) && sizechecked)) {
/* we're about to continue the uploading of a file */
/* 1. get already existing file's size. We use the SIZE command for this
which may not exist in the server! The SIZE command is not in
@ -1542,7 +1542,7 @@ static CURLcode ftp_state_ul_setup(struct connectdata *conn,
/* 4. lower the infilesize counter */
/* => transfer as usual */
if(data->reqdata.resume_from < 0 ) {
if(data->state.resume_from < 0 ) {
/* Got no given size to start from, figure it out */
NBFTPSENDF(conn, "SIZE %s", ftpc->file);
state(conn, FTP_STOR_SIZE);
@ -1559,7 +1559,7 @@ static CURLcode ftp_state_ul_setup(struct connectdata *conn,
/* TODO: allow the ioctlfunction to provide a fast forward function that
can be used here and use this method only as a fallback! */
do {
curl_off_t readthisamountnow = (data->reqdata.resume_from - passed);
curl_off_t readthisamountnow = (data->state.resume_from - passed);
curl_off_t actuallyread;
if(readthisamountnow > BUFSIZE)
@ -1575,11 +1575,11 @@ static CURLcode ftp_state_ul_setup(struct connectdata *conn,
" bytes from the input", passed);
return CURLE_FTP_COULDNT_USE_REST;
}
} while(passed != data->reqdata.resume_from);
} while(passed != data->state.resume_from);
/* now, decrease the size of the read */
if(data->set.infilesize>0) {
data->set.infilesize -= data->reqdata.resume_from;
data->set.infilesize -= data->state.resume_from;
if(data->set.infilesize <= 0) {
infof(data, "File already completely uploaded\n");
@ -1612,7 +1612,7 @@ static CURLcode ftp_state_quote(struct connectdata *conn,
{
CURLcode result = CURLE_OK;
struct SessionHandle *data = conn->data;
struct FTP *ftp = data->reqdata.proto.ftp;
struct FTP *ftp = data->state.proto.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
bool quote=FALSE;
struct curl_slist *item;
@ -1907,13 +1907,13 @@ static CURLcode ftp_state_pasv_resp(struct connectdata *conn,
* FTP pointer
*/
struct HTTP http_proxy;
struct FTP *ftp_save = data->reqdata.proto.ftp;
struct FTP *ftp_save = data->state.proto.ftp;
memset(&http_proxy, 0, sizeof(http_proxy));
data->reqdata.proto.http = &http_proxy;
data->state.proto.http = &http_proxy;
result = Curl_proxyCONNECT(conn, SECONDARYSOCKET, newhost, newport);
data->reqdata.proto.ftp = ftp_save;
data->state.proto.ftp = ftp_save;
if(CURLE_OK != result)
return result;
@ -1963,7 +1963,7 @@ static CURLcode ftp_state_mdtm_resp(struct connectdata *conn,
{
CURLcode result = CURLE_OK;
struct SessionHandle *data=conn->data;
struct FTP *ftp = data->reqdata.proto.ftp;
struct FTP *ftp = data->state.proto.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
switch(ftpcode) {
@ -2095,7 +2095,7 @@ static CURLcode ftp_state_post_retr_size(struct connectdata *conn,
{
CURLcode result = CURLE_OK;
struct SessionHandle *data=conn->data;
struct FTP *ftp = data->reqdata.proto.ftp;
struct FTP *ftp = data->state.proto.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if(data->set.max_filesize && (filesize > data->set.max_filesize)) {
@ -2104,7 +2104,7 @@ static CURLcode ftp_state_post_retr_size(struct connectdata *conn,
}
ftp->downloadsize = filesize;
if(data->reqdata.resume_from) {
if(data->state.resume_from) {
/* We always (attempt to) get the size of downloads, so it is done before
this even when not doing resumes. */
if(filesize == -1) {
@ -2117,28 +2117,28 @@ static CURLcode ftp_state_post_retr_size(struct connectdata *conn,
else {
/* We got a file size report, so we check that there actually is a
part of the file left to get, or else we go home. */
if(data->reqdata.resume_from< 0) {
if(data->state.resume_from< 0) {
/* We're supposed to download the last abs(from) bytes */
if(filesize < -data->reqdata.resume_from) {
if(filesize < -data->state.resume_from) {
failf(data, "Offset (%" FORMAT_OFF_T
") was beyond file size (%" FORMAT_OFF_T ")",
data->reqdata.resume_from, filesize);
data->state.resume_from, filesize);
return CURLE_BAD_DOWNLOAD_RESUME;
}
/* convert to size to download */
ftp->downloadsize = -data->reqdata.resume_from;
ftp->downloadsize = -data->state.resume_from;
/* download from where? */
data->reqdata.resume_from = filesize - ftp->downloadsize;
data->state.resume_from = filesize - ftp->downloadsize;
}
else {
if(filesize < data->reqdata.resume_from) {
if(filesize < data->state.resume_from) {
failf(data, "Offset (%" FORMAT_OFF_T
") was beyond file size (%" FORMAT_OFF_T ")",
data->reqdata.resume_from, filesize);
data->state.resume_from, filesize);
return CURLE_BAD_DOWNLOAD_RESUME;
}
/* Now store the number of bytes we are expected to download */
ftp->downloadsize = filesize-data->reqdata.resume_from;
ftp->downloadsize = filesize-data->state.resume_from;
}
}
@ -2156,9 +2156,9 @@ static CURLcode ftp_state_post_retr_size(struct connectdata *conn,
/* Set resume file transfer offset */
infof(data, "Instructs server to resume from offset %" FORMAT_OFF_T
"\n", data->reqdata.resume_from);
"\n", data->state.resume_from);
NBFTPSENDF(conn, "REST %" FORMAT_OFF_T, data->reqdata.resume_from);
NBFTPSENDF(conn, "REST %" FORMAT_OFF_T, data->state.resume_from);
state(conn, FTP_RETR_REST);
@ -2202,7 +2202,7 @@ static CURLcode ftp_state_size_resp(struct connectdata *conn,
result = ftp_state_post_retr_size(conn, filesize);
}
else if(instate == FTP_STOR_SIZE) {
data->reqdata.resume_from = filesize;
data->state.resume_from = filesize;
result = ftp_state_ul_setup(conn, TRUE);
}
@ -2250,7 +2250,7 @@ static CURLcode ftp_state_stor_resp(struct connectdata *conn,
{
CURLcode result = CURLE_OK;
struct SessionHandle *data = conn->data;
struct FTP *ftp = data->reqdata.proto.ftp;
struct FTP *ftp = data->state.proto.ftp;
if(ftpcode>=400) {
failf(data, "Failed FTP upload: %0d", ftpcode);
@ -2297,7 +2297,7 @@ static CURLcode ftp_state_get_resp(struct connectdata *conn,
{
CURLcode result = CURLE_OK;
struct SessionHandle *data = conn->data;
struct FTP *ftp = data->reqdata.proto.ftp;
struct FTP *ftp = data->state.proto.ftp;
char *buf = data->state.buffer;
if((ftpcode == 150) || (ftpcode == 125)) {
@ -2384,10 +2384,10 @@ static CURLcode ftp_state_get_resp(struct connectdata *conn,
return result;
}
if(size > data->reqdata.maxdownload && data->reqdata.maxdownload > 0)
size = data->reqdata.size = data->reqdata.maxdownload;
if(size > data->req.maxdownload && data->req.maxdownload > 0)
size = data->req.size = data->req.maxdownload;
infof(data, "Maxdownload = %" FORMAT_OFF_T "\n", data->reqdata.maxdownload);
infof(data, "Maxdownload = %" FORMAT_OFF_T "\n", data->req.maxdownload);
if(instate != FTP_LIST)
infof(data, "Getting file with size: %" FORMAT_OFF_T "\n", size);
@ -2465,7 +2465,7 @@ static CURLcode ftp_state_user_resp(struct connectdata *conn,
{
CURLcode result = CURLE_OK;
struct SessionHandle *data = conn->data;
struct FTP *ftp = data->reqdata.proto.ftp;
struct FTP *ftp = data->state.proto.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
(void)instate; /* no use for this yet */
@ -3009,17 +3009,17 @@ static CURLcode ftp_init(struct connectdata *conn)
{
struct SessionHandle *data = conn->data;
struct FTP *ftp;
if(data->reqdata.proto.ftp)
if(data->state.proto.ftp)
return CURLE_OK;
ftp = (struct FTP *)calloc(sizeof(struct FTP), 1);
if(!ftp)
return CURLE_OUT_OF_MEMORY;
data->reqdata.proto.ftp = ftp;
data->state.proto.ftp = ftp;
/* get some initial data into the ftp struct */
ftp->bytecountp = &data->reqdata.keep.bytecount;
ftp->bytecountp = &data->req.bytecount;
/* no need to duplicate them, this connectdata struct won't change */
ftp->user = conn->user;
@ -3076,14 +3076,14 @@ static CURLcode Curl_ftp_connect(struct connectdata *conn,
* Curl_proxyCONNECT we have to set back the member to the original struct
* FTP pointer
*/
ftp_save = data->reqdata.proto.ftp;
ftp_save = data->state.proto.ftp;
memset(&http_proxy, 0, sizeof(http_proxy));
data->reqdata.proto.http = &http_proxy;
data->state.proto.http = &http_proxy;
result = Curl_proxyCONNECT(conn, FIRSTSOCKET,
conn->host.name, conn->remote_port);
data->reqdata.proto.ftp = ftp_save;
data->state.proto.ftp = ftp_save;
if(CURLE_OK != result)
return result;
@ -3129,15 +3129,14 @@ static CURLcode Curl_ftp_done(struct connectdata *conn, CURLcode status,
bool premature)
{
struct SessionHandle *data = conn->data;
struct FTP *ftp = data->reqdata.proto.ftp;
struct FTP *ftp = data->state.proto.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
ssize_t nread;
int ftpcode;
CURLcode result=CURLE_OK;
bool was_ctl_valid = ftpc->ctl_valid;
char *path;
char *path_to_use = data->reqdata.path;
struct Curl_transfer_keeper *k = &data->reqdata.keep;
char *path_to_use = data->state.path;
if(!ftp)
/* When the easy handle is removed from the multi while libcurl is still
@ -3281,22 +3280,24 @@ static CURLcode Curl_ftp_done(struct connectdata *conn, CURLcode status,
}
}
else {
if((-1 != k->size) && (k->size != *ftp->bytecountp) &&
if((-1 != data->req.size) &&
(data->req.size != *ftp->bytecountp) &&
#ifdef CURL_DO_LINEEND_CONV
/* Most FTP servers don't adjust their file SIZE response for CRLFs, so
* we'll check to see if the discrepancy can be explained by the number
* of CRLFs we've changed to LFs.
*/
((k->size + data->state.crlf_conversions) != *ftp->bytecountp) &&
((data->req.size + data->state.crlf_conversions) !=
*ftp->bytecountp) &&
#endif /* CURL_DO_LINEEND_CONV */
(k->maxdownload != *ftp->bytecountp)) {
(data->req.maxdownload != *ftp->bytecountp)) {
failf(data, "Received only partial file: %" FORMAT_OFF_T " bytes",
*ftp->bytecountp);
result = CURLE_PARTIAL_FILE;
}
else if(!ftpc->dont_check &&
!*ftp->bytecountp &&
(k->size>0)) {
(data->req.size>0)) {
failf(data, "No data was received!");
result = CURLE_FTP_COULDNT_RETR_FILE;
}
@ -3426,8 +3427,8 @@ static CURLcode ftp_range(struct connectdata *conn)
struct SessionHandle *data = conn->data;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if(data->reqdata.use_range && data->reqdata.range) {
from=curlx_strtoofft(data->reqdata.range, &ptr, 0);
if(data->state.use_range && data->state.range) {
from=curlx_strtoofft(data->state.range, &ptr, 0);
while(ptr && *ptr && (ISSPACE(*ptr) || (*ptr=='-')))
ptr++;
to=curlx_strtoofft(ptr, &ptr2, 0);
@ -3437,34 +3438,34 @@ static CURLcode ftp_range(struct connectdata *conn)
}
if((-1 == to) && (from>=0)) {
/* X - */
data->reqdata.resume_from = from;
data->state.resume_from = from;
DEBUGF(infof(conn->data, "FTP RANGE %" FORMAT_OFF_T " to end of file\n",
from));
}
else if(from < 0) {
/* -Y */
totalsize = -from;
data->reqdata.maxdownload = -from;
data->reqdata.resume_from = from;
data->req.maxdownload = -from;
data->state.resume_from = from;
DEBUGF(infof(conn->data, "FTP RANGE the last %" FORMAT_OFF_T " bytes\n",
totalsize));
}
else {
/* X-Y */
totalsize = to-from;
data->reqdata.maxdownload = totalsize+1; /* include last byte */
data->reqdata.resume_from = from;
data->req.maxdownload = totalsize+1; /* include last byte */
data->state.resume_from = from;
DEBUGF(infof(conn->data, "FTP RANGE from %" FORMAT_OFF_T
" getting %" FORMAT_OFF_T " bytes\n",
from, data->reqdata.maxdownload));
from, data->req.maxdownload));
}
DEBUGF(infof(conn->data, "range-download from %" FORMAT_OFF_T
" to %" FORMAT_OFF_T ", totally %" FORMAT_OFF_T " bytes\n",
from, to, data->reqdata.maxdownload));
from, to, data->req.maxdownload));
ftpc->dont_check = TRUE; /* dont check for successful transfer */
}
else
data->reqdata.maxdownload = -1;
data->req.maxdownload = -1;
return CURLE_OK;
}
@ -3483,7 +3484,7 @@ static CURLcode Curl_ftp_nextconnect(struct connectdata *conn)
CURLcode result = CURLE_OK;
/* the ftp struct is inited in Curl_ftp_connect() */
struct FTP *ftp = data->reqdata.proto.ftp;
struct FTP *ftp = data->state.proto.ftp;
DEBUGF(infof(data, "DO-MORE phase starts\n"));
@ -3558,7 +3559,7 @@ CURLcode ftp_perform(struct connectdata *conn,
if(conn->bits.no_body) {
/* requested no body means no transfer... */
struct FTP *ftp = conn->data->reqdata.proto.ftp;
struct FTP *ftp = conn->data->state.proto.ftp;
ftp->transfer = FTPTRANSFER_INFO;
}
@ -3840,11 +3841,11 @@ CURLcode ftp_parse_url_path(struct connectdata *conn)
{
struct SessionHandle *data = conn->data;
/* the ftp struct is already inited in ftp_connect() */
struct FTP *ftp = data->reqdata.proto.ftp;
struct FTP *ftp = data->state.proto.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
size_t dlen;
char *slash_pos; /* position of the first '/' char in curpos */
char *path_to_use = data->reqdata.path;
char *path_to_use = data->state.path;
char *cur_pos;
cur_pos = path_to_use; /* current position in path. point at the begin
@ -3864,10 +3865,10 @@ CURLcode ftp_parse_url_path(struct connectdata *conn)
the first condition in the if() right here, is there just in case
someone decides to set path to NULL one day
*/
if(data->reqdata.path &&
data->reqdata.path[0] &&
(data->reqdata.path[strlen(data->reqdata.path) - 1] != '/') )
ftpc->file = data->reqdata.path; /* this is a full file path */
if(data->state.path &&
data->state.path[0] &&
(data->state.path[strlen(data->state.path) - 1] != '/') )
ftpc->file = data->state.path; /* this is a full file path */
else
ftpc->file = NULL;
/*
@ -3924,7 +3925,7 @@ CURLcode ftp_parse_url_path(struct connectdata *conn)
/* parse the URL path into separate path components */
while((slash_pos = strchr(cur_pos, '/')) != NULL) {
/* 1 or 0 to indicate absolute directory */
bool absolute_dir = (bool)((cur_pos - data->reqdata.path > 0) &&
bool absolute_dir = (bool)((cur_pos - data->state.path > 0) &&
(ftpc->dirdepth == 0));
/* seek out the next path component */
@ -3995,7 +3996,7 @@ CURLcode ftp_parse_url_path(struct connectdata *conn)
if(ftpc->prevpath) {
/* prevpath is "raw" so we convert the input path before we compare the
strings */
char *path = curl_easy_unescape(conn->data, data->reqdata.path, 0, NULL);
char *path = curl_easy_unescape(conn->data, data->state.path, 0, NULL);
if(!path) {
freedirs(ftpc);
return CURLE_OUT_OF_MEMORY;
@ -4018,7 +4019,7 @@ static CURLcode ftp_dophase_done(struct connectdata *conn,
bool connected)
{
CURLcode result = CURLE_OK;
struct FTP *ftp = conn->data->reqdata.proto.ftp;
struct FTP *ftp = conn->data->state.proto.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if(connected)
@ -4078,7 +4079,7 @@ CURLcode ftp_regular_transfer(struct connectdata *conn,
bool connected=0;
struct SessionHandle *data = conn->data;
struct ftp_conn *ftpc = &conn->proto.ftpc;
data->reqdata.size = -1; /* make sure this is unknown at this point */
data->req.size = -1; /* make sure this is unknown at this point */
Curl_pgrsSetUploadCounter(data, 0);
Curl_pgrsSetDownloadCounter(data, 0);
@ -4134,11 +4135,11 @@ static CURLcode Curl_ftp_setup_connection(struct connectdata * conn)
#endif
}
data->reqdata.path++; /* don't include the initial slash */
data->state.path++; /* don't include the initial slash */
/* FTP URLs support an extension like ";type=<typecode>" that
* we'll try to get now! */
type = strstr(data->reqdata.path, ";type=");
type = strstr(data->state.path, ";type=");
if(!type)
type = strstr(conn->host.rawalloc, ";type=");

132
lib/http.c
View File

@ -275,8 +275,7 @@ static bool pickoneauth(struct auth *pick)
static CURLcode perhapsrewind(struct connectdata *conn)
{
struct SessionHandle *data = conn->data;
struct HTTP *http = data->reqdata.proto.http;
struct Curl_transfer_keeper *k = &data->reqdata.keep;
struct HTTP *http = data->state.proto.http;
curl_off_t bytessent;
curl_off_t expectsend = -1; /* default is unknown */
@ -338,7 +337,7 @@ static CURLcode perhapsrewind(struct connectdata *conn)
/* This is not NTLM or NTLM with many bytes left to send: close
*/
conn->bits.close = TRUE;
k->size = 0; /* don't download any more than 0 bytes */
data->req.size = 0; /* don't download any more than 0 bytes */
}
if(bytessent)
@ -361,7 +360,7 @@ CURLcode Curl_http_auth_act(struct connectdata *conn)
bool pickproxy = FALSE;
CURLcode code = CURLE_OK;
if(100 == data->reqdata.keep.httpcode)
if(100 == data->req.httpcode)
/* this is a transient response code, ignore */
return CURLE_OK;
@ -369,23 +368,23 @@ CURLcode Curl_http_auth_act(struct connectdata *conn)
return data->set.http_fail_on_error?CURLE_HTTP_RETURNED_ERROR:CURLE_OK;
if(conn->bits.user_passwd &&
((data->reqdata.keep.httpcode == 401) ||
(conn->bits.authneg && data->reqdata.keep.httpcode < 300))) {
((data->req.httpcode == 401) ||
(conn->bits.authneg && data->req.httpcode < 300))) {
pickhost = pickoneauth(&data->state.authhost);
if(!pickhost)
data->state.authproblem = TRUE;
}
if(conn->bits.proxy_user_passwd &&
((data->reqdata.keep.httpcode == 407) ||
(conn->bits.authneg && data->reqdata.keep.httpcode < 300))) {
((data->req.httpcode == 407) ||
(conn->bits.authneg && data->req.httpcode < 300))) {
pickproxy = pickoneauth(&data->state.authproxy);
if(!pickproxy)
data->state.authproblem = TRUE;
}
if(pickhost || pickproxy) {
data->reqdata.newurl = strdup(data->change.url); /* clone URL */
if(!data->reqdata.newurl)
data->req.newurl = strdup(data->change.url); /* clone URL */
if(!data->req.newurl)
return CURLE_OUT_OF_MEMORY;
if((data->set.httpreq != HTTPREQ_GET) &&
@ -397,7 +396,7 @@ CURLcode Curl_http_auth_act(struct connectdata *conn)
}
}
else if((data->reqdata.keep.httpcode < 300) &&
else if((data->req.httpcode < 300) &&
(!data->state.authhost.done) &&
conn->bits.authneg) {
/* no (known) authentication available,
@ -406,15 +405,15 @@ CURLcode Curl_http_auth_act(struct connectdata *conn)
we didn't try HEAD or GET */
if((data->set.httpreq != HTTPREQ_GET) &&
(data->set.httpreq != HTTPREQ_HEAD)) {
data->reqdata.newurl = strdup(data->change.url); /* clone URL */
if(!data->reqdata.newurl)
data->req.newurl = strdup(data->change.url); /* clone URL */
if(!data->req.newurl)
return CURLE_OUT_OF_MEMORY;
data->state.authhost.done = TRUE;
}
}
if(Curl_http_should_fail(conn)) {
failf (data, "The requested URL returned error: %d",
data->reqdata.keep.httpcode);
data->req.httpcode);
code = CURLE_HTTP_RETURNED_ERROR;
}
@ -660,8 +659,8 @@ CURLcode Curl_http_input_auth(struct connectdata *conn,
/* if exactly this is wanted, go */
int neg = Curl_input_negotiate(conn, (bool)(httpcode == 407), start);
if(neg == 0) {
data->reqdata.newurl = strdup(data->change.url);
data->state.authproblem = (data->reqdata.newurl == NULL);
data->req.newurl = strdup(data->change.url);
data->state.authproblem = (data->req.newurl == NULL);
}
else {
infof(data, "Authentication problem. Ignoring this.\n");
@ -743,16 +742,13 @@ CURLcode Curl_http_input_auth(struct connectdata *conn,
int Curl_http_should_fail(struct connectdata *conn)
{
struct SessionHandle *data;
struct Curl_transfer_keeper *k;
int httpcode;
DEBUGASSERT(conn);
data = conn->data;
DEBUGASSERT(data);
/*
** For readability
*/
k = &data->reqdata.keep;
httpcode = data->req.httpcode;
/*
** If we haven't been asked to fail on error,
@ -764,12 +760,12 @@ int Curl_http_should_fail(struct connectdata *conn)
/*
** Any code < 400 is never terminal.
*/
if(k->httpcode < 400)
if(httpcode < 400)
return 0;
if(data->reqdata.resume_from &&
(data->set.httpreq==HTTPREQ_GET) &&
(k->httpcode == 416)) {
if(data->state.resume_from &&
(data->set.httpreq==HTTPREQ_GET) &&
(httpcode == 416)) {
/* "Requested Range Not Satisfiable", just proceed and
pretend this is no error */
return 0;
@ -779,14 +775,14 @@ int Curl_http_should_fail(struct connectdata *conn)
** Any code >= 400 that's not 401 or 407 is always
** a terminal error
*/
if((k->httpcode != 401) &&
(k->httpcode != 407))
if((httpcode != 401) &&
(httpcode != 407))
return 1;
/*
** All we have left to deal with is 401 and 407
*/
DEBUGASSERT((k->httpcode == 401) || (k->httpcode == 407));
DEBUGASSERT((httpcode == 401) || (httpcode == 407));
/*
** Examine the current authentication state to see if this
@ -807,7 +803,8 @@ int Curl_http_should_fail(struct connectdata *conn)
infof(data,"%s: authavail = 0x%08x\n",__FUNCTION__,data->state.authavail);
infof(data,"%s: httpcode = %d\n",__FUNCTION__,k->httpcode);
infof(data,"%s: authdone = %d\n",__FUNCTION__,data->state.authdone);
infof(data,"%s: newurl = %s\n",__FUNCTION__,data->reqdata.newurl ? data->reqdata.newurl : "(null)");
infof(data,"%s: newurl = %s\n",__FUNCTION__,data->req.newurl ?
data->req.newurl : "(null)");
infof(data,"%s: authproblem = %d\n",__FUNCTION__,data->state.authproblem);
#endif
@ -815,9 +812,9 @@ int Curl_http_should_fail(struct connectdata *conn)
** Either we're not authenticating, or we're supposed to
** be authenticating something else. This is an error.
*/
if((k->httpcode == 401) && !conn->bits.user_passwd)
if((httpcode == 401) && !conn->bits.user_passwd)
return TRUE;
if((k->httpcode == 407) && !conn->bits.proxy_user_passwd)
if((httpcode == 407) && !conn->bits.proxy_user_passwd)
return TRUE;
return data->state.authproblem;
@ -837,7 +834,7 @@ static size_t readmoredata(char *buffer,
void *userp)
{
struct connectdata *conn = (struct connectdata *)userp;
struct HTTP *http = conn->data->reqdata.proto.http;
struct HTTP *http = conn->data->state.proto.http;
size_t fullsize = size * nitems;
if(0 == http->postsize)
@ -929,7 +926,7 @@ CURLcode add_buffer_send(send_buffer *in,
CURLcode res;
char *ptr;
size_t size;
struct HTTP *http = conn->data->reqdata.proto.http;
struct HTTP *http = conn->data->state.proto.http;
size_t sendsize;
curl_socket_t sockfd;
size_t headersize;
@ -1220,7 +1217,7 @@ CURLcode Curl_proxyCONNECT(struct connectdata *conn,
{
int subversion=0;
struct SessionHandle *data=conn->data;
struct Curl_transfer_keeper *k = &data->reqdata.keep;
struct SingleRequest *k = &data->req;
CURLcode result;
int res;
long timeout =
@ -1246,12 +1243,12 @@ CURLcode Curl_proxyCONNECT(struct connectdata *conn,
infof(data, "Establish HTTP proxy tunnel to %s:%d\n",
hostname, remote_port);
if(data->reqdata.newurl) {
if(data->req.newurl) {
/* This only happens if we've looped here due to authentication
reasons, and we don't really use the newly cloned URL here
then. Just free() it. */
free(data->reqdata.newurl);
data->reqdata.newurl = NULL;
free(data->req.newurl);
data->req.newurl = NULL;
}
/* initialize a dynamic send-buffer */
@ -1603,20 +1600,20 @@ CURLcode Curl_proxyCONNECT(struct connectdata *conn,
headers. 'newurl' is set to a new URL if we must loop. */
Curl_http_auth_act(conn);
if(closeConnection && data->reqdata.newurl) {
if(closeConnection && data->req.newurl) {
/* Connection closed by server. Don't use it anymore */
sclose(conn->sock[sockindex]);
conn->sock[sockindex] = CURL_SOCKET_BAD;
break;
}
} /* END NEGOTIATION PHASE */
} while(data->reqdata.newurl);
} while(data->req.newurl);
if(200 != k->httpcode) {
if(200 != data->req.httpcode) {
failf(data, "Received HTTP code %d from proxy after CONNECT",
k->httpcode);
data->req.httpcode);
if(closeConnection && data->reqdata.newurl)
if(closeConnection && data->req.newurl)
conn->bits.proxy_connect_closed = TRUE;
return CURLE_RECV_ERROR;
@ -1631,7 +1628,7 @@ CURLcode Curl_proxyCONNECT(struct connectdata *conn,
data->state.authproxy.done = TRUE;
infof (data, "Proxy replied OK to CONNECT request\n");
k->ignorebody = FALSE; /* put it (back) to non-ignore state */
data->req.ignorebody = FALSE; /* put it (back) to non-ignore state */
return CURLE_OK;
}
@ -1790,8 +1787,7 @@ CURLcode Curl_http_done(struct connectdata *conn,
CURLcode status, bool premature)
{
struct SessionHandle *data = conn->data;
struct HTTP *http =data->reqdata.proto.http;
struct Curl_transfer_keeper *k = &data->reqdata.keep;
struct HTTP *http =data->state.proto.http;
(void)premature; /* not used */
/* set the proper values (possibly modified on POST) */
@ -1810,7 +1806,7 @@ CURLcode Curl_http_done(struct connectdata *conn,
}
if(HTTPREQ_POST_FORM == data->set.httpreq) {
k->bytecount = http->readbytecount + http->writebytecount;
data->req.bytecount = http->readbytecount + http->writebytecount;
Curl_formclean(&http->sendit); /* Now free that whole lot */
if(http->form.fp) {
@ -1820,15 +1816,15 @@ CURLcode Curl_http_done(struct connectdata *conn,
}
}
else if(HTTPREQ_PUT == data->set.httpreq)
k->bytecount = http->readbytecount + http->writebytecount;
data->req.bytecount = http->readbytecount + http->writebytecount;
if(status != CURLE_OK)
return (status);
if(!conn->bits.retry &&
((http->readbytecount +
data->reqdata.keep.headerbytecount -
data->reqdata.keep.deductheadercount)) <= 0) {
data->req.headerbytecount -
data->req.deductheadercount)) <= 0) {
/* If this connection isn't simply closed to be retried, AND nothing was
read from the HTTP server (that counts), this can't be right so we
return an error here */
@ -1911,7 +1907,7 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
char *buf = data->state.buffer; /* this is a short cut to the buffer */
CURLcode result=CURLE_OK;
struct HTTP *http;
char *ppath = data->reqdata.path;
char *ppath = data->state.path;
char ftp_typecode[sizeof(";type=?")] = "";
char *host = conn->host.name;
const char *te = ""; /* transfer-encoding */
@ -1930,16 +1926,16 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
sessionhandle, deal with it */
Curl_reset_reqproto(conn);
if(!data->reqdata.proto.http) {
if(!data->state.proto.http) {
/* Only allocate this struct if we don't already have it! */
http = (struct HTTP *)calloc(sizeof(struct HTTP), 1);
if(!http)
return CURLE_OUT_OF_MEMORY;
data->reqdata.proto.http = http;
data->state.proto.http = http;
}
else
http = data->reqdata.proto.http;
http = data->state.proto.http;
if( (conn->protocol&(PROT_HTTP|PROT_FTP)) &&
data->set.upload) {
@ -2169,7 +2165,7 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
if(( (HTTPREQ_POST == httpreq) ||
(HTTPREQ_POST_FORM == httpreq) ||
(HTTPREQ_PUT == httpreq) ) &&
data->reqdata.resume_from) {
data->state.resume_from) {
/**********************************************************************
* Resuming upload in HTTP means that we PUT or POST and that we have
* got a resume_from value set. The resume value has already created
@ -2178,15 +2174,15 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
* file size before we continue this venture in the dark lands of HTTP.
*********************************************************************/
if(data->reqdata.resume_from < 0 ) {
if(data->state.resume_from < 0 ) {
/*
* This is meant to get the size of the present remote-file by itself.
* We don't support this now. Bail out!
*/
data->reqdata.resume_from = 0;
data->state.resume_from = 0;
}
if(data->reqdata.resume_from && !data->state.this_is_a_follow) {
if(data->state.resume_from && !data->state.this_is_a_follow) {
/* do we still game? */
curl_off_t passed=0;
@ -2194,7 +2190,7 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
input. If we knew it was a proper file we could've just
fseek()ed but we only have a stream here */
do {
size_t readthisamountnow = (size_t)(data->reqdata.resume_from - passed);
size_t readthisamountnow = (size_t)(data->state.resume_from - passed);
size_t actuallyread;
if(readthisamountnow > BUFSIZE)
@ -2211,11 +2207,11 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
passed);
return CURLE_READ_ERROR;
}
} while(passed != data->reqdata.resume_from); /* loop until done */
} while(passed != data->state.resume_from); /* loop until done */
/* now, decrease the size of the read */
if(data->set.infilesize>0) {
data->set.infilesize -= data->reqdata.resume_from;
data->set.infilesize -= data->state.resume_from;
if(data->set.infilesize <= 0) {
failf(data, "File already completely uploaded");
@ -2225,7 +2221,7 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
/* we've passed, proceed as normal */
}
}
if(data->reqdata.use_range) {
if(data->state.use_range) {
/*
* A range is selected. We use different headers whether we're downloading
* or uploading and we always let customized headers override our internal
@ -2237,7 +2233,7 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
if(conn->allocptr.rangeline)
free(conn->allocptr.rangeline);
conn->allocptr.rangeline = aprintf("Range: bytes=%s\r\n",
data->reqdata.range);
data->state.range);
}
else if((httpreq != HTTPREQ_GET) &&
!checkheaders(data, "Content-Range:")) {
@ -2246,14 +2242,14 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
if(conn->allocptr.rangeline)
free(conn->allocptr.rangeline);
if(data->reqdata.resume_from) {
if(data->state.resume_from) {
/* This is because "resume" was selected */
curl_off_t total_expected_size=
data->reqdata.resume_from + data->set.infilesize;
data->state.resume_from + data->set.infilesize;
conn->allocptr.rangeline =
aprintf("Content-Range: bytes %s%" FORMAT_OFF_T
"/%" FORMAT_OFF_T "\r\n",
data->reqdata.range, total_expected_size-1,
data->state.range, total_expected_size-1,
total_expected_size);
}
else {
@ -2261,7 +2257,7 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
append total size */
conn->allocptr.rangeline =
aprintf("Content-Range: bytes %s/%" FORMAT_OFF_T "\r\n",
data->reqdata.range, data->set.infilesize);
data->state.range, data->set.infilesize);
}
if(!conn->allocptr.rangeline)
return CURLE_OUT_OF_MEMORY;
@ -2306,7 +2302,7 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
conn->allocptr.proxyuserpwd?
conn->allocptr.proxyuserpwd:"",
conn->allocptr.userpwd?conn->allocptr.userpwd:"",
(data->reqdata.use_range && conn->allocptr.rangeline)?
(data->state.use_range && conn->allocptr.rangeline)?
conn->allocptr.rangeline:"",
(data->set.str[STRING_USERAGENT] &&
*data->set.str[STRING_USERAGENT] && conn->allocptr.uagent)?
@ -2340,7 +2336,7 @@ CURLcode Curl_http(struct connectdata *conn, bool *done)
co = Curl_cookie_getlist(data->cookies,
conn->allocptr.cookiehost?
conn->allocptr.cookiehost:host,
data->reqdata.path,
data->state.path,
(bool)(conn->protocol&PROT_HTTPS?TRUE:FALSE));
Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE);
}

16
lib/http_chunks.c
View File

@ -109,7 +109,7 @@ CHUNKcode Curl_httpchunk_read(struct connectdata *conn,
CURLcode result=CURLE_OK;
struct SessionHandle *data = conn->data;
struct Curl_chunker *ch = &conn->chunk;
struct Curl_transfer_keeper *k = &data->reqdata.keep;
struct SingleRequest *k = &data->req;
size_t piece;
size_t length = (size_t)datalen;
size_t *wrote = (size_t *)wrotep;
@ -217,7 +217,7 @@ CHUNKcode Curl_httpchunk_read(struct connectdata *conn,
/* Write the data portion available */
#ifdef HAVE_LIBZ
switch (conn->data->set.http_ce_skip?
IDENTITY : data->reqdata.keep.content_encoding) {
IDENTITY : data->req.content_encoding) {
case IDENTITY:
#endif
if(!k->ignorebody) {
@ -231,16 +231,16 @@ CHUNKcode Curl_httpchunk_read(struct connectdata *conn,
break;
case DEFLATE:
/* update data->reqdata.keep.str to point to the chunk data. */
data->reqdata.keep.str = datap;
result = Curl_unencode_deflate_write(conn, &data->reqdata.keep,
/* update data->req.keep.str to point to the chunk data. */
data->req.str = datap;
result = Curl_unencode_deflate_write(conn, &data->req,
(ssize_t)piece);
break;
case GZIP:
/* update data->reqdata.keep.str to point to the chunk data. */
data->reqdata.keep.str = datap;
result = Curl_unencode_gzip_write(conn, &data->reqdata.keep,
/* update data->req.keep.str to point to the chunk data. */
data->req.str = datap;
result = Curl_unencode_gzip_write(conn, &data->req,
(ssize_t)piece);
break;

12
lib/multi.c
View File

@ -845,7 +845,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
bool dophase_done;
bool done;
CURLMcode result = CURLM_OK;
struct Curl_transfer_keeper *k;
struct SingleRequest *k;
do {
bool disconnect_conn = FALSE;
@ -857,7 +857,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
we're using gets cleaned up and we're left with nothing. */
if(easy->easy_handle->state.pipe_broke) {
infof(easy->easy_handle, "Pipe broke: handle 0x%x, url = %s\n",
easy, easy->easy_handle->reqdata.path);
easy, easy->easy_handle->state.path);
if(easy->easy_handle->state.is_in_pipeline) {
/* Head back to the CONNECT state */
@ -1252,7 +1252,7 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
/* read/write data if it is ready to do so */
easy->result = Curl_readwrite(easy->easy_conn, &done);
k = &easy->easy_handle->reqdata.keep;
k = &easy->easy_handle->req;
if(!(k->keepon & KEEP_READ)) {
/* We're done reading */
@ -1289,14 +1289,14 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
Curl_posttransfer(easy->easy_handle);
/* When we follow redirects, must to go back to the CONNECT state */
if(easy->easy_handle->reqdata.newurl || retry) {
if(easy->easy_handle->req.newurl || retry) {
Curl_removeHandleFromPipeline(easy->easy_handle,
easy->easy_conn->recv_pipe);
if(!retry) {
/* if the URL is a follow-location and not just a retried request
then figure out the URL here */
newurl = easy->easy_handle->reqdata.newurl;
easy->easy_handle->reqdata.newurl = NULL;
newurl = easy->easy_handle->req.newurl;
easy->easy_handle->req.newurl = NULL;
}
easy->result = Curl_done(&easy->easy_conn, CURLE_OK, FALSE);
if(easy->result == CURLE_OK)

7
lib/progress.c
View File

@ -356,11 +356,10 @@ int Curl_pgrsUpdate(struct connectdata *conn)
progress */
if(!(data->progress.flags & PGRS_HEADERS_OUT)) {
if(data->reqdata.resume_from) {
if(data->state.resume_from) {
fprintf(data->set.err,
"** Resuming transfer from byte position %" FORMAT_OFF_T
"\n",
data->reqdata.resume_from);
"** Resuming transfer from byte position %" FORMAT_OFF_T "\n",
data->state.resume_from);
}
fprintf(data->set.err,
" %% Total %% Received %% Xferd Average Speed Time Time Time Current\n"

38
lib/ssh.c
View File

@ -374,7 +374,7 @@ static CURLcode ssh_getworkingpath(struct connectdata *conn,
char *working_path;
int working_path_len;
working_path = curl_easy_unescape(data, data->reqdata.path, 0,
working_path = curl_easy_unescape(data, data->state.path, 0,
&working_path_len);
if(!working_path)
return CURLE_OUT_OF_MEMORY;
@ -432,7 +432,7 @@ static CURLcode ssh_statemach_act(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
struct SessionHandle *data = conn->data;
struct SSHPROTO *sftp_scp = data->reqdata.proto.ssh;
struct SSHPROTO *sftp_scp = data->state.proto.ssh;
struct ssh_conn *sshc = &conn->proto.sshc;
curl_socket_t sock = conn->sock[FIRSTSOCKET];
#ifdef CURL_LIBSSH2_DEBUG
@ -1350,7 +1350,7 @@ static CURLcode ssh_statemach_act(struct connectdata *conn)
}
/* since this counts what we send to the client, we include the newline
in this counter */
data->reqdata.keep.bytecount += sshc->readdir_len+1;
data->req.bytecount += sshc->readdir_len+1;
/* output debug output if that is requested */
if(data->set.verbose) {
@ -1469,7 +1469,7 @@ static CURLcode ssh_statemach_act(struct connectdata *conn)
Curl_debug(data, CURLINFO_DATA_OUT, sshc->readdir_line,
sshc->readdir_currLen, conn);
}
data->reqdata.keep.bytecount += sshc->readdir_currLen;
data->req.bytecount += sshc->readdir_currLen;
}
Curl_safefree(sshc->readdir_line);
sshc->readdir_line = NULL;
@ -1533,18 +1533,18 @@ static CURLcode ssh_statemach_act(struct connectdata *conn)
* libssh2_sftp_open() didn't return an error, so maybe the server
* just doesn't support stat()
*/
data->reqdata.size = -1;
data->reqdata.maxdownload = -1;
data->req.size = -1;
data->req.maxdownload = -1;
}
else {
data->reqdata.size = attrs.filesize;
data->reqdata.maxdownload = attrs.filesize;
data->req.size = attrs.filesize;
data->req.maxdownload = attrs.filesize;
Curl_pgrsSetDownloadSize(data, attrs.filesize);
}
}
/* Setup the actual download */
result = Curl_setup_transfer(conn, FIRSTSOCKET, data->reqdata.size,
result = Curl_setup_transfer(conn, FIRSTSOCKET, data->req.size,
FALSE, NULL, -1, NULL);
if(result) {
state(conn, SSH_SFTP_CLOSE);
@ -1648,7 +1648,7 @@ static CURLcode ssh_statemach_act(struct connectdata *conn)
}
/* upload data */
result = Curl_setup_transfer(conn, -1, data->reqdata.size, FALSE, NULL,
result = Curl_setup_transfer(conn, -1, data->req.size, FALSE, NULL,
FIRSTSOCKET, NULL);
if(result) {
@ -1696,7 +1696,7 @@ static CURLcode ssh_statemach_act(struct connectdata *conn)
/* download data */
bytecount = (curl_off_t)sb.st_size;
data->reqdata.maxdownload = (curl_off_t)sb.st_size;
data->req.maxdownload = (curl_off_t)sb.st_size;
result = Curl_setup_transfer(conn, FIRSTSOCKET,
bytecount, FALSE, NULL, -1, NULL);
@ -1849,14 +1849,14 @@ static CURLcode ssh_init(struct connectdata *conn)
{
struct SessionHandle *data = conn->data;
struct SSHPROTO *ssh;
if(data->reqdata.proto.ssh)
if(data->state.proto.ssh)
return CURLE_OK;
ssh = (struct SSHPROTO *)calloc(sizeof(struct SSHPROTO), 1);
if(!ssh)
return CURLE_OUT_OF_MEMORY;
data->reqdata.proto.ssh = ssh;
data->state.proto.ssh = ssh;
return CURLE_OK;
}
@ -1989,7 +1989,7 @@ static CURLcode ssh_do(struct connectdata *conn, bool *done)
*done = FALSE; /* default to false */
data->reqdata.size = -1; /* make sure this is unknown at this point */
data->req.size = -1; /* make sure this is unknown at this point */
Curl_pgrsSetUploadCounter(data, 0);
Curl_pgrsSetDownloadCounter(data, 0);
@ -2011,8 +2011,8 @@ static CURLcode scp_disconnect(struct connectdata *conn)
{
CURLcode result;
Curl_safefree(conn->data->reqdata.proto.ssh);
conn->data->reqdata.proto.ssh = NULL;
Curl_safefree(conn->data->state.proto.ssh);
conn->data->state.proto.ssh = NULL;
state(conn, SSH_SESSION_DISCONNECT);
@ -2046,7 +2046,7 @@ static CURLcode scp_done(struct connectdata *conn, CURLcode status,
}
if(done) {
struct SSHPROTO *sftp_scp = conn->data->reqdata.proto.ssh;
struct SSHPROTO *sftp_scp = conn->data->state.proto.ssh;
Curl_safefree(sftp_scp->path);
sftp_scp->path = NULL;
Curl_pgrsDone(conn);
@ -2154,8 +2154,8 @@ static CURLcode sftp_disconnect(struct connectdata *conn)
DEBUGF(infof(conn->data, "SSH DISCONNECT starts now\n"));
Curl_safefree(conn->data->reqdata.proto.ssh);
conn->data->reqdata.proto.ssh = NULL;
Curl_safefree(conn->data->state.proto.ssh);
conn->data->state.proto.ssh = NULL;
state(conn, SSH_SFTP_SHUTDOWN);
result = ssh_easy_statemach(conn);

30
lib/telnet.c
View File

@ -245,7 +245,7 @@ CURLcode init_telnet(struct connectdata *conn)
if(!tn)
return CURLE_OUT_OF_MEMORY;
conn->data->reqdata.proto.telnet = (void *)tn; /* make us known */
conn->data->state.proto.telnet = (void *)tn; /* make us known */
tn->telrcv_state = CURL_TS_DATA;
@ -264,7 +264,7 @@ CURLcode init_telnet(struct connectdata *conn)
static void negotiate(struct connectdata *conn)
{
int i;
struct TELNET *tn = (struct TELNET *) conn->data->reqdata.proto.telnet;
struct TELNET *tn = (struct TELNET *) conn->data->state.proto.telnet;
for(i = 0;i < CURL_NTELOPTS;i++)
{
@ -340,7 +340,7 @@ static void send_negotiation(struct connectdata *conn, int cmd, int option)
static
void set_remote_option(struct connectdata *conn, int option, int newstate)
{
struct TELNET *tn = (struct TELNET *)conn->data->reqdata.proto.telnet;
struct TELNET *tn = (struct TELNET *)conn->data->state.proto.telnet;
if(newstate == CURL_YES)
{
switch(tn->him[option])
@ -422,7 +422,7 @@ void set_remote_option(struct connectdata *conn, int option, int newstate)
static
void rec_will(struct connectdata *conn, int option)
{
struct TELNET *tn = (struct TELNET *)conn->data->reqdata.proto.telnet;
struct TELNET *tn = (struct TELNET *)conn->data->state.proto.telnet;
switch(tn->him[option])
{
case CURL_NO:
@ -475,7 +475,7 @@ void rec_will(struct connectdata *conn, int option)
static
void rec_wont(struct connectdata *conn, int option)
{
struct TELNET *tn = (struct TELNET *)conn->data->reqdata.proto.telnet;
struct TELNET *tn = (struct TELNET *)conn->data->state.proto.telnet;
switch(tn->him[option])
{
case CURL_NO:
@ -520,7 +520,7 @@ void rec_wont(struct connectdata *conn, int option)
static void
set_local_option(struct connectdata *conn, int option, int newstate)
{
struct TELNET *tn = (struct TELNET *)conn->data->reqdata.proto.telnet;
struct TELNET *tn = (struct TELNET *)conn->data->state.proto.telnet;
if(newstate == CURL_YES)
{
switch(tn->us[option])
@ -602,7 +602,7 @@ set_local_option(struct connectdata *conn, int option, int newstate)
static
void rec_do(struct connectdata *conn, int option)
{
struct TELNET *tn = (struct TELNET *)conn->data->reqdata.proto.telnet;
struct TELNET *tn = (struct TELNET *)conn->data->state.proto.telnet;
switch(tn->us[option])
{
case CURL_NO:
@ -655,7 +655,7 @@ void rec_do(struct connectdata *conn, int option)
static
void rec_dont(struct connectdata *conn, int option)
{
struct TELNET *tn = (struct TELNET *)conn->data->reqdata.proto.telnet;
struct TELNET *tn = (struct TELNET *)conn->data->state.proto.telnet;
switch(tn->us[option])
{
case CURL_NO:
@ -817,7 +817,7 @@ static CURLcode check_telnet_options(struct connectdata *conn)
char option_arg[256];
char *buf;
struct SessionHandle *data = conn->data;
struct TELNET *tn = (struct TELNET *)conn->data->reqdata.proto.telnet;
struct TELNET *tn = (struct TELNET *)conn->data->state.proto.telnet;
/* Add the user name as an environment variable if it
was given on the command line */
@ -888,7 +888,7 @@ static void suboption(struct connectdata *conn)
char varname[128];
char varval[128];
struct SessionHandle *data = conn->data;
struct TELNET *tn = (struct TELNET *)data->reqdata.proto.telnet;
struct TELNET *tn = (struct TELNET *)data->state.proto.telnet;
printsub(data, '<', (unsigned char *)tn->subbuffer, CURL_SB_LEN(tn)+2);
switch (CURL_SB_GET(tn)) {
@ -956,7 +956,7 @@ void telrcv(struct connectdata *conn,
int in = 0;
int startwrite=-1;
struct SessionHandle *data = conn->data;
struct TELNET *tn = (struct TELNET *)data->reqdata.proto.telnet;
struct TELNET *tn = (struct TELNET *)data->state.proto.telnet;
#define startskipping() \
if(startwrite >= 0) \
@ -1120,14 +1120,14 @@ void telrcv(struct connectdata *conn,
static CURLcode Curl_telnet_done(struct connectdata *conn,
CURLcode status, bool premature)
{
struct TELNET *tn = (struct TELNET *)conn->data->reqdata.proto.telnet;
struct TELNET *tn = (struct TELNET *)conn->data->state.proto.telnet;
(void)status; /* unused */
(void)premature; /* not used */
curl_slist_free_all(tn->telnet_vars);
free(conn->data->reqdata.proto.telnet);
conn->data->reqdata.proto.telnet = NULL;
free(conn->data->state.proto.telnet);
conn->data->state.proto.telnet = NULL;
return CURLE_OK;
}
@ -1166,7 +1166,7 @@ static CURLcode Curl_telnet(struct connectdata *conn, bool *done)
if(code)
return code;
tn = (struct TELNET *)data->reqdata.proto.telnet;
tn = (struct TELNET *)data->state.proto.telnet;
code = check_telnet_options(conn);
if(code)

20
lib/tftp.c
View File

@ -306,7 +306,7 @@ static CURLcode tftp_send_first(tftp_state_data_t *state, tftp_event_t event)
if(data->set.upload) {
/* If we are uploading, send an WRQ */
setpacketevent(&state->spacket, TFTP_EVENT_WRQ);
state->conn->data->reqdata.upload_fromhere =
state->conn->data->req.upload_fromhere =
(char *)&state->spacket.data[4];
if(data->set.infilesize != -1)
Curl_pgrsSetUploadSize(data, data->set.infilesize);
@ -317,7 +317,7 @@ static CURLcode tftp_send_first(tftp_state_data_t *state, tftp_event_t event)
}
/* As RFC3617 describes the separator slash is not actually part of the
file name so we skip the always-present first letter of the path string. */
filename = curl_easy_unescape(data, &state->conn->data->reqdata.path[1], 0,
filename = curl_easy_unescape(data, &state->conn->data->state.path[1], 0,
NULL);
if(!filename)
return CURLE_OUT_OF_MEMORY;
@ -460,7 +460,7 @@ static CURLcode tftp_tx(tftp_state_data_t *state, tftp_event_t event)
int sbytes;
int rblock;
CURLcode res = CURLE_OK;
struct Curl_transfer_keeper *k = &data->reqdata.keep;
struct SingleRequest *k = &data->req;
switch(event) {
@ -613,9 +613,9 @@ static CURLcode Curl_tftp_connect(struct connectdata *conn, bool *done)
sessionhandle, deal with it */
Curl_reset_reqproto(conn);
if(!(state = conn->data->reqdata.proto.tftp)) {
state = conn->data->reqdata.proto.tftp = calloc(sizeof(tftp_state_data_t),
1);
if(!(state = conn->data->state.proto.tftp)) {
state = conn->data->state.proto.tftp = calloc(sizeof(tftp_state_data_t),
1);
if(!state)
return CURLE_OUT_OF_MEMORY;
}
@ -706,7 +706,7 @@ static CURLcode Curl_tftp(struct connectdata *conn, bool *done)
struct Curl_sockaddr_storage fromaddr;
socklen_t fromlen;
int check_time = 0;
struct Curl_transfer_keeper *k = &data->reqdata.keep;
struct SingleRequest *k = &data->req;
*done = TRUE;
@ -718,12 +718,12 @@ static CURLcode Curl_tftp(struct connectdata *conn, bool *done)
*/
Curl_reset_reqproto(conn);
if(!data->reqdata.proto.tftp) {
if(!data->state.proto.tftp) {
code = Curl_tftp_connect(conn, done);
if(code)
return code;
}
state = (tftp_state_data_t *)data->reqdata.proto.tftp;
state = (tftp_state_data_t *)data->state.proto.tftp;
/* Run the TFTP State Machine */
for(code=tftp_state_machine(state, TFTP_EVENT_INIT);
@ -878,7 +878,7 @@ static CURLcode Curl_tftp_setup_connection(struct connectdata * conn)
/* TFTP URLs support an extension like ";mode=<typecode>" that
* we'll try to get now! */
type = strstr(data->reqdata.path, ";mode=");
type = strstr(data->state.path, ";mode=");
if(!type)
type = strstr(conn->host.rawalloc, ";mode=");

110
lib/transfer.c
View File

@ -122,12 +122,12 @@ CURLcode Curl_fillreadbuffer(struct connectdata *conn, int bytes, int *nreadp)
if(conn->bits.upload_chunky) {
/* if chunked Transfer-Encoding */
buffersize -= (8 + 2 + 2); /* 32bit hex + CRLF + CRLF */
data->reqdata.upload_fromhere += 10; /* 32bit hex + CRLF */
data->req.upload_fromhere += 10; /* 32bit hex + CRLF */
}
/* this function returns a size_t, so we typecast to int to prevent warnings
with picky compilers */
nread = (int)conn->fread_func(data->reqdata.upload_fromhere, 1,
nread = (int)conn->fread_func(data->req.upload_fromhere, 1,
buffersize, conn->fread_in);
if(nread == CURL_READFUNC_ABORT) {
@ -141,18 +141,18 @@ CURLcode Curl_fillreadbuffer(struct connectdata *conn, int bytes, int *nreadp)
int hexlen = snprintf(hexbuffer, sizeof(hexbuffer),
"%x\r\n", nread);
/* move buffer pointer */
data->reqdata.upload_fromhere -= hexlen;
data->req.upload_fromhere -= hexlen;
nread += hexlen;
/* copy the prefix to the buffer */
memcpy(data->reqdata.upload_fromhere, hexbuffer, hexlen);
memcpy(data->req.upload_fromhere, hexbuffer, hexlen);
/* always append CRLF to the data */
memcpy(data->reqdata.upload_fromhere + nread, "\r\n", 2);
memcpy(data->req.upload_fromhere + nread, "\r\n", 2);
if((nread - hexlen) == 0) {
/* mark this as done once this chunk is transfered */
data->reqdata.keep.upload_done = TRUE;
data->req.upload_done = TRUE;
}
nread+=2; /* for the added CRLF */
@ -163,7 +163,7 @@ CURLcode Curl_fillreadbuffer(struct connectdata *conn, int bytes, int *nreadp)
#ifdef CURL_DOES_CONVERSIONS
if(data->set.prefer_ascii) {
CURLcode res;
res = Curl_convert_to_network(data, data->reqdata.upload_fromhere, nread);
res = Curl_convert_to_network(data, data->req.upload_fromhere, nread);
/* Curl_convert_to_network calls failf if unsuccessful */
if(res != CURLE_OK) {
return(res);
@ -315,7 +315,7 @@ CURLcode Curl_readwrite(struct connectdata *conn,
bool *done)
{
struct SessionHandle *data = conn->data;
struct Curl_transfer_keeper *k = &data->reqdata.keep;
struct SingleRequest *k = &data->req;
CURLcode result;
ssize_t nread; /* number of bytes read */
int didwhat=0;
@ -628,12 +628,12 @@ CURLcode Curl_readwrite(struct connectdata *conn,
return result;
data->info.header_size += (long)headerlen;
data->reqdata.keep.headerbytecount += (long)headerlen;
data->req.headerbytecount += (long)headerlen;
data->reqdata.keep.deductheadercount =
(100 == k->httpcode)?data->reqdata.keep.headerbytecount:0;
data->req.deductheadercount =
(100 == k->httpcode)?data->req.headerbytecount:0;
if(data->reqdata.resume_from &&
if(data->state.resume_from &&
(data->set.httpreq==HTTPREQ_GET) &&
(k->httpcode == 416)) {
/* "Requested Range Not Satisfiable" */
@ -792,7 +792,7 @@ CURLcode Curl_readwrite(struct connectdata *conn,
((k->httpcode != 401) || !conn->bits.user_passwd) &&
((k->httpcode != 407) || !conn->bits.proxy_user_passwd) ) {
if(data->reqdata.resume_from &&
if(data->state.resume_from &&
(data->set.httpreq==HTTPREQ_GET) &&
(k->httpcode == 416)) {
/* "Requested Range Not Satisfiable", just proceed and
@ -1042,7 +1042,7 @@ CURLcode Curl_readwrite(struct connectdata *conn,
k->offset = curlx_strtoofft(ptr, NULL, 10);
if(data->reqdata.resume_from == k->offset)
if(data->state.resume_from == k->offset)
/* we asked for a resume and we got it */
k->content_range = TRUE;
}
@ -1057,7 +1057,7 @@ CURLcode Curl_readwrite(struct connectdata *conn,
here, or else use real peer host name. */
conn->allocptr.cookiehost?
conn->allocptr.cookiehost:conn->host.name,
data->reqdata.path);
data->state.path);
Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE);
}
#endif
@ -1105,9 +1105,9 @@ CURLcode Curl_readwrite(struct connectdata *conn,
backup = *ptr; /* store the ending letter */
if(ptr != start) {
*ptr = '\0'; /* zero terminate */
data->reqdata.newurl = strdup(start); /* clone string */
data->req.newurl = strdup(start); /* clone string */
*ptr = backup; /* restore ending letter */
if(!data->reqdata.newurl)
if(!data->req.newurl)
return CURLE_OUT_OF_MEMORY;
}
}
@ -1131,7 +1131,7 @@ CURLcode Curl_readwrite(struct connectdata *conn,
return result;
data->info.header_size += (long)k->hbuflen;
data->reqdata.keep.headerbytecount += (long)k->hbuflen;
data->req.headerbytecount += (long)k->hbuflen;
/* reset hbufp pointer && hbuflen */
k->hbufp = data->state.headerbuff;
@ -1160,7 +1160,7 @@ CURLcode Curl_readwrite(struct connectdata *conn,
if(conn->protocol&PROT_HTTP) {
/* HTTP-only checks */
if(data->reqdata.newurl) {
if(data->req.newurl) {
if(conn->bits.close) {
/* Abort after the headers if "follow Location" is set
and we're set to close anyway. */
@ -1174,7 +1174,7 @@ CURLcode Curl_readwrite(struct connectdata *conn,
k->ignorebody = TRUE;
infof(data, "Ignoring the response-body\n");
}
if(data->reqdata.resume_from && !k->content_range &&
if(data->state.resume_from && !k->content_range &&
(data->set.httpreq==HTTPREQ_GET) &&
!k->ignorebody) {
/* we wanted to resume a download, although the server doesn't
@ -1185,7 +1185,7 @@ CURLcode Curl_readwrite(struct connectdata *conn,
return CURLE_RANGE_ERROR;
}
if(data->set.timecondition && !data->reqdata.range) {
if(data->set.timecondition && !data->state.range) {
/* A time condition has been set AND no ranges have been
requested. This seems to be what chapter 13.3.4 of
RFC 2616 defines to be the correct action for a
@ -1284,7 +1284,7 @@ CURLcode Curl_readwrite(struct connectdata *conn,
" bytes on url %s (size = %" FORMAT_OFF_T
", maxdownload = %" FORMAT_OFF_T
", bytecount = %" FORMAT_OFF_T ", nread = %d)\n",
excess, conn->data->reqdata.path,
excess, data->state.path,
k->size, k->maxdownload, k->bytecount, nread);
read_rewind(conn, excess);
}
@ -1394,9 +1394,9 @@ CURLcode Curl_readwrite(struct connectdata *conn,
/* only read more data if there's no upload data already
present in the upload buffer */
if(0 == data->reqdata.upload_present) {
if(0 == data->req.upload_present) {
/* init the "upload from here" pointer */
data->reqdata.upload_fromhere = k->uploadbuf;
data->req.upload_fromhere = k->uploadbuf;
if(!k->upload_done) {
/* HTTP pollution, this should be written nicer to become more
@ -1404,7 +1404,7 @@ CURLcode Curl_readwrite(struct connectdata *conn,
int fillcount;
if(k->wait100_after_headers &&
(data->reqdata.proto.http->sending == HTTPSEND_BODY)) {
(data->state.proto.http->sending == HTTPSEND_BODY)) {
/* If this call is to send body data, we must take some action:
We have sent off the full HTTP 1.1 request, and we shall now
go into the Expect: 100 state and await such a header */
@ -1441,7 +1441,7 @@ CURLcode Curl_readwrite(struct connectdata *conn,
}
/* store number of bytes available for upload */
data->reqdata.upload_present = nread;
data->req.upload_present = nread;
/* convert LF to CRLF if so asked */
#ifdef CURL_DO_LINEEND_CONV
@ -1463,7 +1463,7 @@ CURLcode Curl_readwrite(struct connectdata *conn,
* must be used instead of the escape sequences \r & \n.
*/
for(i = 0, si = 0; i < nread; i++, si++) {
if(data->reqdata.upload_fromhere[i] == 0x0a) {
if(data->req.upload_fromhere[i] == 0x0a) {
data->state.scratch[si++] = 0x0d;
data->state.scratch[si] = 0x0a;
if(!data->set.crlf) {
@ -1473,7 +1473,7 @@ CURLcode Curl_readwrite(struct connectdata *conn,
}
}
else
data->state.scratch[si] = data->reqdata.upload_fromhere[i];
data->state.scratch[si] = data->req.upload_fromhere[i];
}
if(si != nread) {
/* only perform the special operation if we really did replace
@ -1481,10 +1481,10 @@ CURLcode Curl_readwrite(struct connectdata *conn,
nread = si;
/* upload from the new (replaced) buffer instead */
data->reqdata.upload_fromhere = data->state.scratch;
data->req.upload_fromhere = data->state.scratch;
/* set the new amount too */
data->reqdata.upload_present = nread;
data->req.upload_present = nread;
}
}
}
@ -1496,33 +1496,33 @@ CURLcode Curl_readwrite(struct connectdata *conn,
/* write to socket (send away data) */
result = Curl_write(conn,
conn->writesockfd, /* socket to send to */
data->reqdata.upload_fromhere, /* buffer pointer */
data->reqdata.upload_present, /* buffer size */
data->req.upload_fromhere, /* buffer pointer */
data->req.upload_present, /* buffer size */
&bytes_written); /* actually send away */
if(result)
return result;
if(data->set.verbose)
/* show the data before we change the pointer upload_fromhere */
Curl_debug(data, CURLINFO_DATA_OUT, data->reqdata.upload_fromhere,
Curl_debug(data, CURLINFO_DATA_OUT, data->req.upload_fromhere,
(size_t)bytes_written, conn);
if(data->reqdata.upload_present != bytes_written) {
if(data->req.upload_present != bytes_written) {
/* we only wrote a part of the buffer (if anything), deal with it! */
/* store the amount of bytes left in the buffer to write */
data->reqdata.upload_present -= bytes_written;
data->req.upload_present -= bytes_written;
/* advance the pointer where to find the buffer when the next send
is to happen */
data->reqdata.upload_fromhere += bytes_written;
data->req.upload_fromhere += bytes_written;
writedone = TRUE; /* we are done, stop the loop */
}
else {
/* we've uploaded that buffer now */
data->reqdata.upload_fromhere = k->uploadbuf;
data->reqdata.upload_present = 0; /* no more bytes left */
data->req.upload_fromhere = k->uploadbuf;
data->req.upload_present = 0; /* no more bytes left */
if(k->upload_done) {
/* switch off writing, we're done! */
@ -1609,7 +1609,7 @@ CURLcode Curl_readwrite(struct connectdata *conn,
*/
(k->bytecount != (k->size + data->state.crlf_conversions)) &&
#endif /* CURL_DO_LINEEND_CONV */
!data->reqdata.newurl) {
!data->req.newurl) {
failf(data, "transfer closed with %" FORMAT_OFF_T
" bytes remaining to read",
k->size - k->bytecount);
@ -1660,7 +1660,7 @@ int Curl_single_getsock(const struct connectdata *conn,
/* simple check but we might need two slots */
return GETSOCK_BLANK;
if(data->reqdata.keep.keepon & KEEP_READ) {
if(data->req.keepon & KEEP_READ) {
DEBUGASSERT(conn->sockfd != CURL_SOCKET_BAD);
@ -1668,13 +1668,13 @@ int Curl_single_getsock(const struct connectdata *conn,
sock[sockindex] = conn->sockfd;
}
if(data->reqdata.keep.keepon & KEEP_WRITE) {
if(data->req.keepon & KEEP_WRITE) {
if((conn->sockfd != conn->writesockfd) ||
!(data->reqdata.keep.keepon & KEEP_READ)) {
!(data->req.keepon & KEEP_READ)) {
/* only if they are not the same socket or we didn't have a readable
one, we increase index */
if(data->reqdata.keep.keepon & KEEP_READ)
if(data->req.keepon & KEEP_READ)
sockindex++; /* increase index if we need two entries */
DEBUGASSERT(conn->writesockfd != CURL_SOCKET_BAD);
@ -1708,7 +1708,7 @@ Transfer(struct connectdata *conn)
{
CURLcode result;
struct SessionHandle *data = conn->data;
struct Curl_transfer_keeper *k = &data->reqdata.keep;
struct SingleRequest *k = &data->req;
bool done=FALSE;
if((conn->sockfd == CURL_SOCKET_BAD) &&
@ -2277,8 +2277,8 @@ bool Curl_retry_request(struct connectdata *conn,
if(data->set.upload && !(conn->protocol&PROT_HTTP))
return retry;
if((data->reqdata.keep.bytecount +
data->reqdata.keep.headerbytecount == 0) &&
if((data->req.bytecount +
data->req.headerbytecount == 0) &&
conn->bits.reuse &&
!conn->bits.no_body) {
/* We got no data, we attempted to re-use a connection and yet we want a
@ -2349,7 +2349,7 @@ CURLcode Curl_perform(struct SessionHandle *data)
* We must duplicate the new URL here as the connection data may
* be free()ed in the Curl_done() function.
*/
newurl = data->reqdata.newurl?strdup(data->reqdata.newurl):NULL;
newurl = data->req.newurl?strdup(data->req.newurl):NULL;
}
else {
/* The transfer phase returned error, we mark the connection to get
@ -2435,12 +2435,12 @@ Curl_setup_transfer(
)
{
struct SessionHandle *data;
struct Curl_transfer_keeper *k;
struct SingleRequest *k;
DEBUGASSERT(conn != NULL);
data = conn->data;
k = &data->reqdata.keep;
k = &data->req;
DEBUGASSERT((sockindex <= 1) && (sockindex >= -1));
@ -2451,9 +2451,9 @@ Curl_setup_transfer(
CURL_SOCKET_BAD:conn->sock[writesockindex];
conn->bits.getheader = getheader;
data->reqdata.size = size;
data->reqdata.bytecountp = bytecountp;
data->reqdata.writebytecountp = writecountp;
k->size = size;
k->bytecountp = bytecountp;
k->writebytecountp = writecountp;
/* 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
@ -2461,8 +2461,8 @@ Curl_setup_transfer(
if(!conn->bits.getheader) {
k->header = FALSE;
if(k->size > 0)
Curl_pgrsSetDownloadSize(data, k->size);
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) {
@ -2482,7 +2482,7 @@ Curl_setup_transfer(
state info where we wait for the 100-return code
*/
if(data->state.expect100header &&
(data->reqdata.proto.http->sending == HTTPSEND_BODY)) {
(data->state.proto.http->sending == HTTPSEND_BODY)) {
/* wait with write until we either got 100-continue or a timeout */
k->write_after_100_header = TRUE;
k->start100 = k->start;

84
lib/url.c
View File

@ -463,12 +463,12 @@ CURLcode Curl_close(struct SessionHandle *data)
}
}
if(data->reqdata.rangestringalloc)
free(data->reqdata.range);
if(data->state.rangestringalloc)
free(data->state.range);
/* Free the pathbuffer */
Curl_safefree(data->reqdata.pathbuffer);
Curl_safefree(data->reqdata.proto.generic);
Curl_safefree(data->state.pathbuffer);
Curl_safefree(data->state.proto.generic);
/* Close down all open SSL info and sessions */
Curl_ssl_close_all(data);
@ -2166,7 +2166,7 @@ CURLcode Curl_disconnect(struct connectdata *conn)
}
conn_free(conn);
data->reqdata.current_conn = NULL;
data->state.current_conn = NULL;
return CURLE_OK;
}
@ -2872,7 +2872,7 @@ static CURLcode ParseURLAndFillConnection(struct SessionHandle *data,
char *at;
char *tmp;
char *path = data->reqdata.path;
char *path = data->state.path;
/*************************************************************
* Parse the URL.
@ -3030,7 +3030,7 @@ static CURLcode ParseURLAndFillConnection(struct SessionHandle *data,
* So if the URL was A://B/C,
* conn->protostr is A
* conn->host.name is B
* data->reqdata.path is /C
* data->state.path is /C
*/
return CURLE_OK;
@ -3049,28 +3049,27 @@ static CURLcode setup_range(struct SessionHandle *data)
* If we're doing a resumed transfer, we need to setup our stuff
* properly.
*/
struct HandleData *req = &data->reqdata;
struct UrlState *s = &data->state;
s->resume_from = data->set.set_resume_from;
if(s->resume_from || data->set.str[STRING_SET_RANGE]) {
if(s->rangestringalloc)
free(s->range);
req->resume_from = data->set.set_resume_from;
if(req->resume_from || data->set.str[STRING_SET_RANGE]) {
if(req->rangestringalloc)
free(req->range);
if(req->resume_from)
req->range = aprintf("%" FORMAT_OFF_T "-", req->resume_from);
if(s->resume_from)
s->range = aprintf("%" FORMAT_OFF_T "-", s->resume_from);
else
req->range = strdup(data->set.str[STRING_SET_RANGE]);
s->range = strdup(data->set.str[STRING_SET_RANGE]);
req->rangestringalloc = (unsigned char)(req->range?TRUE:FALSE);
s->rangestringalloc = (bool)(s->range?TRUE:FALSE);
if(!req->range)
if(!s->range)
return CURLE_OUT_OF_MEMORY;
/* tell ourselves to fetch this range */
req->use_range = TRUE; /* enable range download */
s->use_range = TRUE; /* enable range download */
}
else
req->use_range = FALSE; /* disable range download */
s->use_range = FALSE; /* disable range download */
return CURLE_OK;
}
@ -3539,7 +3538,7 @@ static CURLcode CreateConnection(struct SessionHandle *data,
urllen=LEAST_PATH_ALLOC;
/* Free the old buffer */
Curl_safefree(data->reqdata.pathbuffer);
Curl_safefree(data->state.pathbuffer);
/*
* We malloc() the buffers below urllen+2 to make room for to possibilities:
@ -3547,10 +3546,10 @@ static CURLcode CreateConnection(struct SessionHandle *data,
* 2 - an extra slash (in case a syntax like "www.host.com?moo" is used)
*/
data->reqdata.pathbuffer=(char *)malloc(urllen+2);
if(NULL == data->reqdata.pathbuffer)
data->state.pathbuffer=(char *)malloc(urllen+2);
if(NULL == data->state.pathbuffer)
return CURLE_OUT_OF_MEMORY; /* really bad error */
data->reqdata.path = data->reqdata.pathbuffer;
data->state.path = data->state.pathbuffer;
conn->host.rawalloc=(char *)malloc(urllen+2);
if(NULL == conn->host.rawalloc)
@ -3803,7 +3802,7 @@ static CURLcode CreateConnection(struct SessionHandle *data,
char *url;
url = aprintf("%s://%s:%d%s", conn->protostr, conn->host.name,
conn->remote_port, data->reqdata.path);
conn->remote_port, data->state.path);
if(!url)
return CURLE_OUT_OF_MEMORY;
@ -4237,7 +4236,7 @@ static CURLcode SetupConnection(struct connectdata *conn,
return CURLE_OUT_OF_MEMORY;
}
data->reqdata.keep.headerbytecount = 0;
data->req.headerbytecount = 0;
#ifdef CURL_DO_LINEEND_CONV
data->state.crlf_conversions = 0; /* reset CRLF conversion counter */
@ -4393,9 +4392,9 @@ CURLcode Curl_done(struct connectdata **connp,
conn->writechannel_inuse = FALSE;
/* Cleanup possible redirect junk */
if(data->reqdata.newurl) {
free(data->reqdata.newurl);
data->reqdata.newurl = NULL;
if(data->req.newurl) {
free(data->req.newurl);
data->req.newurl = NULL;
}
if(conn->dns_entry) {
@ -4458,14 +4457,13 @@ CURLcode Curl_done(struct connectdata **connp,
static CURLcode do_init(struct connectdata *conn)
{
struct SessionHandle *data = conn->data;
struct Curl_transfer_keeper *k = &data->reqdata.keep;
struct SingleRequest *k = &data->req;
conn->bits.done = FALSE; /* Curl_done() is not called yet */
conn->bits.do_more = FALSE; /* by default there's no curl_do_more() to use */
/* NB: the content encoding software depends on this initialization of
Curl_transfer_keeper.*/
memset(k, 0, sizeof(struct Curl_transfer_keeper));
/* NB: the content encoding software depends on this initialization */
Curl_easy_initHandleData(data);
k->start = Curl_tvnow(); /* start time */
k->now = k->start; /* current time is now */
@ -4496,19 +4494,11 @@ static CURLcode do_init(struct connectdata *conn)
*/
static void do_complete(struct connectdata *conn)
{
struct SessionHandle *data = conn->data;
struct Curl_transfer_keeper *k = &data->reqdata.keep;
conn->bits.chunk=FALSE;
conn->bits.trailerhdrpresent=FALSE;
k->maxfd = (conn->sockfd>conn->writesockfd?
conn->sockfd:conn->writesockfd)+1;
k->size = data->reqdata.size;
k->maxdownload = data->reqdata.maxdownload;
k->bytecountp = data->reqdata.bytecountp;
k->writebytecountp = data->reqdata.writebytecountp;
conn->data->req.maxfd = (conn->sockfd>conn->writesockfd?
conn->sockfd:conn->writesockfd)+1;
}
CURLcode Curl_do(struct connectdata **connp, bool *done)
@ -4602,9 +4592,9 @@ CURLcode Curl_do_more(struct connectdata *conn)
void Curl_reset_reqproto(struct connectdata *conn)
{
struct SessionHandle *data = conn->data;
if(data->reqdata.proto.generic && data->reqdata.current_conn != conn) {
free(data->reqdata.proto.generic);
data->reqdata.proto.generic = NULL;
if(data->state.proto.generic && data->state.current_conn != conn) {
free(data->state.proto.generic);
data->state.proto.generic = NULL;
}
data->reqdata.current_conn = conn;
data->state.current_conn = conn;
}

152
lib/urldata.h
View File

@ -646,16 +646,36 @@ typedef enum {
} zlibInitState;
#endif
#if defined(USE_ARES) || defined(USE_THREADING_GETHOSTBYNAME) || \
defined(USE_THREADING_GETADDRINFO)
struct Curl_async {
char *hostname;
int port;
struct Curl_dns_entry *dns;
bool done; /* set TRUE when the lookup is complete */
int status; /* if done is TRUE, this is the status from the callback */
void *os_specific; /* 'struct thread_data' for Windows */
};
#endif
#define FIRSTSOCKET 0
#define SECONDARYSOCKET 1
/* These function pointer types are here only to allow easier typecasting
within the source when we need to cast between data pointers (such as NULL)
and function pointers. */
typedef CURLcode (*Curl_do_more_func)(struct connectdata *);
typedef CURLcode (*Curl_done_func)(struct connectdata *, CURLcode, bool);
/*
* This struct is all the previously local variables from Curl_perform() moved
* to struct to allow the function to return and get re-invoked better without
* losing state.
* Request specific data in the easy handle (SessionHandle). Previously,
* these members were on the connectdata struct but since a conn struct may
* now be shared between different SessionHandles, we store connection-specifc
* data here. This struct only keeps stuff that's interesting for *this*
* request, as it will be cleared between multiple ones
*/
struct Curl_transfer_keeper {
/** Values copied over from the HandleData struct each time on init **/
struct SingleRequest {
curl_off_t size; /* -1 if unknown at this point */
curl_off_t *bytecountp; /* return number of bytes read or NULL */
@ -663,17 +683,15 @@ struct Curl_transfer_keeper {
-1 means unlimited */
curl_off_t *writebytecountp; /* return number of bytes written or NULL */
/** End of HandleData struct copies **/
curl_off_t bytecount; /* total number of bytes read */
curl_off_t writebytecount; /* number of bytes written */
long headerbytecount; /* only count received headers */
long headerbytecount; /* only count received headers */
long deductheadercount; /* this amount of bytes doesn't count when we check
if anything has been transfered at the end of
a connection. We use this counter to make only
a 100 reply (without a following second response
code) result in a CURLE_GOT_NOTHING error code */
if anything has been transfered at the end of a
connection. We use this counter to make only a
100 reply (without a following second response
code) result in a CURLE_GOT_NOTHING error code */
struct timeval start; /* transfer started at this time */
struct timeval now; /* current time */
@ -733,48 +751,10 @@ struct Curl_transfer_keeper {
bool ignorebody; /* we read a response-body but we ignore it! */
bool ignorecl; /* This HTTP response has no body so we ignore the Content-
Length: header */
};
#if defined(USE_ARES) || defined(USE_THREADING_GETHOSTBYNAME) || \
defined(USE_THREADING_GETADDRINFO)
struct Curl_async {
char *hostname;
int port;
struct Curl_dns_entry *dns;
bool done; /* set TRUE when the lookup is complete */
int status; /* if done is TRUE, this is the status from the callback */
void *os_specific; /* 'struct thread_data' for Windows */
};
#endif
#define FIRSTSOCKET 0
#define SECONDARYSOCKET 1
/* These function pointer types are here only to allow easier typecasting
within the source when we need to cast between data pointers (such as NULL)
and function pointers. */
typedef CURLcode (*Curl_do_more_func)(struct connectdata *);
typedef CURLcode (*Curl_done_func)(struct connectdata *, CURLcode, bool);
/*
* Store's request specific data in the easy handle (SessionHandle).
* Previously, these members were on the connectdata struct but since
* a conn struct may now be shared between different SessionHandles,
* we store connection-specifc data here.
*
*/
struct HandleData {
char *pathbuffer;/* allocated buffer to store the URL's path part in */
char *path; /* path to use, points to somewhere within the pathbuffer
area */
char *newurl; /* This can only be set if a Location: was in the
document headers */
/* This struct is inited when needed */
struct Curl_transfer_keeper keep;
/* 'upload_present' is used to keep a byte counter of how much data there is
still left in the buffer, aimed for upload. */
ssize_t upload_present;
@ -784,40 +764,6 @@ struct HandleData {
and the 'upload_present' contains the number of bytes available at this
position */
char *upload_fromhere;
curl_off_t size; /* -1 if unknown at this point */
curl_off_t *bytecountp; /* return number of bytes read or NULL */
curl_off_t maxdownload; /* in bytes, the maximum amount of data to fetch, -1
means unlimited */
curl_off_t *writebytecountp; /* return number of bytes written or NULL */
bool use_range;
bool rangestringalloc; /* the range string is malloc()'ed */
char *range; /* range, if used. See README for detailed specification on
this syntax. */
curl_off_t resume_from; /* continue [ftp] transfer from here */
/* Protocol specific data.
*
*************************************************************************
* Note that this data will be REMOVED after each request, so anything that
* should be kept/stored on a per-connection basis and thus live for the
* next requst on the same connection MUST be put in the connectdata struct!
*************************************************************************/
union {
struct HTTP *http;
struct HTTP *https; /* alias, just for the sake of being more readable */
struct FTP *ftp;
void *tftp; /* private for tftp.c-eyes only */
struct FILEPROTO *file;
void *telnet; /* private for telnet.c-eyes only */
void *generic;
struct SSHPROTO *ssh;
} proto;
/* current user of this HandleData instance, or NULL */
struct connectdata *current_conn;
};
/*
@ -1246,6 +1192,36 @@ struct UrlState {
bool closed; /* set to TRUE when curl_easy_cleanup() has been called on this
handle, but it is kept around as mentioned for
shared_conn */
char *pathbuffer;/* allocated buffer to store the URL's path part in */
char *path; /* path to use, points to somewhere within the pathbuffer
area */
bool use_range;
bool rangestringalloc; /* the range string is malloc()'ed */
char *range; /* range, if used. See README for detailed specification on
this syntax. */
curl_off_t resume_from; /* continue [ftp] transfer from here */
/* Protocol specific data.
*
*************************************************************************
* Note that this data will be REMOVED after each request, so anything that
* should be kept/stored on a per-connection basis and thus live for the
* next requst on the same connection MUST be put in the connectdata struct!
*************************************************************************/
union {
struct HTTP *http;
struct HTTP *https; /* alias, just for the sake of being more readable */
struct FTP *ftp;
void *tftp; /* private for tftp.c-eyes only */
struct FILEPROTO *file;
void *telnet; /* private for telnet.c-eyes only */
void *generic;
struct SSHPROTO *ssh;
} proto;
/* current user of this SessionHandle instance, or NULL */
struct connectdata *current_conn;
};
@ -1496,7 +1472,7 @@ struct SessionHandle {
in multi controlling structure to assist
in removal. */
struct Curl_share *share; /* Share, handles global variable mutexing */
struct HandleData reqdata; /* Request-specific data */
struct SingleRequest req; /* Request-specific data */
struct UserDefined set; /* values set by the libcurl user */
struct DynamicStatic change; /* possibly modified userdefined data */
struct CookieInfo *cookies; /* the cookies, read from files and servers.