static CURLcode
inflate_stream(struct connectdata *conn,
- struct Curl_transfer_keeper *k)
+ struct SingleRequest *k)
{
int allow_restart = 1;
z_stream *z = &k->z; /* zlib state structure */
CURLcode
Curl_unencode_deflate_write(struct connectdata *conn,
- struct Curl_transfer_keeper *k,
+ struct SingleRequest *k,
ssize_t nread)
{
z_stream *z = &k->z; /* zlib state structure */
CURLcode
Curl_unencode_gzip_write(struct connectdata *conn,
- struct Curl_transfer_keeper *k,
+ struct SingleRequest *k,
ssize_t nread)
{
z_stream *z = &k->z; /* zlib state structure */
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2006, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2007, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
#endif
CURLcode Curl_unencode_deflate_write(struct connectdata *conn,
- struct Curl_transfer_keeper *k,
+ struct SingleRequest *req,
ssize_t nread);
CURLcode
Curl_unencode_gzip_write(struct connectdata *conn,
- struct Curl_transfer_keeper *k,
+ struct SingleRequest *k,
ssize_t nread);
struct SessionHandle *data=conn->data;
curl_socket_t sockfd = conn->sock[FIRSTSOCKET];
- char *path = data->reqdata.path;
- curl_off_t *bytecount = &data->reqdata.keep.bytecount;
+ char *path = data->state.path;
+ curl_off_t *bytecount = &data->req.bytecount;
*done = TRUE; /* unconditionally */
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;
}
/*
{
struct SessionHandle *data = (struct SessionHandle *)curl;
- Curl_safefree(data->reqdata.pathbuffer);
- data->reqdata.pathbuffer=NULL;
+ Curl_safefree(data->state.pathbuffer);
+ data->state.pathbuffer=NULL;
- Curl_safefree(data->reqdata.proto.generic);
- data->reqdata.proto.generic=NULL;
+ Curl_safefree(data->state.proto.generic);
+ data->state.proto.generic=NULL;
/* zero out UserDefined data: */
Curl_freeset(data);
static CURLcode Curl_file_connect(struct connectdata *conn, bool *done)
{
struct SessionHandle *data = conn->data;
- char *real_path = curl_easy_unescape(data, data->reqdata.path, 0, NULL);
+ char *real_path = curl_easy_unescape(data, data->state.path, 0, NULL);
struct FILEPROTO *file;
int fd;
#if defined(WIN32) || defined(MSDOS) || defined(__EMX__)
sessionhandle, deal with it */
Curl_reset_reqproto(conn);
- if(!data->reqdata.proto.file) {
+ if(!data->state.proto.file) {
file = (struct FILEPROTO *)calloc(sizeof(struct FILEPROTO), 1);
if(!file) {
free(real_path);
return CURLE_OUT_OF_MEMORY;
}
- data->reqdata.proto.file = file;
+ data->state.proto.file = file;
}
else {
/* file is not a protocol that can deal with "persistancy" */
- file = data->reqdata.proto.file;
+ file = data->state.proto.file;
Curl_safefree(file->freepath);
if(file->fd != -1)
close(file->fd);
file->fd = fd;
if(!data->set.upload && (fd == -1)) {
- failf(data, "Couldn't open file %s", data->reqdata.path);
+ failf(data, "Couldn't open file %s", data->state.path);
Curl_file_done(conn, CURLE_FILE_COULDNT_READ_FILE, FALSE);
return CURLE_FILE_COULDNT_READ_FILE;
}
static CURLcode Curl_file_done(struct connectdata *conn,
CURLcode status, bool premature)
{
- struct FILEPROTO *file = conn->data->reqdata.proto.file;
+ struct FILEPROTO *file = conn->data->state.proto.file;
(void)status; /* not used */
(void)premature; /* not used */
Curl_safefree(file->freepath);
static CURLcode file_upload(struct connectdata *conn)
{
- struct FILEPROTO *file = conn->data->reqdata.proto.file;
+ struct FILEPROTO *file = conn->data->state.proto.file;
const char *dir = strchr(file->path, DIRSEP);
FILE *fp;
CURLcode res=CURLE_OK;
*/
conn->fread_func = data->set.fread_func;
conn->fread_in = data->set.in;
- conn->data->reqdata.upload_fromhere = buf;
+ conn->data->req.upload_fromhere = buf;
if(!dir)
return CURLE_FILE_COULDNT_READ_FILE; /* fix: better error code */
if(!dir[1])
return CURLE_FILE_COULDNT_READ_FILE; /* fix: better error code */
- if(data->reqdata.resume_from)
+ if(data->state.resume_from)
fp = fopen( file->path, "ab" );
else {
int fd;
Curl_pgrsSetUploadSize(data, data->set.infilesize);
/* treat the negative resume offset value as the case of "-" */
- if(data->reqdata.resume_from < 0){
+ if(data->state.resume_from < 0){
if(stat(file->path, &file_stat)){
fclose(fp);
failf(data, "Can't get the size of %s", file->path);
return CURLE_WRITE_ERROR;
}
else
- data->reqdata.resume_from = (curl_off_t)file_stat.st_size;
+ data->state.resume_from = (curl_off_t)file_stat.st_size;
}
while(res == CURLE_OK) {
nread = (size_t)readcount;
/*skip bytes before resume point*/
- if(data->reqdata.resume_from) {
- if( (curl_off_t)nread <= data->reqdata.resume_from ) {
- data->reqdata.resume_from -= nread;
+ if(data->state.resume_from) {
+ if( (curl_off_t)nread <= data->state.resume_from ) {
+ data->state.resume_from -= nread;
nread = 0;
buf2 = buf;
}
else {
- buf2 = buf + data->reqdata.resume_from;
- nread -= data->reqdata.resume_from;
- data->reqdata.resume_from = 0;
+ buf2 = buf + data->state.resume_from;
+ nread -= data->state.resume_from;
+ data->state.resume_from = 0;
}
}
else
return file_upload(conn);
/* get the fd from the connection phase */
- fd = conn->data->reqdata.proto.file->fd;
+ fd = conn->data->state.proto.file->fd;
/* VMS: This only works reliable for STREAMLF files */
if( -1 != fstat(fd, &statbuf)) {
return result;
}
- if(data->reqdata.resume_from <= expected_size)
- expected_size -= data->reqdata.resume_from;
+ if(data->state.resume_from <= expected_size)
+ expected_size -= data->state.resume_from;
else {
failf(data, "failed to resume file:// transfer");
return CURLE_BAD_DOWNLOAD_RESUME;
if(fstated)
Curl_pgrsSetDownloadSize(data, expected_size);
- if(data->reqdata.resume_from) {
- if(data->reqdata.resume_from !=
- lseek(fd, data->reqdata.resume_from, SEEK_SET))
+ if(data->state.resume_from) {
+ if(data->state.resume_from !=
+ lseek(fd, data->state.resume_from, SEEK_SET))
return CURLE_BAD_DOWNLOAD_RESUME;
}
int clipamount = 0;
bool restart = FALSE;
- data->reqdata.keep.headerbytecount += gotbytes;
+ data->req.headerbytecount += gotbytes;
ftpc->nread_resp += gotbytes;
for(i = 0; i < gotbytes; ptr++, i++) {
static CURLcode ftp_state_user(struct connectdata *conn)
{
CURLcode result;
- struct FTP *ftp = conn->data->reqdata.proto.ftp;
+ struct FTP *ftp = conn->data->state.proto.ftp;
/* send USER */
NBFTPSENDF(conn, "USER %s", ftp->user?ftp->user:"");
static CURLcode ftp_state_post_rest(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
- struct FTP *ftp = conn->data->reqdata.proto.ftp;
+ struct FTP *ftp = conn->data->state.proto.ftp;
struct SessionHandle *data = conn->data;
if(ftp->transfer != FTPTRANSFER_BODY) {
static CURLcode ftp_state_post_size(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
- struct FTP *ftp = conn->data->reqdata.proto.ftp;
+ struct FTP *ftp = conn->data->state.proto.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if((ftp->transfer != FTPTRANSFER_BODY) && ftpc->file) {
static CURLcode ftp_state_post_type(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
- struct FTP *ftp = conn->data->reqdata.proto.ftp;
+ struct FTP *ftp = conn->data->state.proto.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if((ftp->transfer == FTPTRANSFER_INFO) && ftpc->file) {
lstArg = NULL;
if((data->set.ftp_filemethod == FTPFILE_NOCWD) &&
- data->reqdata.path &&
- data->reqdata.path[0] &&
- strchr(data->reqdata.path,'/')) {
+ data->state.path &&
+ data->state.path[0] &&
+ strchr(data->state.path,'/')) {
- lstArg = strdup(data->reqdata.path);
+ lstArg = strdup(data->state.path);
if(!lstArg)
return CURLE_OUT_OF_MEMORY;
static CURLcode ftp_state_post_mdtm(struct connectdata *conn)
{
CURLcode result = CURLE_OK;
- struct FTP *ftp = conn->data->reqdata.proto.ftp;
+ struct FTP *ftp = conn->data->state.proto.ftp;
struct SessionHandle *data = conn->data;
struct ftp_conn *ftpc = &conn->proto.ftpc;
bool sizechecked)
{
CURLcode result = CURLE_OK;
- struct FTP *ftp = conn->data->reqdata.proto.ftp;
+ struct FTP *ftp = conn->data->state.proto.ftp;
struct SessionHandle *data = conn->data;
struct ftp_conn *ftpc = &conn->proto.ftpc;
curl_off_t passed=0;
- if((data->reqdata.resume_from && !sizechecked) ||
- ((data->reqdata.resume_from > 0) && sizechecked)) {
+ if((data->state.resume_from && !sizechecked) ||
+ ((data->state.resume_from > 0) && sizechecked)) {
/* we're about to continue the uploading of a file */
/* 1. get already existing file's size. We use the SIZE command for this
which may not exist in the server! The SIZE command is not in
/* 4. lower the infilesize counter */
/* => transfer as usual */
- if(data->reqdata.resume_from < 0 ) {
+ if(data->state.resume_from < 0 ) {
/* Got no given size to start from, figure it out */
NBFTPSENDF(conn, "SIZE %s", ftpc->file);
state(conn, FTP_STOR_SIZE);
/* TODO: allow the ioctlfunction to provide a fast forward function that
can be used here and use this method only as a fallback! */
do {
- curl_off_t readthisamountnow = (data->reqdata.resume_from - passed);
+ curl_off_t readthisamountnow = (data->state.resume_from - passed);
curl_off_t actuallyread;
if(readthisamountnow > BUFSIZE)
" bytes from the input", passed);
return CURLE_FTP_COULDNT_USE_REST;
}
- } while(passed != data->reqdata.resume_from);
+ } while(passed != data->state.resume_from);
/* now, decrease the size of the read */
if(data->set.infilesize>0) {
- data->set.infilesize -= data->reqdata.resume_from;
+ data->set.infilesize -= data->state.resume_from;
if(data->set.infilesize <= 0) {
infof(data, "File already completely uploaded\n");
{
CURLcode result = CURLE_OK;
struct SessionHandle *data = conn->data;
- struct FTP *ftp = data->reqdata.proto.ftp;
+ struct FTP *ftp = data->state.proto.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
bool quote=FALSE;
struct curl_slist *item;
* FTP pointer
*/
struct HTTP http_proxy;
- struct FTP *ftp_save = data->reqdata.proto.ftp;
+ struct FTP *ftp_save = data->state.proto.ftp;
memset(&http_proxy, 0, sizeof(http_proxy));
- data->reqdata.proto.http = &http_proxy;
+ data->state.proto.http = &http_proxy;
result = Curl_proxyCONNECT(conn, SECONDARYSOCKET, newhost, newport);
- data->reqdata.proto.ftp = ftp_save;
+ data->state.proto.ftp = ftp_save;
if(CURLE_OK != result)
return result;
{
CURLcode result = CURLE_OK;
struct SessionHandle *data=conn->data;
- struct FTP *ftp = data->reqdata.proto.ftp;
+ struct FTP *ftp = data->state.proto.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
switch(ftpcode) {
{
CURLcode result = CURLE_OK;
struct SessionHandle *data=conn->data;
- struct FTP *ftp = data->reqdata.proto.ftp;
+ struct FTP *ftp = data->state.proto.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if(data->set.max_filesize && (filesize > data->set.max_filesize)) {
}
ftp->downloadsize = filesize;
- if(data->reqdata.resume_from) {
+ if(data->state.resume_from) {
/* We always (attempt to) get the size of downloads, so it is done before
this even when not doing resumes. */
if(filesize == -1) {
else {
/* We got a file size report, so we check that there actually is a
part of the file left to get, or else we go home. */
- if(data->reqdata.resume_from< 0) {
+ if(data->state.resume_from< 0) {
/* We're supposed to download the last abs(from) bytes */
- if(filesize < -data->reqdata.resume_from) {
+ if(filesize < -data->state.resume_from) {
failf(data, "Offset (%" FORMAT_OFF_T
") was beyond file size (%" FORMAT_OFF_T ")",
- data->reqdata.resume_from, filesize);
+ data->state.resume_from, filesize);
return CURLE_BAD_DOWNLOAD_RESUME;
}
/* convert to size to download */
- ftp->downloadsize = -data->reqdata.resume_from;
+ ftp->downloadsize = -data->state.resume_from;
/* download from where? */
- data->reqdata.resume_from = filesize - ftp->downloadsize;
+ data->state.resume_from = filesize - ftp->downloadsize;
}
else {
- if(filesize < data->reqdata.resume_from) {
+ if(filesize < data->state.resume_from) {
failf(data, "Offset (%" FORMAT_OFF_T
") was beyond file size (%" FORMAT_OFF_T ")",
- data->reqdata.resume_from, filesize);
+ data->state.resume_from, filesize);
return CURLE_BAD_DOWNLOAD_RESUME;
}
/* Now store the number of bytes we are expected to download */
- ftp->downloadsize = filesize-data->reqdata.resume_from;
+ ftp->downloadsize = filesize-data->state.resume_from;
}
}
/* Set resume file transfer offset */
infof(data, "Instructs server to resume from offset %" FORMAT_OFF_T
- "\n", data->reqdata.resume_from);
+ "\n", data->state.resume_from);
- NBFTPSENDF(conn, "REST %" FORMAT_OFF_T, data->reqdata.resume_from);
+ NBFTPSENDF(conn, "REST %" FORMAT_OFF_T, data->state.resume_from);
state(conn, FTP_RETR_REST);
result = ftp_state_post_retr_size(conn, filesize);
}
else if(instate == FTP_STOR_SIZE) {
- data->reqdata.resume_from = filesize;
+ data->state.resume_from = filesize;
result = ftp_state_ul_setup(conn, TRUE);
}
{
CURLcode result = CURLE_OK;
struct SessionHandle *data = conn->data;
- struct FTP *ftp = data->reqdata.proto.ftp;
+ struct FTP *ftp = data->state.proto.ftp;
if(ftpcode>=400) {
failf(data, "Failed FTP upload: %0d", ftpcode);
{
CURLcode result = CURLE_OK;
struct SessionHandle *data = conn->data;
- struct FTP *ftp = data->reqdata.proto.ftp;
+ struct FTP *ftp = data->state.proto.ftp;
char *buf = data->state.buffer;
if((ftpcode == 150) || (ftpcode == 125)) {
return result;
}
- if(size > data->reqdata.maxdownload && data->reqdata.maxdownload > 0)
- size = data->reqdata.size = data->reqdata.maxdownload;
+ if(size > data->req.maxdownload && data->req.maxdownload > 0)
+ size = data->req.size = data->req.maxdownload;
- infof(data, "Maxdownload = %" FORMAT_OFF_T "\n", data->reqdata.maxdownload);
+ infof(data, "Maxdownload = %" FORMAT_OFF_T "\n", data->req.maxdownload);
if(instate != FTP_LIST)
infof(data, "Getting file with size: %" FORMAT_OFF_T "\n", size);
{
CURLcode result = CURLE_OK;
struct SessionHandle *data = conn->data;
- struct FTP *ftp = data->reqdata.proto.ftp;
+ struct FTP *ftp = data->state.proto.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
(void)instate; /* no use for this yet */
{
struct SessionHandle *data = conn->data;
struct FTP *ftp;
- if(data->reqdata.proto.ftp)
+ if(data->state.proto.ftp)
return CURLE_OK;
ftp = (struct FTP *)calloc(sizeof(struct FTP), 1);
if(!ftp)
return CURLE_OUT_OF_MEMORY;
- data->reqdata.proto.ftp = ftp;
+ data->state.proto.ftp = ftp;
/* get some initial data into the ftp struct */
- ftp->bytecountp = &data->reqdata.keep.bytecount;
+ ftp->bytecountp = &data->req.bytecount;
/* no need to duplicate them, this connectdata struct won't change */
ftp->user = conn->user;
* Curl_proxyCONNECT we have to set back the member to the original struct
* FTP pointer
*/
- ftp_save = data->reqdata.proto.ftp;
+ ftp_save = data->state.proto.ftp;
memset(&http_proxy, 0, sizeof(http_proxy));
- data->reqdata.proto.http = &http_proxy;
+ data->state.proto.http = &http_proxy;
result = Curl_proxyCONNECT(conn, FIRSTSOCKET,
conn->host.name, conn->remote_port);
- data->reqdata.proto.ftp = ftp_save;
+ data->state.proto.ftp = ftp_save;
if(CURLE_OK != result)
return result;
bool premature)
{
struct SessionHandle *data = conn->data;
- struct FTP *ftp = data->reqdata.proto.ftp;
+ struct FTP *ftp = data->state.proto.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
ssize_t nread;
int ftpcode;
CURLcode result=CURLE_OK;
bool was_ctl_valid = ftpc->ctl_valid;
char *path;
- char *path_to_use = data->reqdata.path;
- struct Curl_transfer_keeper *k = &data->reqdata.keep;
+ char *path_to_use = data->state.path;
if(!ftp)
/* When the easy handle is removed from the multi while libcurl is still
}
}
else {
- if((-1 != k->size) && (k->size != *ftp->bytecountp) &&
+ if((-1 != data->req.size) &&
+ (data->req.size != *ftp->bytecountp) &&
#ifdef CURL_DO_LINEEND_CONV
/* Most FTP servers don't adjust their file SIZE response for CRLFs, so
* we'll check to see if the discrepancy can be explained by the number
* of CRLFs we've changed to LFs.
*/
- ((k->size + data->state.crlf_conversions) != *ftp->bytecountp) &&
+ ((data->req.size + data->state.crlf_conversions) !=
+ *ftp->bytecountp) &&
#endif /* CURL_DO_LINEEND_CONV */
- (k->maxdownload != *ftp->bytecountp)) {
+ (data->req.maxdownload != *ftp->bytecountp)) {
failf(data, "Received only partial file: %" FORMAT_OFF_T " bytes",
*ftp->bytecountp);
result = CURLE_PARTIAL_FILE;
}
else if(!ftpc->dont_check &&
!*ftp->bytecountp &&
- (k->size>0)) {
+ (data->req.size>0)) {
failf(data, "No data was received!");
result = CURLE_FTP_COULDNT_RETR_FILE;
}
struct SessionHandle *data = conn->data;
struct ftp_conn *ftpc = &conn->proto.ftpc;
- if(data->reqdata.use_range && data->reqdata.range) {
- from=curlx_strtoofft(data->reqdata.range, &ptr, 0);
+ if(data->state.use_range && data->state.range) {
+ from=curlx_strtoofft(data->state.range, &ptr, 0);
while(ptr && *ptr && (ISSPACE(*ptr) || (*ptr=='-')))
ptr++;
to=curlx_strtoofft(ptr, &ptr2, 0);
}
if((-1 == to) && (from>=0)) {
/* X - */
- data->reqdata.resume_from = from;
+ data->state.resume_from = from;
DEBUGF(infof(conn->data, "FTP RANGE %" FORMAT_OFF_T " to end of file\n",
from));
}
else if(from < 0) {
/* -Y */
totalsize = -from;
- data->reqdata.maxdownload = -from;
- data->reqdata.resume_from = from;
+ data->req.maxdownload = -from;
+ data->state.resume_from = from;
DEBUGF(infof(conn->data, "FTP RANGE the last %" FORMAT_OFF_T " bytes\n",
totalsize));
}
else {
/* X-Y */
totalsize = to-from;
- data->reqdata.maxdownload = totalsize+1; /* include last byte */
- data->reqdata.resume_from = from;
+ data->req.maxdownload = totalsize+1; /* include last byte */
+ data->state.resume_from = from;
DEBUGF(infof(conn->data, "FTP RANGE from %" FORMAT_OFF_T
" getting %" FORMAT_OFF_T " bytes\n",
- from, data->reqdata.maxdownload));
+ from, data->req.maxdownload));
}
DEBUGF(infof(conn->data, "range-download from %" FORMAT_OFF_T
" to %" FORMAT_OFF_T ", totally %" FORMAT_OFF_T " bytes\n",
- from, to, data->reqdata.maxdownload));
+ from, to, data->req.maxdownload));
ftpc->dont_check = TRUE; /* dont check for successful transfer */
}
else
- data->reqdata.maxdownload = -1;
+ data->req.maxdownload = -1;
return CURLE_OK;
}
CURLcode result = CURLE_OK;
/* the ftp struct is inited in Curl_ftp_connect() */
- struct FTP *ftp = data->reqdata.proto.ftp;
+ struct FTP *ftp = data->state.proto.ftp;
DEBUGF(infof(data, "DO-MORE phase starts\n"));
if(conn->bits.no_body) {
/* requested no body means no transfer... */
- struct FTP *ftp = conn->data->reqdata.proto.ftp;
+ struct FTP *ftp = conn->data->state.proto.ftp;
ftp->transfer = FTPTRANSFER_INFO;
}
{
struct SessionHandle *data = conn->data;
/* the ftp struct is already inited in ftp_connect() */
- struct FTP *ftp = data->reqdata.proto.ftp;
+ struct FTP *ftp = data->state.proto.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
size_t dlen;
char *slash_pos; /* position of the first '/' char in curpos */
- char *path_to_use = data->reqdata.path;
+ char *path_to_use = data->state.path;
char *cur_pos;
cur_pos = path_to_use; /* current position in path. point at the begin
the first condition in the if() right here, is there just in case
someone decides to set path to NULL one day
*/
- if(data->reqdata.path &&
- data->reqdata.path[0] &&
- (data->reqdata.path[strlen(data->reqdata.path) - 1] != '/') )
- ftpc->file = data->reqdata.path; /* this is a full file path */
+ if(data->state.path &&
+ data->state.path[0] &&
+ (data->state.path[strlen(data->state.path) - 1] != '/') )
+ ftpc->file = data->state.path; /* this is a full file path */
else
ftpc->file = NULL;
/*
/* parse the URL path into separate path components */
while((slash_pos = strchr(cur_pos, '/')) != NULL) {
/* 1 or 0 to indicate absolute directory */
- bool absolute_dir = (bool)((cur_pos - data->reqdata.path > 0) &&
+ bool absolute_dir = (bool)((cur_pos - data->state.path > 0) &&
(ftpc->dirdepth == 0));
/* seek out the next path component */
if(ftpc->prevpath) {
/* prevpath is "raw" so we convert the input path before we compare the
strings */
- char *path = curl_easy_unescape(conn->data, data->reqdata.path, 0, NULL);
+ char *path = curl_easy_unescape(conn->data, data->state.path, 0, NULL);
if(!path) {
freedirs(ftpc);
return CURLE_OUT_OF_MEMORY;
bool connected)
{
CURLcode result = CURLE_OK;
- struct FTP *ftp = conn->data->reqdata.proto.ftp;
+ struct FTP *ftp = conn->data->state.proto.ftp;
struct ftp_conn *ftpc = &conn->proto.ftpc;
if(connected)
bool connected=0;
struct SessionHandle *data = conn->data;
struct ftp_conn *ftpc = &conn->proto.ftpc;
- data->reqdata.size = -1; /* make sure this is unknown at this point */
+ data->req.size = -1; /* make sure this is unknown at this point */
Curl_pgrsSetUploadCounter(data, 0);
Curl_pgrsSetDownloadCounter(data, 0);
#endif
}
- data->reqdata.path++; /* don't include the initial slash */
+ data->state.path++; /* don't include the initial slash */
/* FTP URLs support an extension like ";type=<typecode>" that
* we'll try to get now! */
- type = strstr(data->reqdata.path, ";type=");
+ type = strstr(data->state.path, ";type=");
if(!type)
type = strstr(conn->host.rawalloc, ";type=");
static CURLcode perhapsrewind(struct connectdata *conn)
{
struct SessionHandle *data = conn->data;
- struct HTTP *http = data->reqdata.proto.http;
- struct Curl_transfer_keeper *k = &data->reqdata.keep;
+ struct HTTP *http = data->state.proto.http;
curl_off_t bytessent;
curl_off_t expectsend = -1; /* default is unknown */
/* This is not NTLM or NTLM with many bytes left to send: close
*/
conn->bits.close = TRUE;
- k->size = 0; /* don't download any more than 0 bytes */
+ data->req.size = 0; /* don't download any more than 0 bytes */
}
if(bytessent)
bool pickproxy = FALSE;
CURLcode code = CURLE_OK;
- if(100 == data->reqdata.keep.httpcode)
+ if(100 == data->req.httpcode)
/* this is a transient response code, ignore */
return CURLE_OK;
return data->set.http_fail_on_error?CURLE_HTTP_RETURNED_ERROR:CURLE_OK;
if(conn->bits.user_passwd &&
- ((data->reqdata.keep.httpcode == 401) ||
- (conn->bits.authneg && data->reqdata.keep.httpcode < 300))) {
+ ((data->req.httpcode == 401) ||
+ (conn->bits.authneg && data->req.httpcode < 300))) {
pickhost = pickoneauth(&data->state.authhost);
if(!pickhost)
data->state.authproblem = TRUE;
}
if(conn->bits.proxy_user_passwd &&
- ((data->reqdata.keep.httpcode == 407) ||
- (conn->bits.authneg && data->reqdata.keep.httpcode < 300))) {
+ ((data->req.httpcode == 407) ||
+ (conn->bits.authneg && data->req.httpcode < 300))) {
pickproxy = pickoneauth(&data->state.authproxy);
if(!pickproxy)
data->state.authproblem = TRUE;
}
if(pickhost || pickproxy) {
- data->reqdata.newurl = strdup(data->change.url); /* clone URL */
- if(!data->reqdata.newurl)
+ data->req.newurl = strdup(data->change.url); /* clone URL */
+ if(!data->req.newurl)
return CURLE_OUT_OF_MEMORY;
if((data->set.httpreq != HTTPREQ_GET) &&
}
}
- else if((data->reqdata.keep.httpcode < 300) &&
+ else if((data->req.httpcode < 300) &&
(!data->state.authhost.done) &&
conn->bits.authneg) {
/* no (known) authentication available,
we didn't try HEAD or GET */
if((data->set.httpreq != HTTPREQ_GET) &&
(data->set.httpreq != HTTPREQ_HEAD)) {
- data->reqdata.newurl = strdup(data->change.url); /* clone URL */
- if(!data->reqdata.newurl)
+ data->req.newurl = strdup(data->change.url); /* clone URL */
+ if(!data->req.newurl)
return CURLE_OUT_OF_MEMORY;
data->state.authhost.done = TRUE;
}
}
if(Curl_http_should_fail(conn)) {
failf (data, "The requested URL returned error: %d",
- data->reqdata.keep.httpcode);
+ data->req.httpcode);
code = CURLE_HTTP_RETURNED_ERROR;
}
/* if exactly this is wanted, go */
int neg = Curl_input_negotiate(conn, (bool)(httpcode == 407), start);
if(neg == 0) {
- data->reqdata.newurl = strdup(data->change.url);
- data->state.authproblem = (data->reqdata.newurl == NULL);
+ data->req.newurl = strdup(data->change.url);
+ data->state.authproblem = (data->req.newurl == NULL);
}
else {
infof(data, "Authentication problem. Ignoring this.\n");
int Curl_http_should_fail(struct connectdata *conn)
{
struct SessionHandle *data;
- struct Curl_transfer_keeper *k;
+ int httpcode;
DEBUGASSERT(conn);
data = conn->data;
DEBUGASSERT(data);
- /*
- ** For readability
- */
- k = &data->reqdata.keep;
+ httpcode = data->req.httpcode;
/*
** If we haven't been asked to fail on error,
/*
** Any code < 400 is never terminal.
*/
- if(k->httpcode < 400)
+ if(httpcode < 400)
return 0;
- if(data->reqdata.resume_from &&
- (data->set.httpreq==HTTPREQ_GET) &&
- (k->httpcode == 416)) {
+ if(data->state.resume_from &&
+ (data->set.httpreq==HTTPREQ_GET) &&
+ (httpcode == 416)) {
/* "Requested Range Not Satisfiable", just proceed and
pretend this is no error */
return 0;
** Any code >= 400 that's not 401 or 407 is always
** a terminal error
*/
- if((k->httpcode != 401) &&
- (k->httpcode != 407))
+ if((httpcode != 401) &&
+ (httpcode != 407))
return 1;
/*
** All we have left to deal with is 401 and 407
*/
- DEBUGASSERT((k->httpcode == 401) || (k->httpcode == 407));
+ DEBUGASSERT((httpcode == 401) || (httpcode == 407));
/*
** Examine the current authentication state to see if this
infof(data,"%s: authavail = 0x%08x\n",__FUNCTION__,data->state.authavail);
infof(data,"%s: httpcode = %d\n",__FUNCTION__,k->httpcode);
infof(data,"%s: authdone = %d\n",__FUNCTION__,data->state.authdone);
- infof(data,"%s: newurl = %s\n",__FUNCTION__,data->reqdata.newurl ? data->reqdata.newurl : "(null)");
+ infof(data,"%s: newurl = %s\n",__FUNCTION__,data->req.newurl ?
+ data->req.newurl : "(null)");
infof(data,"%s: authproblem = %d\n",__FUNCTION__,data->state.authproblem);
#endif
** Either we're not authenticating, or we're supposed to
** be authenticating something else. This is an error.
*/
- if((k->httpcode == 401) && !conn->bits.user_passwd)
+ if((httpcode == 401) && !conn->bits.user_passwd)
return TRUE;
- if((k->httpcode == 407) && !conn->bits.proxy_user_passwd)
+ if((httpcode == 407) && !conn->bits.proxy_user_passwd)
return TRUE;
return data->state.authproblem;
void *userp)
{
struct connectdata *conn = (struct connectdata *)userp;
- struct HTTP *http = conn->data->reqdata.proto.http;
+ struct HTTP *http = conn->data->state.proto.http;
size_t fullsize = size * nitems;
if(0 == http->postsize)
CURLcode res;
char *ptr;
size_t size;
- struct HTTP *http = conn->data->reqdata.proto.http;
+ struct HTTP *http = conn->data->state.proto.http;
size_t sendsize;
curl_socket_t sockfd;
size_t headersize;
{
int subversion=0;
struct SessionHandle *data=conn->data;
- struct Curl_transfer_keeper *k = &data->reqdata.keep;
+ struct SingleRequest *k = &data->req;
CURLcode result;
int res;
long timeout =
infof(data, "Establish HTTP proxy tunnel to %s:%d\n",
hostname, remote_port);
- if(data->reqdata.newurl) {
+ if(data->req.newurl) {
/* This only happens if we've looped here due to authentication
reasons, and we don't really use the newly cloned URL here
then. Just free() it. */
- free(data->reqdata.newurl);
- data->reqdata.newurl = NULL;
+ free(data->req.newurl);
+ data->req.newurl = NULL;
}
/* initialize a dynamic send-buffer */
headers. 'newurl' is set to a new URL if we must loop. */
Curl_http_auth_act(conn);
- if(closeConnection && data->reqdata.newurl) {
+ if(closeConnection && data->req.newurl) {
/* Connection closed by server. Don't use it anymore */
sclose(conn->sock[sockindex]);
conn->sock[sockindex] = CURL_SOCKET_BAD;
break;
}
} /* END NEGOTIATION PHASE */
- } while(data->reqdata.newurl);
+ } while(data->req.newurl);
- if(200 != k->httpcode) {
+ if(200 != data->req.httpcode) {
failf(data, "Received HTTP code %d from proxy after CONNECT",
- k->httpcode);
+ data->req.httpcode);
- if(closeConnection && data->reqdata.newurl)
+ if(closeConnection && data->req.newurl)
conn->bits.proxy_connect_closed = TRUE;
return CURLE_RECV_ERROR;
data->state.authproxy.done = TRUE;
infof (data, "Proxy replied OK to CONNECT request\n");
- k->ignorebody = FALSE; /* put it (back) to non-ignore state */
+ data->req.ignorebody = FALSE; /* put it (back) to non-ignore state */
return CURLE_OK;
}
CURLcode status, bool premature)
{
struct SessionHandle *data = conn->data;
- struct HTTP *http =data->reqdata.proto.http;
- struct Curl_transfer_keeper *k = &data->reqdata.keep;
+ struct HTTP *http =data->state.proto.http;
(void)premature; /* not used */
/* set the proper values (possibly modified on POST) */
}
if(HTTPREQ_POST_FORM == data->set.httpreq) {
- k->bytecount = http->readbytecount + http->writebytecount;
+ data->req.bytecount = http->readbytecount + http->writebytecount;
Curl_formclean(&http->sendit); /* Now free that whole lot */
if(http->form.fp) {
}
}
else if(HTTPREQ_PUT == data->set.httpreq)
- k->bytecount = http->readbytecount + http->writebytecount;
+ data->req.bytecount = http->readbytecount + http->writebytecount;
if(status != CURLE_OK)
return (status);
if(!conn->bits.retry &&
((http->readbytecount +
- data->reqdata.keep.headerbytecount -
- data->reqdata.keep.deductheadercount)) <= 0) {
+ data->req.headerbytecount -
+ data->req.deductheadercount)) <= 0) {
/* If this connection isn't simply closed to be retried, AND nothing was
read from the HTTP server (that counts), this can't be right so we
return an error here */
char *buf = data->state.buffer; /* this is a short cut to the buffer */
CURLcode result=CURLE_OK;
struct HTTP *http;
- char *ppath = data->reqdata.path;
+ char *ppath = data->state.path;
char ftp_typecode[sizeof(";type=?")] = "";
char *host = conn->host.name;
const char *te = ""; /* transfer-encoding */
sessionhandle, deal with it */
Curl_reset_reqproto(conn);
- if(!data->reqdata.proto.http) {
+ if(!data->state.proto.http) {
/* Only allocate this struct if we don't already have it! */
http = (struct HTTP *)calloc(sizeof(struct HTTP), 1);
if(!http)
return CURLE_OUT_OF_MEMORY;
- data->reqdata.proto.http = http;
+ data->state.proto.http = http;
}
else
- http = data->reqdata.proto.http;
+ http = data->state.proto.http;
if( (conn->protocol&(PROT_HTTP|PROT_FTP)) &&
data->set.upload) {
if(( (HTTPREQ_POST == httpreq) ||
(HTTPREQ_POST_FORM == httpreq) ||
(HTTPREQ_PUT == httpreq) ) &&
- data->reqdata.resume_from) {
+ data->state.resume_from) {
/**********************************************************************
* Resuming upload in HTTP means that we PUT or POST and that we have
* got a resume_from value set. The resume value has already created
* file size before we continue this venture in the dark lands of HTTP.
*********************************************************************/
- if(data->reqdata.resume_from < 0 ) {
+ if(data->state.resume_from < 0 ) {
/*
* This is meant to get the size of the present remote-file by itself.
* We don't support this now. Bail out!
*/
- data->reqdata.resume_from = 0;
+ data->state.resume_from = 0;
}
- if(data->reqdata.resume_from && !data->state.this_is_a_follow) {
+ if(data->state.resume_from && !data->state.this_is_a_follow) {
/* do we still game? */
curl_off_t passed=0;
input. If we knew it was a proper file we could've just
fseek()ed but we only have a stream here */
do {
- size_t readthisamountnow = (size_t)(data->reqdata.resume_from - passed);
+ size_t readthisamountnow = (size_t)(data->state.resume_from - passed);
size_t actuallyread;
if(readthisamountnow > BUFSIZE)
passed);
return CURLE_READ_ERROR;
}
- } while(passed != data->reqdata.resume_from); /* loop until done */
+ } while(passed != data->state.resume_from); /* loop until done */
/* now, decrease the size of the read */
if(data->set.infilesize>0) {
- data->set.infilesize -= data->reqdata.resume_from;
+ data->set.infilesize -= data->state.resume_from;
if(data->set.infilesize <= 0) {
failf(data, "File already completely uploaded");
/* we've passed, proceed as normal */
}
}
- if(data->reqdata.use_range) {
+ if(data->state.use_range) {
/*
* A range is selected. We use different headers whether we're downloading
* or uploading and we always let customized headers override our internal
if(conn->allocptr.rangeline)
free(conn->allocptr.rangeline);
conn->allocptr.rangeline = aprintf("Range: bytes=%s\r\n",
- data->reqdata.range);
+ data->state.range);
}
else if((httpreq != HTTPREQ_GET) &&
!checkheaders(data, "Content-Range:")) {
if(conn->allocptr.rangeline)
free(conn->allocptr.rangeline);
- if(data->reqdata.resume_from) {
+ if(data->state.resume_from) {
/* This is because "resume" was selected */
curl_off_t total_expected_size=
- data->reqdata.resume_from + data->set.infilesize;
+ data->state.resume_from + data->set.infilesize;
conn->allocptr.rangeline =
aprintf("Content-Range: bytes %s%" FORMAT_OFF_T
"/%" FORMAT_OFF_T "\r\n",
- data->reqdata.range, total_expected_size-1,
+ data->state.range, total_expected_size-1,
total_expected_size);
}
else {
append total size */
conn->allocptr.rangeline =
aprintf("Content-Range: bytes %s/%" FORMAT_OFF_T "\r\n",
- data->reqdata.range, data->set.infilesize);
+ data->state.range, data->set.infilesize);
}
if(!conn->allocptr.rangeline)
return CURLE_OUT_OF_MEMORY;
conn->allocptr.proxyuserpwd?
conn->allocptr.proxyuserpwd:"",
conn->allocptr.userpwd?conn->allocptr.userpwd:"",
- (data->reqdata.use_range && conn->allocptr.rangeline)?
+ (data->state.use_range && conn->allocptr.rangeline)?
conn->allocptr.rangeline:"",
(data->set.str[STRING_USERAGENT] &&
*data->set.str[STRING_USERAGENT] && conn->allocptr.uagent)?
co = Curl_cookie_getlist(data->cookies,
conn->allocptr.cookiehost?
conn->allocptr.cookiehost:host,
- data->reqdata.path,
+ data->state.path,
(bool)(conn->protocol&PROT_HTTPS?TRUE:FALSE));
Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE);
}
CURLcode result=CURLE_OK;
struct SessionHandle *data = conn->data;
struct Curl_chunker *ch = &conn->chunk;
- struct Curl_transfer_keeper *k = &data->reqdata.keep;
+ struct SingleRequest *k = &data->req;
size_t piece;
size_t length = (size_t)datalen;
size_t *wrote = (size_t *)wrotep;
/* Write the data portion available */
#ifdef HAVE_LIBZ
switch (conn->data->set.http_ce_skip?
- IDENTITY : data->reqdata.keep.content_encoding) {
+ IDENTITY : data->req.content_encoding) {
case IDENTITY:
#endif
if(!k->ignorebody) {
break;
case DEFLATE:
- /* update data->reqdata.keep.str to point to the chunk data. */
- data->reqdata.keep.str = datap;
- result = Curl_unencode_deflate_write(conn, &data->reqdata.keep,
+ /* update data->req.keep.str to point to the chunk data. */
+ data->req.str = datap;
+ result = Curl_unencode_deflate_write(conn, &data->req,
(ssize_t)piece);
break;
case GZIP:
- /* update data->reqdata.keep.str to point to the chunk data. */
- data->reqdata.keep.str = datap;
- result = Curl_unencode_gzip_write(conn, &data->reqdata.keep,
+ /* update data->req.keep.str to point to the chunk data. */
+ data->req.str = datap;
+ result = Curl_unencode_gzip_write(conn, &data->req,
(ssize_t)piece);
break;
bool dophase_done;
bool done;
CURLMcode result = CURLM_OK;
- struct Curl_transfer_keeper *k;
+ struct SingleRequest *k;
do {
bool disconnect_conn = FALSE;
we're using gets cleaned up and we're left with nothing. */
if(easy->easy_handle->state.pipe_broke) {
infof(easy->easy_handle, "Pipe broke: handle 0x%x, url = %s\n",
- easy, easy->easy_handle->reqdata.path);
+ easy, easy->easy_handle->state.path);
if(easy->easy_handle->state.is_in_pipeline) {
/* Head back to the CONNECT state */
/* read/write data if it is ready to do so */
easy->result = Curl_readwrite(easy->easy_conn, &done);
- k = &easy->easy_handle->reqdata.keep;
+ k = &easy->easy_handle->req;
if(!(k->keepon & KEEP_READ)) {
/* We're done reading */
Curl_posttransfer(easy->easy_handle);
/* When we follow redirects, must to go back to the CONNECT state */
- if(easy->easy_handle->reqdata.newurl || retry) {
+ if(easy->easy_handle->req.newurl || retry) {
Curl_removeHandleFromPipeline(easy->easy_handle,
easy->easy_conn->recv_pipe);
if(!retry) {
/* if the URL is a follow-location and not just a retried request
then figure out the URL here */
- newurl = easy->easy_handle->reqdata.newurl;
- easy->easy_handle->reqdata.newurl = NULL;
+ newurl = easy->easy_handle->req.newurl;
+ easy->easy_handle->req.newurl = NULL;
}
easy->result = Curl_done(&easy->easy_conn, CURLE_OK, FALSE);
if(easy->result == CURLE_OK)
progress */
if(!(data->progress.flags & PGRS_HEADERS_OUT)) {
- if(data->reqdata.resume_from) {
+ if(data->state.resume_from) {
fprintf(data->set.err,
- "** Resuming transfer from byte position %" FORMAT_OFF_T
- "\n",
- data->reqdata.resume_from);
+ "** Resuming transfer from byte position %" FORMAT_OFF_T "\n",
+ data->state.resume_from);
}
fprintf(data->set.err,
" %% Total %% Received %% Xferd Average Speed Time Time Time Current\n"
char *working_path;
int working_path_len;
- working_path = curl_easy_unescape(data, data->reqdata.path, 0,
+ working_path = curl_easy_unescape(data, data->state.path, 0,
&working_path_len);
if(!working_path)
return CURLE_OUT_OF_MEMORY;
{
CURLcode result = CURLE_OK;
struct SessionHandle *data = conn->data;
- struct SSHPROTO *sftp_scp = data->reqdata.proto.ssh;
+ struct SSHPROTO *sftp_scp = data->state.proto.ssh;
struct ssh_conn *sshc = &conn->proto.sshc;
curl_socket_t sock = conn->sock[FIRSTSOCKET];
#ifdef CURL_LIBSSH2_DEBUG
}
/* since this counts what we send to the client, we include the newline
in this counter */
- data->reqdata.keep.bytecount += sshc->readdir_len+1;
+ data->req.bytecount += sshc->readdir_len+1;
/* output debug output if that is requested */
if(data->set.verbose) {
Curl_debug(data, CURLINFO_DATA_OUT, sshc->readdir_line,
sshc->readdir_currLen, conn);
}
- data->reqdata.keep.bytecount += sshc->readdir_currLen;
+ data->req.bytecount += sshc->readdir_currLen;
}
Curl_safefree(sshc->readdir_line);
sshc->readdir_line = NULL;
* libssh2_sftp_open() didn't return an error, so maybe the server
* just doesn't support stat()
*/
- data->reqdata.size = -1;
- data->reqdata.maxdownload = -1;
+ data->req.size = -1;
+ data->req.maxdownload = -1;
}
else {
- data->reqdata.size = attrs.filesize;
- data->reqdata.maxdownload = attrs.filesize;
+ data->req.size = attrs.filesize;
+ data->req.maxdownload = attrs.filesize;
Curl_pgrsSetDownloadSize(data, attrs.filesize);
}
}
/* Setup the actual download */
- result = Curl_setup_transfer(conn, FIRSTSOCKET, data->reqdata.size,
+ result = Curl_setup_transfer(conn, FIRSTSOCKET, data->req.size,
FALSE, NULL, -1, NULL);
if(result) {
state(conn, SSH_SFTP_CLOSE);
}
/* upload data */
- result = Curl_setup_transfer(conn, -1, data->reqdata.size, FALSE, NULL,
+ result = Curl_setup_transfer(conn, -1, data->req.size, FALSE, NULL,
FIRSTSOCKET, NULL);
if(result) {
/* download data */
bytecount = (curl_off_t)sb.st_size;
- data->reqdata.maxdownload = (curl_off_t)sb.st_size;
+ data->req.maxdownload = (curl_off_t)sb.st_size;
result = Curl_setup_transfer(conn, FIRSTSOCKET,
bytecount, FALSE, NULL, -1, NULL);
{
struct SessionHandle *data = conn->data;
struct SSHPROTO *ssh;
- if(data->reqdata.proto.ssh)
+ if(data->state.proto.ssh)
return CURLE_OK;
ssh = (struct SSHPROTO *)calloc(sizeof(struct SSHPROTO), 1);
if(!ssh)
return CURLE_OUT_OF_MEMORY;
- data->reqdata.proto.ssh = ssh;
+ data->state.proto.ssh = ssh;
return CURLE_OK;
}
*done = FALSE; /* default to false */
- data->reqdata.size = -1; /* make sure this is unknown at this point */
+ data->req.size = -1; /* make sure this is unknown at this point */
Curl_pgrsSetUploadCounter(data, 0);
Curl_pgrsSetDownloadCounter(data, 0);
{
CURLcode result;
- Curl_safefree(conn->data->reqdata.proto.ssh);
- conn->data->reqdata.proto.ssh = NULL;
+ Curl_safefree(conn->data->state.proto.ssh);
+ conn->data->state.proto.ssh = NULL;
state(conn, SSH_SESSION_DISCONNECT);
}
if(done) {
- struct SSHPROTO *sftp_scp = conn->data->reqdata.proto.ssh;
+ struct SSHPROTO *sftp_scp = conn->data->state.proto.ssh;
Curl_safefree(sftp_scp->path);
sftp_scp->path = NULL;
Curl_pgrsDone(conn);
DEBUGF(infof(conn->data, "SSH DISCONNECT starts now\n"));
- Curl_safefree(conn->data->reqdata.proto.ssh);
- conn->data->reqdata.proto.ssh = NULL;
+ Curl_safefree(conn->data->state.proto.ssh);
+ conn->data->state.proto.ssh = NULL;
state(conn, SSH_SFTP_SHUTDOWN);
result = ssh_easy_statemach(conn);
if(!tn)
return CURLE_OUT_OF_MEMORY;
- conn->data->reqdata.proto.telnet = (void *)tn; /* make us known */
+ conn->data->state.proto.telnet = (void *)tn; /* make us known */
tn->telrcv_state = CURL_TS_DATA;
static void negotiate(struct connectdata *conn)
{
int i;
- struct TELNET *tn = (struct TELNET *) conn->data->reqdata.proto.telnet;
+ struct TELNET *tn = (struct TELNET *) conn->data->state.proto.telnet;
for(i = 0;i < CURL_NTELOPTS;i++)
{
static
void set_remote_option(struct connectdata *conn, int option, int newstate)
{
- struct TELNET *tn = (struct TELNET *)conn->data->reqdata.proto.telnet;
+ struct TELNET *tn = (struct TELNET *)conn->data->state.proto.telnet;
if(newstate == CURL_YES)
{
switch(tn->him[option])
static
void rec_will(struct connectdata *conn, int option)
{
- struct TELNET *tn = (struct TELNET *)conn->data->reqdata.proto.telnet;
+ struct TELNET *tn = (struct TELNET *)conn->data->state.proto.telnet;
switch(tn->him[option])
{
case CURL_NO:
static
void rec_wont(struct connectdata *conn, int option)
{
- struct TELNET *tn = (struct TELNET *)conn->data->reqdata.proto.telnet;
+ struct TELNET *tn = (struct TELNET *)conn->data->state.proto.telnet;
switch(tn->him[option])
{
case CURL_NO:
static void
set_local_option(struct connectdata *conn, int option, int newstate)
{
- struct TELNET *tn = (struct TELNET *)conn->data->reqdata.proto.telnet;
+ struct TELNET *tn = (struct TELNET *)conn->data->state.proto.telnet;
if(newstate == CURL_YES)
{
switch(tn->us[option])
static
void rec_do(struct connectdata *conn, int option)
{
- struct TELNET *tn = (struct TELNET *)conn->data->reqdata.proto.telnet;
+ struct TELNET *tn = (struct TELNET *)conn->data->state.proto.telnet;
switch(tn->us[option])
{
case CURL_NO:
static
void rec_dont(struct connectdata *conn, int option)
{
- struct TELNET *tn = (struct TELNET *)conn->data->reqdata.proto.telnet;
+ struct TELNET *tn = (struct TELNET *)conn->data->state.proto.telnet;
switch(tn->us[option])
{
case CURL_NO:
char option_arg[256];
char *buf;
struct SessionHandle *data = conn->data;
- struct TELNET *tn = (struct TELNET *)conn->data->reqdata.proto.telnet;
+ struct TELNET *tn = (struct TELNET *)conn->data->state.proto.telnet;
/* Add the user name as an environment variable if it
was given on the command line */
char varname[128];
char varval[128];
struct SessionHandle *data = conn->data;
- struct TELNET *tn = (struct TELNET *)data->reqdata.proto.telnet;
+ struct TELNET *tn = (struct TELNET *)data->state.proto.telnet;
printsub(data, '<', (unsigned char *)tn->subbuffer, CURL_SB_LEN(tn)+2);
switch (CURL_SB_GET(tn)) {
int in = 0;
int startwrite=-1;
struct SessionHandle *data = conn->data;
- struct TELNET *tn = (struct TELNET *)data->reqdata.proto.telnet;
+ struct TELNET *tn = (struct TELNET *)data->state.proto.telnet;
#define startskipping() \
if(startwrite >= 0) \
static CURLcode Curl_telnet_done(struct connectdata *conn,
CURLcode status, bool premature)
{
- struct TELNET *tn = (struct TELNET *)conn->data->reqdata.proto.telnet;
+ struct TELNET *tn = (struct TELNET *)conn->data->state.proto.telnet;
(void)status; /* unused */
(void)premature; /* not used */
curl_slist_free_all(tn->telnet_vars);
- free(conn->data->reqdata.proto.telnet);
- conn->data->reqdata.proto.telnet = NULL;
+ free(conn->data->state.proto.telnet);
+ conn->data->state.proto.telnet = NULL;
return CURLE_OK;
}
if(code)
return code;
- tn = (struct TELNET *)data->reqdata.proto.telnet;
+ tn = (struct TELNET *)data->state.proto.telnet;
code = check_telnet_options(conn);
if(code)
if(data->set.upload) {
/* If we are uploading, send an WRQ */
setpacketevent(&state->spacket, TFTP_EVENT_WRQ);
- state->conn->data->reqdata.upload_fromhere =
+ state->conn->data->req.upload_fromhere =
(char *)&state->spacket.data[4];
if(data->set.infilesize != -1)
Curl_pgrsSetUploadSize(data, data->set.infilesize);
}
/* As RFC3617 describes the separator slash is not actually part of the
file name so we skip the always-present first letter of the path string. */
- filename = curl_easy_unescape(data, &state->conn->data->reqdata.path[1], 0,
+ filename = curl_easy_unescape(data, &state->conn->data->state.path[1], 0,
NULL);
if(!filename)
return CURLE_OUT_OF_MEMORY;
int sbytes;
int rblock;
CURLcode res = CURLE_OK;
- struct Curl_transfer_keeper *k = &data->reqdata.keep;
+ struct SingleRequest *k = &data->req;
switch(event) {
sessionhandle, deal with it */
Curl_reset_reqproto(conn);
- if(!(state = conn->data->reqdata.proto.tftp)) {
- state = conn->data->reqdata.proto.tftp = calloc(sizeof(tftp_state_data_t),
- 1);
+ if(!(state = conn->data->state.proto.tftp)) {
+ state = conn->data->state.proto.tftp = calloc(sizeof(tftp_state_data_t),
+ 1);
if(!state)
return CURLE_OUT_OF_MEMORY;
}
struct Curl_sockaddr_storage fromaddr;
socklen_t fromlen;
int check_time = 0;
- struct Curl_transfer_keeper *k = &data->reqdata.keep;
+ struct SingleRequest *k = &data->req;
*done = TRUE;
*/
Curl_reset_reqproto(conn);
- if(!data->reqdata.proto.tftp) {
+ if(!data->state.proto.tftp) {
code = Curl_tftp_connect(conn, done);
if(code)
return code;
}
- state = (tftp_state_data_t *)data->reqdata.proto.tftp;
+ state = (tftp_state_data_t *)data->state.proto.tftp;
/* Run the TFTP State Machine */
for(code=tftp_state_machine(state, TFTP_EVENT_INIT);
/* TFTP URLs support an extension like ";mode=<typecode>" that
* we'll try to get now! */
- type = strstr(data->reqdata.path, ";mode=");
+ type = strstr(data->state.path, ";mode=");
if(!type)
type = strstr(conn->host.rawalloc, ";mode=");
if(conn->bits.upload_chunky) {
/* if chunked Transfer-Encoding */
buffersize -= (8 + 2 + 2); /* 32bit hex + CRLF + CRLF */
- data->reqdata.upload_fromhere += 10; /* 32bit hex + CRLF */
+ data->req.upload_fromhere += 10; /* 32bit hex + CRLF */
}
/* this function returns a size_t, so we typecast to int to prevent warnings
with picky compilers */
- nread = (int)conn->fread_func(data->reqdata.upload_fromhere, 1,
+ nread = (int)conn->fread_func(data->req.upload_fromhere, 1,
buffersize, conn->fread_in);
if(nread == CURL_READFUNC_ABORT) {
int hexlen = snprintf(hexbuffer, sizeof(hexbuffer),
"%x\r\n", nread);
/* move buffer pointer */
- data->reqdata.upload_fromhere -= hexlen;
+ data->req.upload_fromhere -= hexlen;
nread += hexlen;
/* copy the prefix to the buffer */
- memcpy(data->reqdata.upload_fromhere, hexbuffer, hexlen);
+ memcpy(data->req.upload_fromhere, hexbuffer, hexlen);
/* always append CRLF to the data */
- memcpy(data->reqdata.upload_fromhere + nread, "\r\n", 2);
+ memcpy(data->req.upload_fromhere + nread, "\r\n", 2);
if((nread - hexlen) == 0) {
/* mark this as done once this chunk is transfered */
- data->reqdata.keep.upload_done = TRUE;
+ data->req.upload_done = TRUE;
}
nread+=2; /* for the added CRLF */
#ifdef CURL_DOES_CONVERSIONS
if(data->set.prefer_ascii) {
CURLcode res;
- res = Curl_convert_to_network(data, data->reqdata.upload_fromhere, nread);
+ res = Curl_convert_to_network(data, data->req.upload_fromhere, nread);
/* Curl_convert_to_network calls failf if unsuccessful */
if(res != CURLE_OK) {
return(res);
bool *done)
{
struct SessionHandle *data = conn->data;
- struct Curl_transfer_keeper *k = &data->reqdata.keep;
+ struct SingleRequest *k = &data->req;
CURLcode result;
ssize_t nread; /* number of bytes read */
int didwhat=0;
return result;
data->info.header_size += (long)headerlen;
- data->reqdata.keep.headerbytecount += (long)headerlen;
+ data->req.headerbytecount += (long)headerlen;
- data->reqdata.keep.deductheadercount =
- (100 == k->httpcode)?data->reqdata.keep.headerbytecount:0;
+ data->req.deductheadercount =
+ (100 == k->httpcode)?data->req.headerbytecount:0;
- if(data->reqdata.resume_from &&
+ if(data->state.resume_from &&
(data->set.httpreq==HTTPREQ_GET) &&
(k->httpcode == 416)) {
/* "Requested Range Not Satisfiable" */
((k->httpcode != 401) || !conn->bits.user_passwd) &&
((k->httpcode != 407) || !conn->bits.proxy_user_passwd) ) {
- if(data->reqdata.resume_from &&
+ if(data->state.resume_from &&
(data->set.httpreq==HTTPREQ_GET) &&
(k->httpcode == 416)) {
/* "Requested Range Not Satisfiable", just proceed and
k->offset = curlx_strtoofft(ptr, NULL, 10);
- if(data->reqdata.resume_from == k->offset)
+ if(data->state.resume_from == k->offset)
/* we asked for a resume and we got it */
k->content_range = TRUE;
}
here, or else use real peer host name. */
conn->allocptr.cookiehost?
conn->allocptr.cookiehost:conn->host.name,
- data->reqdata.path);
+ data->state.path);
Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE);
}
#endif
backup = *ptr; /* store the ending letter */
if(ptr != start) {
*ptr = '\0'; /* zero terminate */
- data->reqdata.newurl = strdup(start); /* clone string */
+ data->req.newurl = strdup(start); /* clone string */
*ptr = backup; /* restore ending letter */
- if(!data->reqdata.newurl)
+ if(!data->req.newurl)
return CURLE_OUT_OF_MEMORY;
}
}
return result;
data->info.header_size += (long)k->hbuflen;
- data->reqdata.keep.headerbytecount += (long)k->hbuflen;
+ data->req.headerbytecount += (long)k->hbuflen;
/* reset hbufp pointer && hbuflen */
k->hbufp = data->state.headerbuff;
if(conn->protocol&PROT_HTTP) {
/* HTTP-only checks */
- if(data->reqdata.newurl) {
+ if(data->req.newurl) {
if(conn->bits.close) {
/* Abort after the headers if "follow Location" is set
and we're set to close anyway. */
k->ignorebody = TRUE;
infof(data, "Ignoring the response-body\n");
}
- if(data->reqdata.resume_from && !k->content_range &&
+ if(data->state.resume_from && !k->content_range &&
(data->set.httpreq==HTTPREQ_GET) &&
!k->ignorebody) {
/* we wanted to resume a download, although the server doesn't
return CURLE_RANGE_ERROR;
}
- if(data->set.timecondition && !data->reqdata.range) {
+ if(data->set.timecondition && !data->state.range) {
/* A time condition has been set AND no ranges have been
requested. This seems to be what chapter 13.3.4 of
RFC 2616 defines to be the correct action for a
" bytes on url %s (size = %" FORMAT_OFF_T
", maxdownload = %" FORMAT_OFF_T
", bytecount = %" FORMAT_OFF_T ", nread = %d)\n",
- excess, conn->data->reqdata.path,
+ excess, data->state.path,
k->size, k->maxdownload, k->bytecount, nread);
read_rewind(conn, excess);
}
/* only read more data if there's no upload data already
present in the upload buffer */
- if(0 == data->reqdata.upload_present) {
+ if(0 == data->req.upload_present) {
/* init the "upload from here" pointer */
- data->reqdata.upload_fromhere = k->uploadbuf;
+ data->req.upload_fromhere = k->uploadbuf;
if(!k->upload_done) {
/* HTTP pollution, this should be written nicer to become more
int fillcount;
if(k->wait100_after_headers &&
- (data->reqdata.proto.http->sending == HTTPSEND_BODY)) {
+ (data->state.proto.http->sending == HTTPSEND_BODY)) {
/* If this call is to send body data, we must take some action:
We have sent off the full HTTP 1.1 request, and we shall now
go into the Expect: 100 state and await such a header */
}
/* store number of bytes available for upload */
- data->reqdata.upload_present = nread;
+ data->req.upload_present = nread;
/* convert LF to CRLF if so asked */
#ifdef CURL_DO_LINEEND_CONV
* must be used instead of the escape sequences \r & \n.
*/
for(i = 0, si = 0; i < nread; i++, si++) {
- if(data->reqdata.upload_fromhere[i] == 0x0a) {
+ if(data->req.upload_fromhere[i] == 0x0a) {
data->state.scratch[si++] = 0x0d;
data->state.scratch[si] = 0x0a;
if(!data->set.crlf) {
}
}
else
- data->state.scratch[si] = data->reqdata.upload_fromhere[i];
+ data->state.scratch[si] = data->req.upload_fromhere[i];
}
if(si != nread) {
/* only perform the special operation if we really did replace
nread = si;
/* upload from the new (replaced) buffer instead */
- data->reqdata.upload_fromhere = data->state.scratch;
+ data->req.upload_fromhere = data->state.scratch;
/* set the new amount too */
- data->reqdata.upload_present = nread;
+ data->req.upload_present = nread;
}
}
}
/* write to socket (send away data) */
result = Curl_write(conn,
conn->writesockfd, /* socket to send to */
- data->reqdata.upload_fromhere, /* buffer pointer */
- data->reqdata.upload_present, /* buffer size */
+ data->req.upload_fromhere, /* buffer pointer */
+ data->req.upload_present, /* buffer size */
&bytes_written); /* actually send away */
if(result)
return result;
if(data->set.verbose)
/* show the data before we change the pointer upload_fromhere */
- Curl_debug(data, CURLINFO_DATA_OUT, data->reqdata.upload_fromhere,
+ Curl_debug(data, CURLINFO_DATA_OUT, data->req.upload_fromhere,
(size_t)bytes_written, conn);
- if(data->reqdata.upload_present != bytes_written) {
+ if(data->req.upload_present != bytes_written) {
/* we only wrote a part of the buffer (if anything), deal with it! */
/* store the amount of bytes left in the buffer to write */
- data->reqdata.upload_present -= bytes_written;
+ data->req.upload_present -= bytes_written;
/* advance the pointer where to find the buffer when the next send
is to happen */
- data->reqdata.upload_fromhere += bytes_written;
+ data->req.upload_fromhere += bytes_written;
writedone = TRUE; /* we are done, stop the loop */
}
else {
/* we've uploaded that buffer now */
- data->reqdata.upload_fromhere = k->uploadbuf;
- data->reqdata.upload_present = 0; /* no more bytes left */
+ data->req.upload_fromhere = k->uploadbuf;
+ data->req.upload_present = 0; /* no more bytes left */
if(k->upload_done) {
/* switch off writing, we're done! */
*/
(k->bytecount != (k->size + data->state.crlf_conversions)) &&
#endif /* CURL_DO_LINEEND_CONV */
- !data->reqdata.newurl) {
+ !data->req.newurl) {
failf(data, "transfer closed with %" FORMAT_OFF_T
" bytes remaining to read",
k->size - k->bytecount);
/* simple check but we might need two slots */
return GETSOCK_BLANK;
- if(data->reqdata.keep.keepon & KEEP_READ) {
+ if(data->req.keepon & KEEP_READ) {
DEBUGASSERT(conn->sockfd != CURL_SOCKET_BAD);
sock[sockindex] = conn->sockfd;
}
- if(data->reqdata.keep.keepon & KEEP_WRITE) {
+ if(data->req.keepon & KEEP_WRITE) {
if((conn->sockfd != conn->writesockfd) ||
- !(data->reqdata.keep.keepon & KEEP_READ)) {
+ !(data->req.keepon & KEEP_READ)) {
/* only if they are not the same socket or we didn't have a readable
one, we increase index */
- if(data->reqdata.keep.keepon & KEEP_READ)
+ if(data->req.keepon & KEEP_READ)
sockindex++; /* increase index if we need two entries */
DEBUGASSERT(conn->writesockfd != CURL_SOCKET_BAD);
{
CURLcode result;
struct SessionHandle *data = conn->data;
- struct Curl_transfer_keeper *k = &data->reqdata.keep;
+ struct SingleRequest *k = &data->req;
bool done=FALSE;
if((conn->sockfd == CURL_SOCKET_BAD) &&
if(data->set.upload && !(conn->protocol&PROT_HTTP))
return retry;
- if((data->reqdata.keep.bytecount +
- data->reqdata.keep.headerbytecount == 0) &&
+ if((data->req.bytecount +
+ data->req.headerbytecount == 0) &&
conn->bits.reuse &&
!conn->bits.no_body) {
/* We got no data, we attempted to re-use a connection and yet we want a
* We must duplicate the new URL here as the connection data may
* be free()ed in the Curl_done() function.
*/
- newurl = data->reqdata.newurl?strdup(data->reqdata.newurl):NULL;
+ newurl = data->req.newurl?strdup(data->req.newurl):NULL;
}
else {
/* The transfer phase returned error, we mark the connection to get
)
{
struct SessionHandle *data;
- struct Curl_transfer_keeper *k;
+ struct SingleRequest *k;
DEBUGASSERT(conn != NULL);
data = conn->data;
- k = &data->reqdata.keep;
+ k = &data->req;
DEBUGASSERT((sockindex <= 1) && (sockindex >= -1));
CURL_SOCKET_BAD:conn->sock[writesockindex];
conn->bits.getheader = getheader;
- data->reqdata.size = size;
- data->reqdata.bytecountp = bytecountp;
- data->reqdata.writebytecountp = writecountp;
+ k->size = size;
+ k->bytecountp = bytecountp;
+ k->writebytecountp = writecountp;
/* The code sequence below is placed in this function just because all
necessary input is not always known in do_complete() as this function may
if(!conn->bits.getheader) {
k->header = FALSE;
- if(k->size > 0)
- Curl_pgrsSetDownloadSize(data, k->size);
+ if(size > 0)
+ Curl_pgrsSetDownloadSize(data, size);
}
/* we want header and/or body, if neither then don't do this! */
if(conn->bits.getheader || !conn->bits.no_body) {
state info where we wait for the 100-return code
*/
if(data->state.expect100header &&
- (data->reqdata.proto.http->sending == HTTPSEND_BODY)) {
+ (data->state.proto.http->sending == HTTPSEND_BODY)) {
/* wait with write until we either got 100-continue or a timeout */
k->write_after_100_header = TRUE;
k->start100 = k->start;
}
}
- if(data->reqdata.rangestringalloc)
- free(data->reqdata.range);
+ if(data->state.rangestringalloc)
+ free(data->state.range);
/* Free the pathbuffer */
- Curl_safefree(data->reqdata.pathbuffer);
- Curl_safefree(data->reqdata.proto.generic);
+ Curl_safefree(data->state.pathbuffer);
+ Curl_safefree(data->state.proto.generic);
/* Close down all open SSL info and sessions */
Curl_ssl_close_all(data);
}
conn_free(conn);
- data->reqdata.current_conn = NULL;
+ data->state.current_conn = NULL;
return CURLE_OK;
}
char *at;
char *tmp;
- char *path = data->reqdata.path;
+ char *path = data->state.path;
/*************************************************************
* Parse the URL.
* So if the URL was A://B/C,
* conn->protostr is A
* conn->host.name is B
- * data->reqdata.path is /C
+ * data->state.path is /C
*/
return CURLE_OK;
* If we're doing a resumed transfer, we need to setup our stuff
* properly.
*/
- struct HandleData *req = &data->reqdata;
-
- req->resume_from = data->set.set_resume_from;
- if(req->resume_from || data->set.str[STRING_SET_RANGE]) {
- if(req->rangestringalloc)
- free(req->range);
-
- if(req->resume_from)
- req->range = aprintf("%" FORMAT_OFF_T "-", req->resume_from);
+ 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);
+
+ if(s->resume_from)
+ s->range = aprintf("%" FORMAT_OFF_T "-", s->resume_from);
else
- req->range = strdup(data->set.str[STRING_SET_RANGE]);
+ s->range = strdup(data->set.str[STRING_SET_RANGE]);
- req->rangestringalloc = (unsigned char)(req->range?TRUE:FALSE);
+ s->rangestringalloc = (bool)(s->range?TRUE:FALSE);
- if(!req->range)
+ if(!s->range)
return CURLE_OUT_OF_MEMORY;
/* tell ourselves to fetch this range */
- req->use_range = TRUE; /* enable range download */
+ s->use_range = TRUE; /* enable range download */
}
else
- req->use_range = FALSE; /* disable range download */
+ s->use_range = FALSE; /* disable range download */
return CURLE_OK;
}
urllen=LEAST_PATH_ALLOC;
/* Free the old buffer */
- Curl_safefree(data->reqdata.pathbuffer);
+ Curl_safefree(data->state.pathbuffer);
/*
* We malloc() the buffers below urllen+2 to make room for to possibilities:
* 2 - an extra slash (in case a syntax like "www.host.com?moo" is used)
*/
- data->reqdata.pathbuffer=(char *)malloc(urllen+2);
- if(NULL == data->reqdata.pathbuffer)
+ data->state.pathbuffer=(char *)malloc(urllen+2);
+ if(NULL == data->state.pathbuffer)
return CURLE_OUT_OF_MEMORY; /* really bad error */
- data->reqdata.path = data->reqdata.pathbuffer;
+ data->state.path = data->state.pathbuffer;
conn->host.rawalloc=(char *)malloc(urllen+2);
if(NULL == conn->host.rawalloc)
char *url;
url = aprintf("%s://%s:%d%s", conn->protostr, conn->host.name,
- conn->remote_port, data->reqdata.path);
+ conn->remote_port, data->state.path);
if(!url)
return CURLE_OUT_OF_MEMORY;
return CURLE_OUT_OF_MEMORY;
}
- data->reqdata.keep.headerbytecount = 0;
+ data->req.headerbytecount = 0;
#ifdef CURL_DO_LINEEND_CONV
data->state.crlf_conversions = 0; /* reset CRLF conversion counter */
conn->writechannel_inuse = FALSE;
/* Cleanup possible redirect junk */
- if(data->reqdata.newurl) {
- free(data->reqdata.newurl);
- data->reqdata.newurl = NULL;
+ if(data->req.newurl) {
+ free(data->req.newurl);
+ data->req.newurl = NULL;
}
if(conn->dns_entry) {
static CURLcode do_init(struct connectdata *conn)
{
struct SessionHandle *data = conn->data;
- struct Curl_transfer_keeper *k = &data->reqdata.keep;
+ struct SingleRequest *k = &data->req;
conn->bits.done = FALSE; /* Curl_done() is not called yet */
conn->bits.do_more = FALSE; /* by default there's no curl_do_more() to use */
- /* NB: the content encoding software depends on this initialization of
- Curl_transfer_keeper.*/
- memset(k, 0, sizeof(struct Curl_transfer_keeper));
+ /* NB: the content encoding software depends on this initialization */
+ Curl_easy_initHandleData(data);
k->start = Curl_tvnow(); /* start time */
k->now = k->start; /* current time is now */
*/
static void do_complete(struct connectdata *conn)
{
- struct SessionHandle *data = conn->data;
- struct Curl_transfer_keeper *k = &data->reqdata.keep;
conn->bits.chunk=FALSE;
conn->bits.trailerhdrpresent=FALSE;
- k->maxfd = (conn->sockfd>conn->writesockfd?
- conn->sockfd:conn->writesockfd)+1;
-
- k->size = data->reqdata.size;
- k->maxdownload = data->reqdata.maxdownload;
- k->bytecountp = data->reqdata.bytecountp;
- k->writebytecountp = data->reqdata.writebytecountp;
-
+ conn->data->req.maxfd = (conn->sockfd>conn->writesockfd?
+ conn->sockfd:conn->writesockfd)+1;
}
CURLcode Curl_do(struct connectdata **connp, bool *done)
void Curl_reset_reqproto(struct connectdata *conn)
{
struct SessionHandle *data = conn->data;
- if(data->reqdata.proto.generic && data->reqdata.current_conn != conn) {
- free(data->reqdata.proto.generic);
- data->reqdata.proto.generic = NULL;
+ if(data->state.proto.generic && data->state.current_conn != conn) {
+ free(data->state.proto.generic);
+ data->state.proto.generic = NULL;
}
- data->reqdata.current_conn = conn;
+ data->state.current_conn = conn;
}
} zlibInitState;
#endif
-/*
- * This struct is all the previously local variables from Curl_perform() moved
- * to struct to allow the function to return and get re-invoked better without
- * losing state.
- */
+#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
-struct Curl_transfer_keeper {
+#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);
- /** Values copied over from the HandleData struct each time on init **/
+/*
+ * Request specific data in the easy handle (SessionHandle). Previously,
+ * these members were on the connectdata struct but since a conn struct may
+ * now be shared between different SessionHandles, we store connection-specifc
+ * data here. This struct only keeps stuff that's interesting for *this*
+ * request, as it will be cleared between multiple ones
+ */
+struct SingleRequest {
curl_off_t size; /* -1 if unknown at this point */
curl_off_t *bytecountp; /* return number of bytes read or NULL */
-1 means unlimited */
curl_off_t *writebytecountp; /* return number of bytes written or NULL */
- /** End of HandleData struct copies **/
-
curl_off_t bytecount; /* total number of bytes read */
curl_off_t writebytecount; /* number of bytes written */
- long headerbytecount; /* only count received headers */
+ long headerbytecount; /* only count received headers */
long deductheadercount; /* this amount of bytes doesn't count when we check
- if anything has been transfered at the end of
- a connection. We use this counter to make only
- a 100 reply (without a following second response
- code) result in a CURLE_GOT_NOTHING error code */
+ if anything has been transfered at the end of a
+ connection. We use this counter to make only a
+ 100 reply (without a following second response
+ code) result in a CURLE_GOT_NOTHING error code */
struct timeval start; /* transfer started at this time */
struct timeval now; /* current time */
bool ignorebody; /* we read a response-body but we ignore it! */
bool ignorecl; /* This HTTP response has no body so we ignore the Content-
Length: header */
-};
-
-#if defined(USE_ARES) || defined(USE_THREADING_GETHOSTBYNAME) || \
- defined(USE_THREADING_GETADDRINFO)
-struct Curl_async {
- char *hostname;
- int port;
- struct Curl_dns_entry *dns;
- bool done; /* set TRUE when the lookup is complete */
- int status; /* if done is TRUE, this is the status from the callback */
- void *os_specific; /* 'struct thread_data' for Windows */
-};
-#endif
-
-#define FIRSTSOCKET 0
-#define SECONDARYSOCKET 1
-
-/* These function pointer types are here only to allow easier typecasting
- within the source when we need to cast between data pointers (such as NULL)
- and function pointers. */
-typedef CURLcode (*Curl_do_more_func)(struct connectdata *);
-typedef CURLcode (*Curl_done_func)(struct connectdata *, CURLcode, bool);
-
-
-/*
- * Store's request specific data in the easy handle (SessionHandle).
- * Previously, these members were on the connectdata struct but since
- * a conn struct may now be shared between different SessionHandles,
- * we store connection-specifc data here.
- *
- */
-struct HandleData {
- char *pathbuffer;/* allocated buffer to store the URL's path part in */
- char *path; /* path to use, points to somewhere within the pathbuffer
- area */
char *newurl; /* This can only be set if a Location: was in the
document headers */
- /* This struct is inited when needed */
- struct Curl_transfer_keeper keep;
-
/* 'upload_present' is used to keep a byte counter of how much data there is
still left in the buffer, aimed for upload. */
ssize_t upload_present;
and the 'upload_present' contains the number of bytes available at this
position */
char *upload_fromhere;
-
- curl_off_t size; /* -1 if unknown at this point */
- curl_off_t *bytecountp; /* return number of bytes read or NULL */
-
- curl_off_t maxdownload; /* in bytes, the maximum amount of data to fetch, -1
- means unlimited */
- curl_off_t *writebytecountp; /* return number of bytes written or NULL */
-
- bool use_range;
- bool rangestringalloc; /* the range string is malloc()'ed */
-
- char *range; /* range, if used. See README for detailed specification on
- this syntax. */
- curl_off_t resume_from; /* continue [ftp] transfer from here */
-
- /* Protocol specific data.
- *
- *************************************************************************
- * Note that this data will be REMOVED after each request, so anything that
- * should be kept/stored on a per-connection basis and thus live for the
- * next requst on the same connection MUST be put in the connectdata struct!
- *************************************************************************/
- union {
- struct HTTP *http;
- struct HTTP *https; /* alias, just for the sake of being more readable */
- struct FTP *ftp;
- void *tftp; /* private for tftp.c-eyes only */
- struct FILEPROTO *file;
- void *telnet; /* private for telnet.c-eyes only */
- void *generic;
- struct SSHPROTO *ssh;
- } proto;
- /* current user of this HandleData instance, or NULL */
- struct connectdata *current_conn;
};
/*
bool closed; /* set to TRUE when curl_easy_cleanup() has been called on this
handle, but it is kept around as mentioned for
shared_conn */
+ char *pathbuffer;/* allocated buffer to store the URL's path part in */
+ char *path; /* path to use, points to somewhere within the pathbuffer
+ area */
+
+ bool use_range;
+ bool rangestringalloc; /* the range string is malloc()'ed */
+
+ char *range; /* range, if used. See README for detailed specification on
+ this syntax. */
+ curl_off_t resume_from; /* continue [ftp] transfer from here */
+
+ /* Protocol specific data.
+ *
+ *************************************************************************
+ * Note that this data will be REMOVED after each request, so anything that
+ * should be kept/stored on a per-connection basis and thus live for the
+ * next requst on the same connection MUST be put in the connectdata struct!
+ *************************************************************************/
+ union {
+ struct HTTP *http;
+ struct HTTP *https; /* alias, just for the sake of being more readable */
+ struct FTP *ftp;
+ void *tftp; /* private for tftp.c-eyes only */
+ struct FILEPROTO *file;
+ void *telnet; /* private for telnet.c-eyes only */
+ void *generic;
+ struct SSHPROTO *ssh;
+ } proto;
+ /* current user of this SessionHandle instance, or NULL */
+ struct connectdata *current_conn;
};
bool ftp_create_missing_dirs; /* create directories that don't exist */
bool ftp_use_port; /* use the FTP PORT command */
bool hide_progress; /* don't use the progress meter */
- bool http_fail_on_error; /* fail on HTTP error codes >= 300 */
+ bool http_fail_on_error; /* fail on HTTP error codes >= 300 */
bool http_follow_location; /* follow HTTP redirects */
bool http_disable_hostname_check_before_authentication;
bool include_header; /* include received protocol headers in data output */
in multi controlling structure to assist
in removal. */
struct Curl_share *share; /* Share, handles global variable mutexing */
- struct HandleData reqdata; /* Request-specific data */
+ struct SingleRequest req; /* Request-specific data */
struct UserDefined set; /* values set by the libcurl user */
struct DynamicStatic change; /* possibly modified userdefined data */
struct CookieInfo *cookies; /* the cookies, read from files and servers.
projects / curl / commitdiff