generic-library/curl
1
0
Fork 0
Code Issues Pull Requests 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
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 static CURLcode
inflate_stream(struct connectdata *conn, inflate_stream(struct connectdata *conn,
struct Curl_transfer_keeper *k) struct SingleRequest *k)
{ {
int allow_restart = 1; int allow_restart = 1;
z_stream *z = &k->z; /* zlib state structure */ z_stream *z = &k->z; /* zlib state structure */
@@ -152,7 +152,7 @@ inflate_stream(struct connectdata *conn,
CURLcode CURLcode
Curl_unencode_deflate_write(struct connectdata *conn, Curl_unencode_deflate_write(struct connectdata *conn,
struct Curl_transfer_keeper *k, struct SingleRequest *k,
ssize_t nread) ssize_t nread)
{ {
z_stream *z = &k->z; /* zlib state structure */ z_stream *z = &k->z; /* zlib state structure */
@@ -265,7 +265,7 @@ static enum {
CURLcode CURLcode
Curl_unencode_gzip_write(struct connectdata *conn, Curl_unencode_gzip_write(struct connectdata *conn,
struct Curl_transfer_keeper *k, struct SingleRequest *k,
ssize_t nread) ssize_t nread)
{ {
z_stream *z = &k->z; /* zlib state structure */ 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 * This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms * you should have received as part of this distribution. The terms
@@ -32,10 +32,10 @@
#endif #endif
CURLcode Curl_unencode_deflate_write(struct connectdata *conn, CURLcode Curl_unencode_deflate_write(struct connectdata *conn,
struct Curl_transfer_keeper *k, struct SingleRequest *req,
ssize_t nread); ssize_t nread);
CURLcode CURLcode
Curl_unencode_gzip_write(struct connectdata *conn, Curl_unencode_gzip_write(struct connectdata *conn,
struct Curl_transfer_keeper *k, struct SingleRequest *k,
ssize_t nread); 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; struct SessionHandle *data=conn->data;
curl_socket_t sockfd = conn->sock[FIRSTSOCKET]; curl_socket_t sockfd = conn->sock[FIRSTSOCKET];
char *path = data->reqdata.path; char *path = data->state.path;
curl_off_t *bytecount = &data->reqdata.keep.bytecount; curl_off_t *bytecount = &data->req.bytecount;
*done = TRUE; /* unconditionally */ *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) 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; struct SessionHandle *data = (struct SessionHandle *)curl;
Curl_safefree(data->reqdata.pathbuffer); Curl_safefree(data->state.pathbuffer);
data->reqdata.pathbuffer=NULL; data->state.pathbuffer=NULL;
Curl_safefree(data->reqdata.proto.generic); Curl_safefree(data->state.proto.generic);
data->reqdata.proto.generic=NULL; data->state.proto.generic=NULL;
/* zero out UserDefined data: */ /* zero out UserDefined data: */
Curl_freeset(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) static CURLcode Curl_file_connect(struct connectdata *conn, bool *done)
{ {
struct SessionHandle *data = conn->data; 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; struct FILEPROTO *file;
int fd; int fd;
#if defined(WIN32) || defined(MSDOS) || defined(__EMX__) #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 */ sessionhandle, deal with it */
Curl_reset_reqproto(conn); Curl_reset_reqproto(conn);
if(!data->reqdata.proto.file) { if(!data->state.proto.file) {
file = (struct FILEPROTO *)calloc(sizeof(struct FILEPROTO), 1); file = (struct FILEPROTO *)calloc(sizeof(struct FILEPROTO), 1);
if(!file) { if(!file) {
free(real_path); free(real_path);
return CURLE_OUT_OF_MEMORY; return CURLE_OUT_OF_MEMORY;
} }
data->reqdata.proto.file = file; data->state.proto.file = file;
} }
else { else {
/* file is not a protocol that can deal with "persistancy" */ /* file is not a protocol that can deal with "persistancy" */
file = data->reqdata.proto.file; file = data->state.proto.file;
Curl_safefree(file->freepath); Curl_safefree(file->freepath);
if(file->fd != -1) if(file->fd != -1)
close(file->fd); close(file->fd);
@@ -200,7 +200,7 @@ static CURLcode Curl_file_connect(struct connectdata *conn, bool *done)
file->fd = fd; file->fd = fd;
if(!data->set.upload && (fd == -1)) { 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); Curl_file_done(conn, CURLE_FILE_COULDNT_READ_FILE, FALSE);
return CURLE_FILE_COULDNT_READ_FILE; 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, static CURLcode Curl_file_done(struct connectdata *conn,
CURLcode status, bool premature) 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)status; /* not used */
(void)premature; /* not used */ (void)premature; /* not used */
Curl_safefree(file->freepath); Curl_safefree(file->freepath);
@@ -231,7 +231,7 @@ static CURLcode Curl_file_done(struct connectdata *conn,
static CURLcode file_upload(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); const char *dir = strchr(file->path, DIRSEP);
FILE *fp; FILE *fp;
CURLcode res=CURLE_OK; CURLcode res=CURLE_OK;
@@ -250,7 +250,7 @@ static CURLcode file_upload(struct connectdata *conn)
*/ */
conn->fread_func = data->set.fread_func; conn->fread_func = data->set.fread_func;
conn->fread_in = data->set.in; conn->fread_in = data->set.in;
conn->data->reqdata.upload_fromhere = buf; conn->data->req.upload_fromhere = buf;
if(!dir) if(!dir)
return CURLE_FILE_COULDNT_READ_FILE; /* fix: better error code */ return CURLE_FILE_COULDNT_READ_FILE; /* fix: better error code */
@@ -258,7 +258,7 @@ static CURLcode file_upload(struct connectdata *conn)
if(!dir[1]) if(!dir[1])
return CURLE_FILE_COULDNT_READ_FILE; /* fix: better error code */ 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" ); fp = fopen( file->path, "ab" );
else { else {
int fd; int fd;
@@ -287,14 +287,14 @@ static CURLcode file_upload(struct connectdata *conn)
Curl_pgrsSetUploadSize(data, data->set.infilesize); Curl_pgrsSetUploadSize(data, data->set.infilesize);
/* treat the negative resume offset value as the case of "-" */ /* 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)){ if(stat(file->path, &file_stat)){
fclose(fp); fclose(fp);
failf(data, "Can't get the size of %s", file->path); failf(data, "Can't get the size of %s", file->path);
return CURLE_WRITE_ERROR; return CURLE_WRITE_ERROR;
} }
else 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) { while(res == CURLE_OK) {
@@ -309,16 +309,16 @@ static CURLcode file_upload(struct connectdata *conn)
nread = (size_t)readcount; nread = (size_t)readcount;
/*skip bytes before resume point*/ /*skip bytes before resume point*/
if(data->reqdata.resume_from) { if(data->state.resume_from) {
if( (curl_off_t)nread <= data->reqdata.resume_from ) { if( (curl_off_t)nread <= data->state.resume_from ) {
data->reqdata.resume_from -= nread; data->state.resume_from -= nread;
nread = 0; nread = 0;
buf2 = buf; buf2 = buf;
} }
else { else {
buf2 = buf + data->reqdata.resume_from; buf2 = buf + data->state.resume_from;
nread -= data->reqdata.resume_from; nread -= data->state.resume_from;
data->reqdata.resume_from = 0; data->state.resume_from = 0;
} }
} }
else else
@@ -385,7 +385,7 @@ static CURLcode Curl_file(struct connectdata *conn, bool *done)
return file_upload(conn); return file_upload(conn);
/* get the fd from the connection phase */ /* 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 */ /* VMS: This only works reliable for STREAMLF files */
if( -1 != fstat(fd, &statbuf)) { if( -1 != fstat(fd, &statbuf)) {
@@ -434,8 +434,8 @@ static CURLcode Curl_file(struct connectdata *conn, bool *done)
return result; return result;
} }
if(data->reqdata.resume_from <= expected_size) if(data->state.resume_from <= expected_size)
expected_size -= data->reqdata.resume_from; expected_size -= data->state.resume_from;
else { else {
failf(data, "failed to resume file:// transfer"); failf(data, "failed to resume file:// transfer");
return CURLE_BAD_DOWNLOAD_RESUME; return CURLE_BAD_DOWNLOAD_RESUME;
@@ -451,9 +451,9 @@ static CURLcode Curl_file(struct connectdata *conn, bool *done)
if(fstated) if(fstated)
Curl_pgrsSetDownloadSize(data, expected_size); Curl_pgrsSetDownloadSize(data, expected_size);
if(data->reqdata.resume_from) { if(data->state.resume_from) {
if(data->reqdata.resume_from != if(data->state.resume_from !=
lseek(fd, data->reqdata.resume_from, SEEK_SET)) lseek(fd, data->state.resume_from, SEEK_SET))
return CURLE_BAD_DOWNLOAD_RESUME; 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; int clipamount = 0;
bool restart = FALSE; bool restart = FALSE;
data->reqdata.keep.headerbytecount += gotbytes; data->req.headerbytecount += gotbytes;
ftpc->nread_resp += gotbytes; ftpc->nread_resp += gotbytes;
for(i = 0; i < gotbytes; ptr++, i++) { 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) static CURLcode ftp_state_user(struct connectdata *conn)
{ {
CURLcode result; CURLcode result;
struct FTP *ftp = conn->data->reqdata.proto.ftp; struct FTP *ftp = conn->data->state.proto.ftp;
/* send USER */ /* send USER */
NBFTPSENDF(conn, "USER %s", ftp->user?ftp->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) static CURLcode ftp_state_post_rest(struct connectdata *conn)
{ {
CURLcode result = CURLE_OK; 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 SessionHandle *data = conn->data;
if(ftp->transfer != FTPTRANSFER_BODY) { 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) static CURLcode ftp_state_post_size(struct connectdata *conn)
{ {
CURLcode result = CURLE_OK; 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; struct ftp_conn *ftpc = &conn->proto.ftpc;
if((ftp->transfer != FTPTRANSFER_BODY) && ftpc->file) { 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) static CURLcode ftp_state_post_type(struct connectdata *conn)
{ {
CURLcode result = CURLE_OK; 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; struct ftp_conn *ftpc = &conn->proto.ftpc;
if((ftp->transfer == FTPTRANSFER_INFO) && ftpc->file) { if((ftp->transfer == FTPTRANSFER_INFO) && ftpc->file) {
@@ -1398,11 +1398,11 @@ static CURLcode ftp_state_post_listtype(struct connectdata *conn)
lstArg = NULL; lstArg = NULL;
if((data->set.ftp_filemethod == FTPFILE_NOCWD) && if((data->set.ftp_filemethod == FTPFILE_NOCWD) &&
data->reqdata.path && data->state.path &&
data->reqdata.path[0] && data->state.path[0] &&
strchr(data->reqdata.path,'/')) { strchr(data->state.path,'/')) {
lstArg = strdup(data->reqdata.path); lstArg = strdup(data->state.path);
if(!lstArg) if(!lstArg)
return CURLE_OUT_OF_MEMORY; 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) static CURLcode ftp_state_post_mdtm(struct connectdata *conn)
{ {
CURLcode result = CURLE_OK; 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 SessionHandle *data = conn->data;
struct ftp_conn *ftpc = &conn->proto.ftpc; struct ftp_conn *ftpc = &conn->proto.ftpc;
@@ -1522,13 +1522,13 @@ static CURLcode ftp_state_ul_setup(struct connectdata *conn,
bool sizechecked) bool sizechecked)
{ {
CURLcode result = CURLE_OK; 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 SessionHandle *data = conn->data;
struct ftp_conn *ftpc = &conn->proto.ftpc; struct ftp_conn *ftpc = &conn->proto.ftpc;
curl_off_t passed=0; curl_off_t passed=0;
if((data->reqdata.resume_from && !sizechecked) || if((data->state.resume_from && !sizechecked) ||
((data->reqdata.resume_from > 0) && sizechecked)) { ((data->state.resume_from > 0) && sizechecked)) {
/* we're about to continue the uploading of a file */ /* we're about to continue the uploading of a file */
/* 1. get already existing file's size. We use the SIZE command for this /* 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 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 */ /* 4. lower the infilesize counter */
/* => transfer as usual */ /* => 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 */ /* Got no given size to start from, figure it out */
NBFTPSENDF(conn, "SIZE %s", ftpc->file); NBFTPSENDF(conn, "SIZE %s", ftpc->file);
state(conn, FTP_STOR_SIZE); 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 /* TODO: allow the ioctlfunction to provide a fast forward function that
can be used here and use this method only as a fallback! */ can be used here and use this method only as a fallback! */
do { do {
curl_off_t readthisamountnow = (data->reqdata.resume_from - passed); curl_off_t readthisamountnow = (data->state.resume_from - passed);
curl_off_t actuallyread; curl_off_t actuallyread;
if(readthisamountnow > BUFSIZE) if(readthisamountnow > BUFSIZE)
@@ -1575,11 +1575,11 @@ static CURLcode ftp_state_ul_setup(struct connectdata *conn,
" bytes from the input", passed); " bytes from the input", passed);
return CURLE_FTP_COULDNT_USE_REST; 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 */ /* now, decrease the size of the read */
if(data->set.infilesize>0) { if(data->set.infilesize>0) {
data->set.infilesize -= data->reqdata.resume_from; data->set.infilesize -= data->state.resume_from;
if(data->set.infilesize <= 0) { if(data->set.infilesize <= 0) {
infof(data, "File already completely uploaded\n"); infof(data, "File already completely uploaded\n");
@@ -1612,7 +1612,7 @@ static CURLcode ftp_state_quote(struct connectdata *conn,
{ {
CURLcode result = CURLE_OK; CURLcode result = CURLE_OK;
struct SessionHandle *data = conn->data; 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; struct ftp_conn *ftpc = &conn->proto.ftpc;
bool quote=FALSE; bool quote=FALSE;
struct curl_slist *item; struct curl_slist *item;
@@ -1907,13 +1907,13 @@ static CURLcode ftp_state_pasv_resp(struct connectdata *conn,
* FTP pointer * FTP pointer
*/ */
struct HTTP http_proxy; 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)); 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); result = Curl_proxyCONNECT(conn, SECONDARYSOCKET, newhost, newport);
data->reqdata.proto.ftp = ftp_save; data->state.proto.ftp = ftp_save;
if(CURLE_OK != result) if(CURLE_OK != result)
return result; return result;
@@ -1963,7 +1963,7 @@ static CURLcode ftp_state_mdtm_resp(struct connectdata *conn,
{ {
CURLcode result = CURLE_OK; CURLcode result = CURLE_OK;
struct SessionHandle *data=conn->data; 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; struct ftp_conn *ftpc = &conn->proto.ftpc;
switch(ftpcode) { switch(ftpcode) {
@@ -2095,7 +2095,7 @@ static CURLcode ftp_state_post_retr_size(struct connectdata *conn,
{ {
CURLcode result = CURLE_OK; CURLcode result = CURLE_OK;
struct SessionHandle *data=conn->data; 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; struct ftp_conn *ftpc = &conn->proto.ftpc;
if(data->set.max_filesize && (filesize > data->set.max_filesize)) { 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; 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 /* We always (attempt to) get the size of downloads, so it is done before
this even when not doing resumes. */ this even when not doing resumes. */
if(filesize == -1) { if(filesize == -1) {
@@ -2117,28 +2117,28 @@ static CURLcode ftp_state_post_retr_size(struct connectdata *conn,
else { else {
/* We got a file size report, so we check that there actually is a /* 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. */ 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 */ /* 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 failf(data, "Offset (%" FORMAT_OFF_T
") was beyond file size (%" 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; return CURLE_BAD_DOWNLOAD_RESUME;
} }
/* convert to size to download */ /* convert to size to download */
ftp->downloadsize = -data->reqdata.resume_from; ftp->downloadsize = -data->state.resume_from;
/* download from where? */ /* download from where? */
data->reqdata.resume_from = filesize - ftp->downloadsize; data->state.resume_from = filesize - ftp->downloadsize;
} }
else { else {
if(filesize < data->reqdata.resume_from) { if(filesize < data->state.resume_from) {
failf(data, "Offset (%" FORMAT_OFF_T failf(data, "Offset (%" FORMAT_OFF_T
") was beyond file size (%" 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; return CURLE_BAD_DOWNLOAD_RESUME;
} }
/* Now store the number of bytes we are expected to download */ /* 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 */ /* Set resume file transfer offset */
infof(data, "Instructs server to resume from offset %" FORMAT_OFF_T 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); 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); result = ftp_state_post_retr_size(conn, filesize);
} }
else if(instate == FTP_STOR_SIZE) { else if(instate == FTP_STOR_SIZE) {
data->reqdata.resume_from = filesize; data->state.resume_from = filesize;
result = ftp_state_ul_setup(conn, TRUE); result = ftp_state_ul_setup(conn, TRUE);
} }
@@ -2250,7 +2250,7 @@ static CURLcode ftp_state_stor_resp(struct connectdata *conn,
{ {
CURLcode result = CURLE_OK; CURLcode result = CURLE_OK;
struct SessionHandle *data = conn->data; struct SessionHandle *data = conn->data;
struct FTP *ftp = data->reqdata.proto.ftp; struct FTP *ftp = data->state.proto.ftp;
if(ftpcode>=400) { if(ftpcode>=400) {
failf(data, "Failed FTP upload: %0d", ftpcode); failf(data, "Failed FTP upload: %0d", ftpcode);
@@ -2297,7 +2297,7 @@ static CURLcode ftp_state_get_resp(struct connectdata *conn,
{ {
CURLcode result = CURLE_OK; CURLcode result = CURLE_OK;
struct SessionHandle *data = conn->data; struct SessionHandle *data = conn->data;
struct FTP *ftp = data->reqdata.proto.ftp; struct FTP *ftp = data->state.proto.ftp;
char *buf = data->state.buffer; char *buf = data->state.buffer;
if((ftpcode == 150) || (ftpcode == 125)) { if((ftpcode == 150) || (ftpcode == 125)) {
@@ -2384,10 +2384,10 @@ static CURLcode ftp_state_get_resp(struct connectdata *conn,
return result; return result;
} }
if(size > data->reqdata.maxdownload && data->reqdata.maxdownload > 0) if(size > data->req.maxdownload && data->req.maxdownload > 0)
size = data->reqdata.size = data->reqdata.maxdownload; 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) if(instate != FTP_LIST)
infof(data, "Getting file with size: %" FORMAT_OFF_T "\n", size); 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; CURLcode result = CURLE_OK;
struct SessionHandle *data = conn->data; 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; struct ftp_conn *ftpc = &conn->proto.ftpc;
(void)instate; /* no use for this yet */ (void)instate; /* no use for this yet */
@@ -3009,17 +3009,17 @@ static CURLcode ftp_init(struct connectdata *conn)
{ {
struct SessionHandle *data = conn->data; struct SessionHandle *data = conn->data;
struct FTP *ftp; struct FTP *ftp;
if(data->reqdata.proto.ftp) if(data->state.proto.ftp)
return CURLE_OK; return CURLE_OK;
ftp = (struct FTP *)calloc(sizeof(struct FTP), 1); ftp = (struct FTP *)calloc(sizeof(struct FTP), 1);
if(!ftp) if(!ftp)
return CURLE_OUT_OF_MEMORY; return CURLE_OUT_OF_MEMORY;
data->reqdata.proto.ftp = ftp; data->state.proto.ftp = ftp;
/* get some initial data into the ftp struct */ /* 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 */ /* no need to duplicate them, this connectdata struct won't change */
ftp->user = conn->user; 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 * Curl_proxyCONNECT we have to set back the member to the original struct
* FTP pointer * FTP pointer
*/ */
ftp_save = data->reqdata.proto.ftp; ftp_save = data->state.proto.ftp;
memset(&http_proxy, 0, sizeof(http_proxy)); memset(&http_proxy, 0, sizeof(http_proxy));
data->reqdata.proto.http = &http_proxy; data->state.proto.http = &http_proxy;
result = Curl_proxyCONNECT(conn, FIRSTSOCKET, result = Curl_proxyCONNECT(conn, FIRSTSOCKET,
conn->host.name, conn->remote_port); conn->host.name, conn->remote_port);
data->reqdata.proto.ftp = ftp_save; data->state.proto.ftp = ftp_save;
if(CURLE_OK != result) if(CURLE_OK != result)
return result; return result;
@@ -3129,15 +3129,14 @@ static CURLcode Curl_ftp_done(struct connectdata *conn, CURLcode status,
bool premature) bool premature)
{ {
struct SessionHandle *data = conn->data; 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; struct ftp_conn *ftpc = &conn->proto.ftpc;
ssize_t nread; ssize_t nread;
int ftpcode; int ftpcode;
CURLcode result=CURLE_OK; CURLcode result=CURLE_OK;
bool was_ctl_valid = ftpc->ctl_valid; bool was_ctl_valid = ftpc->ctl_valid;
char *path; char *path;
char *path_to_use = data->reqdata.path; char *path_to_use = data->state.path;
struct Curl_transfer_keeper *k = &data->reqdata.keep;
if(!ftp) if(!ftp)
/* When the easy handle is removed from the multi while libcurl is still /* 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 { else {
if((-1 != k->size) && (k->size != *ftp->bytecountp) && if((-1 != data->req.size) &&
(data->req.size != *ftp->bytecountp) &&
#ifdef CURL_DO_LINEEND_CONV #ifdef CURL_DO_LINEEND_CONV
/* Most FTP servers don't adjust their file SIZE response for CRLFs, so /* 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 * we'll check to see if the discrepancy can be explained by the number
* of CRLFs we've changed to LFs. * 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 */ #endif /* CURL_DO_LINEEND_CONV */
(k->maxdownload != *ftp->bytecountp)) { (data->req.maxdownload != *ftp->bytecountp)) {
failf(data, "Received only partial file: %" FORMAT_OFF_T " bytes", failf(data, "Received only partial file: %" FORMAT_OFF_T " bytes",
*ftp->bytecountp); *ftp->bytecountp);
result = CURLE_PARTIAL_FILE; result = CURLE_PARTIAL_FILE;
} }
else if(!ftpc->dont_check && else if(!ftpc->dont_check &&
!*ftp->bytecountp && !*ftp->bytecountp &&
(k->size>0)) { (data->req.size>0)) {
failf(data, "No data was received!"); failf(data, "No data was received!");
result = CURLE_FTP_COULDNT_RETR_FILE; result = CURLE_FTP_COULDNT_RETR_FILE;
} }
@@ -3426,8 +3427,8 @@ static CURLcode ftp_range(struct connectdata *conn)
struct SessionHandle *data = conn->data; struct SessionHandle *data = conn->data;
struct ftp_conn *ftpc = &conn->proto.ftpc; struct ftp_conn *ftpc = &conn->proto.ftpc;
if(data->reqdata.use_range && data->reqdata.range) { if(data->state.use_range && data->state.range) {
from=curlx_strtoofft(data->reqdata.range, &ptr, 0); from=curlx_strtoofft(data->state.range, &ptr, 0);
while(ptr && *ptr && (ISSPACE(*ptr) || (*ptr=='-'))) while(ptr && *ptr && (ISSPACE(*ptr) || (*ptr=='-')))
ptr++; ptr++;
to=curlx_strtoofft(ptr, &ptr2, 0); to=curlx_strtoofft(ptr, &ptr2, 0);
@@ -3437,34 +3438,34 @@ static CURLcode ftp_range(struct connectdata *conn)
} }
if((-1 == to) && (from>=0)) { if((-1 == to) && (from>=0)) {
/* X - */ /* 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", DEBUGF(infof(conn->data, "FTP RANGE %" FORMAT_OFF_T " to end of file\n",
from)); from));
} }
else if(from < 0) { else if(from < 0) {
/* -Y */ /* -Y */
totalsize = -from; totalsize = -from;
data->reqdata.maxdownload = -from; data->req.maxdownload = -from;
data->reqdata.resume_from = from; data->state.resume_from = from;
DEBUGF(infof(conn->data, "FTP RANGE the last %" FORMAT_OFF_T " bytes\n", DEBUGF(infof(conn->data, "FTP RANGE the last %" FORMAT_OFF_T " bytes\n",
totalsize)); totalsize));
} }
else { else {
/* X-Y */ /* X-Y */
totalsize = to-from; totalsize = to-from;
data->reqdata.maxdownload = totalsize+1; /* include last byte */ data->req.maxdownload = totalsize+1; /* include last byte */
data->reqdata.resume_from = from; data->state.resume_from = from;
DEBUGF(infof(conn->data, "FTP RANGE from %" FORMAT_OFF_T DEBUGF(infof(conn->data, "FTP RANGE from %" FORMAT_OFF_T
" getting %" FORMAT_OFF_T " bytes\n", " getting %" FORMAT_OFF_T " bytes\n",
from, data->reqdata.maxdownload)); from, data->req.maxdownload));
} }
DEBUGF(infof(conn->data, "range-download from %" FORMAT_OFF_T DEBUGF(infof(conn->data, "range-download from %" FORMAT_OFF_T
" to %" FORMAT_OFF_T ", totally %" FORMAT_OFF_T " bytes\n", " 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 */ ftpc->dont_check = TRUE; /* dont check for successful transfer */
} }
else else
data->reqdata.maxdownload = -1; data->req.maxdownload = -1;
return CURLE_OK; return CURLE_OK;
} }
@@ -3483,7 +3484,7 @@ static CURLcode Curl_ftp_nextconnect(struct connectdata *conn)
CURLcode result = CURLE_OK; CURLcode result = CURLE_OK;
/* the ftp struct is inited in Curl_ftp_connect() */ /* 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")); DEBUGF(infof(data, "DO-MORE phase starts\n"));
@@ -3558,7 +3559,7 @@ CURLcode ftp_perform(struct connectdata *conn,
if(conn->bits.no_body) { if(conn->bits.no_body) {
/* requested no body means no transfer... */ /* 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; ftp->transfer = FTPTRANSFER_INFO;
} }
@@ -3840,11 +3841,11 @@ CURLcode ftp_parse_url_path(struct connectdata *conn)
{ {
struct SessionHandle *data = conn->data; struct SessionHandle *data = conn->data;
/* the ftp struct is already inited in ftp_connect() */ /* 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; struct ftp_conn *ftpc = &conn->proto.ftpc;
size_t dlen; size_t dlen;
char *slash_pos; /* position of the first '/' char in curpos */ 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; char *cur_pos;
cur_pos = path_to_use; /* current position in path. point at the begin 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 the first condition in the if() right here, is there just in case
someone decides to set path to NULL one day someone decides to set path to NULL one day
*/ */
if(data->reqdata.path && if(data->state.path &&
data->reqdata.path[0] && data->state.path[0] &&
(data->reqdata.path[strlen(data->reqdata.path) - 1] != '/') ) (data->state.path[strlen(data->state.path) - 1] != '/') )
ftpc->file = data->reqdata.path; /* this is a full file path */ ftpc->file = data->state.path; /* this is a full file path */
else else
ftpc->file = NULL; ftpc->file = NULL;
/* /*
@@ -3924,7 +3925,7 @@ CURLcode ftp_parse_url_path(struct connectdata *conn)
/* parse the URL path into separate path components */ /* parse the URL path into separate path components */
while((slash_pos = strchr(cur_pos, '/')) != NULL) { while((slash_pos = strchr(cur_pos, '/')) != NULL) {
/* 1 or 0 to indicate absolute directory */ /* 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)); (ftpc->dirdepth == 0));
/* seek out the next path component */ /* seek out the next path component */
@@ -3995,7 +3996,7 @@ CURLcode ftp_parse_url_path(struct connectdata *conn)
if(ftpc->prevpath) { if(ftpc->prevpath) {
/* prevpath is "raw" so we convert the input path before we compare the /* prevpath is "raw" so we convert the input path before we compare the
strings */ 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) { if(!path) {
freedirs(ftpc); freedirs(ftpc);
return CURLE_OUT_OF_MEMORY; return CURLE_OUT_OF_MEMORY;
@@ -4018,7 +4019,7 @@ static CURLcode ftp_dophase_done(struct connectdata *conn,
bool connected) bool connected)
{ {
CURLcode result = CURLE_OK; 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; struct ftp_conn *ftpc = &conn->proto.ftpc;
if(connected) if(connected)
@@ -4078,7 +4079,7 @@ CURLcode ftp_regular_transfer(struct connectdata *conn,
bool connected=0; bool connected=0;
struct SessionHandle *data = conn->data; struct SessionHandle *data = conn->data;
struct ftp_conn *ftpc = &conn->proto.ftpc; 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_pgrsSetUploadCounter(data, 0);
Curl_pgrsSetDownloadCounter(data, 0); Curl_pgrsSetDownloadCounter(data, 0);
@@ -4134,11 +4135,11 @@ static CURLcode Curl_ftp_setup_connection(struct connectdata * conn)
#endif #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 /* FTP URLs support an extension like ";type=<typecode>" that
* we'll try to get now! */ * we'll try to get now! */
type = strstr(data->reqdata.path, ";type="); type = strstr(data->state.path, ";type=");
if(!type) if(!type)
type = strstr(conn->host.rawalloc, ";type="); type = strstr(conn->host.rawalloc, ";type=");

130
lib/http.c
View File

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

12
lib/multi.c
View File

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

7
lib/progress.c
View File

@@ -356,11 +356,10 @@ int Curl_pgrsUpdate(struct connectdata *conn)
progress */ progress */
if(!(data->progress.flags & PGRS_HEADERS_OUT)) { if(!(data->progress.flags & PGRS_HEADERS_OUT)) {
if(data->reqdata.resume_from) { if(data->state.resume_from) {
fprintf(data->set.err, fprintf(data->set.err,
"** Resuming transfer from byte position %" FORMAT_OFF_T "** Resuming transfer from byte position %" FORMAT_OFF_T "\n",
"\n", data->state.resume_from);
data->reqdata.resume_from);
} }
fprintf(data->set.err, fprintf(data->set.err,
" %% Total %% Received %% Xferd Average Speed Time Time Time Current\n" " %% 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; char *working_path;
int working_path_len; 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); &working_path_len);
if(!working_path) if(!working_path)
return CURLE_OUT_OF_MEMORY; return CURLE_OUT_OF_MEMORY;
@@ -432,7 +432,7 @@ static CURLcode ssh_statemach_act(struct connectdata *conn)
{ {
CURLcode result = CURLE_OK; CURLcode result = CURLE_OK;
struct SessionHandle *data = conn->data; 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; struct ssh_conn *sshc = &conn->proto.sshc;
curl_socket_t sock = conn->sock[FIRSTSOCKET]; curl_socket_t sock = conn->sock[FIRSTSOCKET];
#ifdef CURL_LIBSSH2_DEBUG #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 /* since this counts what we send to the client, we include the newline
in this counter */ 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 */ /* output debug output if that is requested */
if(data->set.verbose) { 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, Curl_debug(data, CURLINFO_DATA_OUT, sshc->readdir_line,
sshc->readdir_currLen, conn); sshc->readdir_currLen, conn);
} }
data->reqdata.keep.bytecount += sshc->readdir_currLen; data->req.bytecount += sshc->readdir_currLen;
} }
Curl_safefree(sshc->readdir_line); Curl_safefree(sshc->readdir_line);
sshc->readdir_line = NULL; 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 * libssh2_sftp_open() didn't return an error, so maybe the server
* just doesn't support stat() * just doesn't support stat()
*/ */
data->reqdata.size = -1; data->req.size = -1;
data->reqdata.maxdownload = -1; data->req.maxdownload = -1;
} }
else { else {
data->reqdata.size = attrs.filesize; data->req.size = attrs.filesize;
data->reqdata.maxdownload = attrs.filesize; data->req.maxdownload = attrs.filesize;
Curl_pgrsSetDownloadSize(data, attrs.filesize); Curl_pgrsSetDownloadSize(data, attrs.filesize);
} }
} }
/* Setup the actual download */ /* 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); FALSE, NULL, -1, NULL);
if(result) { if(result) {
state(conn, SSH_SFTP_CLOSE); state(conn, SSH_SFTP_CLOSE);
@@ -1648,7 +1648,7 @@ static CURLcode ssh_statemach_act(struct connectdata *conn)
} }
/* upload data */ /* 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); FIRSTSOCKET, NULL);
if(result) { if(result) {
@@ -1696,7 +1696,7 @@ static CURLcode ssh_statemach_act(struct connectdata *conn)
/* download data */ /* download data */
bytecount = (curl_off_t)sb.st_size; 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, result = Curl_setup_transfer(conn, FIRSTSOCKET,
bytecount, FALSE, NULL, -1, NULL); bytecount, FALSE, NULL, -1, NULL);
@@ -1849,14 +1849,14 @@ static CURLcode ssh_init(struct connectdata *conn)
{ {
struct SessionHandle *data = conn->data; struct SessionHandle *data = conn->data;
struct SSHPROTO *ssh; struct SSHPROTO *ssh;
if(data->reqdata.proto.ssh) if(data->state.proto.ssh)
return CURLE_OK; return CURLE_OK;
ssh = (struct SSHPROTO *)calloc(sizeof(struct SSHPROTO), 1); ssh = (struct SSHPROTO *)calloc(sizeof(struct SSHPROTO), 1);
if(!ssh) if(!ssh)
return CURLE_OUT_OF_MEMORY; return CURLE_OUT_OF_MEMORY;
data->reqdata.proto.ssh = ssh; data->state.proto.ssh = ssh;
return CURLE_OK; return CURLE_OK;
} }
@@ -1989,7 +1989,7 @@ static CURLcode ssh_do(struct connectdata *conn, bool *done)
*done = FALSE; /* default to false */ *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_pgrsSetUploadCounter(data, 0);
Curl_pgrsSetDownloadCounter(data, 0); Curl_pgrsSetDownloadCounter(data, 0);
@@ -2011,8 +2011,8 @@ static CURLcode scp_disconnect(struct connectdata *conn)
{ {
CURLcode result; CURLcode result;
Curl_safefree(conn->data->reqdata.proto.ssh); Curl_safefree(conn->data->state.proto.ssh);
conn->data->reqdata.proto.ssh = NULL; conn->data->state.proto.ssh = NULL;
state(conn, SSH_SESSION_DISCONNECT); state(conn, SSH_SESSION_DISCONNECT);
@@ -2046,7 +2046,7 @@ static CURLcode scp_done(struct connectdata *conn, CURLcode status,
} }
if(done) { 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); Curl_safefree(sftp_scp->path);
sftp_scp->path = NULL; sftp_scp->path = NULL;
Curl_pgrsDone(conn); Curl_pgrsDone(conn);
@@ -2154,8 +2154,8 @@ static CURLcode sftp_disconnect(struct connectdata *conn)
DEBUGF(infof(conn->data, "SSH DISCONNECT starts now\n")); DEBUGF(infof(conn->data, "SSH DISCONNECT starts now\n"));
Curl_safefree(conn->data->reqdata.proto.ssh); Curl_safefree(conn->data->state.proto.ssh);
conn->data->reqdata.proto.ssh = NULL; conn->data->state.proto.ssh = NULL;
state(conn, SSH_SFTP_SHUTDOWN); state(conn, SSH_SFTP_SHUTDOWN);
result = ssh_easy_statemach(conn); result = ssh_easy_statemach(conn);

30
lib/telnet.c
View File

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

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

82
lib/url.c
View File

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

148
lib/urldata.h
View File

@@ -646,16 +646,36 @@ typedef enum {
} zlibInitState; } zlibInitState;
#endif #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 * Request specific data in the easy handle (SessionHandle). Previously,
* to struct to allow the function to return and get re-invoked better without * these members were on the connectdata struct but since a conn struct may
* losing state. * 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 SingleRequest {
struct Curl_transfer_keeper {
/** Values copied over from the HandleData struct each time on init **/
curl_off_t size; /* -1 if unknown at this point */ curl_off_t size; /* -1 if unknown at this point */
curl_off_t *bytecountp; /* return number of bytes read or NULL */ curl_off_t *bytecountp; /* return number of bytes read or NULL */
@@ -663,16 +683,14 @@ struct Curl_transfer_keeper {
-1 means unlimited */ -1 means unlimited */
curl_off_t *writebytecountp; /* return number of bytes written or NULL */ 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 bytecount; /* total number of bytes read */
curl_off_t writebytecount; /* number of bytes written */ 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 long deductheadercount; /* this amount of bytes doesn't count when we check
if anything has been transfered at the end of if anything has been transfered at the end of a
a connection. We use this counter to make only connection. We use this counter to make only a
a 100 reply (without a following second response 100 reply (without a following second response
code) result in a CURLE_GOT_NOTHING error code */ code) result in a CURLE_GOT_NOTHING error code */
struct timeval start; /* transfer started at this time */ struct timeval start; /* transfer started at this time */
@@ -733,48 +751,10 @@ struct Curl_transfer_keeper {
bool ignorebody; /* we read a response-body but we ignore it! */ bool ignorebody; /* we read a response-body but we ignore it! */
bool ignorecl; /* This HTTP response has no body so we ignore the Content- bool ignorecl; /* This HTTP response has no body so we ignore the Content-
Length: header */ 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 char *newurl; /* This can only be set if a Location: was in the
document headers */ 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 /* 'upload_present' is used to keep a byte counter of how much data there is
still left in the buffer, aimed for upload. */ still left in the buffer, aimed for upload. */
ssize_t upload_present; ssize_t upload_present;
@@ -784,40 +764,6 @@ struct HandleData {
and the 'upload_present' contains the number of bytes available at this and the 'upload_present' contains the number of bytes available at this
position */ position */
char *upload_fromhere; 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 bool closed; /* set to TRUE when curl_easy_cleanup() has been called on this
handle, but it is kept around as mentioned for handle, but it is kept around as mentioned for
shared_conn */ 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 multi controlling structure to assist
in removal. */ in removal. */
struct Curl_share *share; /* Share, handles global variable mutexing */ 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 UserDefined set; /* values set by the libcurl user */
struct DynamicStatic change; /* possibly modified userdefined data */ struct DynamicStatic change; /* possibly modified userdefined data */
struct CookieInfo *cookies; /* the cookies, read from files and servers. struct CookieInfo *cookies; /* the cookies, read from files and servers.