From 0ece1b5c34c049a3226f7dd793cf75e470c46e4d Mon Sep 17 00:00:00 2001 From: Daniel Stenberg Date: Thu, 30 Aug 2001 22:48:34 +0000 Subject: Major rename and redesign of the internal "backbone" structs. Details will be posted in a minute to the libcurl list. --- lib/dict.c | 2 +- lib/easy.c | 13 +- lib/file.c | 4 +- lib/ftp.c | 151 +++++++-------- lib/getinfo.c | 23 +-- lib/getinfo.h | 4 +- lib/hostip.c | 4 +- lib/hostip.h | 4 +- lib/http.c | 185 +++++++++--------- lib/krb4.c | 20 +- lib/ldap.c | 12 +- lib/progress.c | 38 ++-- lib/progress.h | 12 +- lib/security.c | 22 +-- lib/sendf.c | 30 +-- lib/sendf.h | 6 +- lib/speedcheck.c | 20 +- lib/speedcheck.h | 4 +- lib/ssluse.c | 96 +++++----- lib/ssluse.h | 4 +- lib/telnet.c | 26 +-- lib/transfer.c | 152 ++++++++------- lib/transfer.h | 2 +- lib/url.c | 572 +++++++++++++++++++++++++++---------------------------- lib/url.h | 8 +- lib/urldata.h | 320 +++++++++++++++---------------- 26 files changed, 855 insertions(+), 879 deletions(-) diff --git a/lib/dict.c b/lib/dict.c index ff0e90541..f8763e29a 100644 --- a/lib/dict.c +++ b/lib/dict.c @@ -90,7 +90,7 @@ CURLcode Curl_dict(struct connectdata *conn) char *nthdef = NULL; /* This is not part of the protocol, but required by RFC 2229 */ CURLcode result=CURLE_OK; - struct UrlData *data=conn->data; + struct SessionHandle *data=conn->data; char *path = conn->path; long *bytecount = &conn->bytecount; diff --git a/lib/easy.c b/lib/easy.c index 51521164d..38ae32082 100644 --- a/lib/easy.c +++ b/lib/easy.c @@ -175,7 +175,7 @@ void curl_global_cleanup(void) CURL *curl_easy_init(void) { CURLcode res; - struct UrlData *data; + struct SessionHandle *data; /* Make sure we inited the global SSL stuff */ if (!initialized) @@ -186,9 +186,6 @@ CURL *curl_easy_init(void) if(res != CURLE_OK) return NULL; - /* SAC */ - data->device = NULL; - return data; } @@ -199,7 +196,7 @@ CURLcode curl_easy_setopt(CURL *curl, CURLoption tag, ...) func_T param_func = (func_T)0; long param_long = 0; void *param_obj = NULL; - struct UrlData *data = curl; + struct SessionHandle *data = curl; va_start(arg, tag); @@ -231,14 +228,14 @@ CURLcode curl_easy_setopt(CURL *curl, CURLoption tag, ...) CURLcode curl_easy_perform(CURL *curl) { - struct UrlData *data = (struct UrlData *)curl; + struct SessionHandle *data = (struct SessionHandle *)curl; return Curl_perform(data); } void curl_easy_cleanup(CURL *curl) { - struct UrlData *data = (struct UrlData *)curl; + struct SessionHandle *data = (struct SessionHandle *)curl; Curl_close(data); } @@ -246,7 +243,7 @@ CURLcode curl_easy_getinfo(CURL *curl, CURLINFO info, ...) { va_list arg; void *paramp; - struct UrlData *data = (struct UrlData *)curl; + struct SessionHandle *data = (struct SessionHandle *)curl; va_start(arg, info); paramp = va_arg(arg, void *); diff --git a/lib/file.c b/lib/file.c index c3e2ceba7..2b95d55aa 100644 --- a/lib/file.c +++ b/lib/file.c @@ -142,8 +142,8 @@ CURLcode Curl_file(struct connectdata *conn) struct stat statbuf; ssize_t expected_size=-1; ssize_t nread; - struct UrlData *data = conn->data; - char *buf = data->buffer; + struct SessionHandle *data = conn->data; + char *buf = data->state.buffer; int bytecount = 0; struct timeval start = Curl_tvnow(); struct timeval now = start; diff --git a/lib/ftp.c b/lib/ftp.c index 9ba013ff0..dc638dc61 100644 --- a/lib/ftp.c +++ b/lib/ftp.c @@ -98,7 +98,7 @@ static CURLcode _ftp_cwd(struct connectdata *conn, char *path); /* easy-to-use macro: */ #define ftpsendf Curl_ftpsendf -static CURLcode AllowServerConnect(struct UrlData *data, +static CURLcode AllowServerConnect(struct SessionHandle *data, struct connectdata *conn, int sock) { @@ -178,7 +178,7 @@ int Curl_GetFTPResponse(int sockfd, struct timeval interval; fd_set rkeepfd; fd_set readfd; - struct UrlData *data = conn->data; + struct SessionHandle *data = conn->data; char *line_start; int code=0; /* default "error code" to return */ @@ -190,9 +190,9 @@ int Curl_GetFTPResponse(int sockfd, if(ftpcode) *ftpcode=0; /* 0 for errors */ - if(data->timeout) { + if(data->set.timeout) { /* if timeout is requested, find out how much remaining time we have */ - timeout = data->timeout - /* timeout time */ + timeout = data->set.timeout - /* timeout time */ (Curl_tvlong(Curl_tvnow()) - Curl_tvlong(conn->now)); /* spent time */ if(timeout <=0 ) { failf(data, "Transfer aborted due to timeout"); @@ -255,9 +255,9 @@ int Curl_GetFTPResponse(int sockfd, the line isn't really terminated until the LF comes */ /* output debug output if that is requested */ - if(data->bits.verbose) { - fputs("< ", data->err); - fwrite(line_start, perline, 1, data->err); + if(data->set.verbose) { + fputs("< ", data->set.err); + fwrite(line_start, perline, 1, data->set.err); /* no need to output LF here, it is part of the data */ } @@ -339,8 +339,8 @@ CURLcode Curl_ftp_connect(struct connectdata *conn) { /* this is FTP and no proxy */ int nread; - struct UrlData *data=conn->data; - char *buf = data->buffer; /* this is our buffer */ + struct SessionHandle *data=conn->data; + char *buf = data->state.buffer; /* this is our buffer */ struct FTP *ftp; CURLcode result; int ftpcode; @@ -360,11 +360,11 @@ CURLcode Curl_ftp_connect(struct connectdata *conn) /* get some initial data into the ftp struct */ ftp->bytecountp = &conn->bytecount; - /* duplicate to keep them even when the data struct changes */ - ftp->user = strdup(data->user); - ftp->passwd = strdup(data->passwd); + /* no need to duplicate them, the data struct won't change */ + ftp->user = data->state.user; + ftp->passwd = data->state.passwd; - if (data->bits.tunnel_thru_httpproxy) { + if (data->set.tunnel_thru_httpproxy) { /* We want "seamless" FTP operations through HTTP proxy tunnel */ result = Curl_ConnectHTTPProxyTunnel(conn, conn->firstsocket, conn->hostname, conn->remote_port); @@ -393,14 +393,14 @@ CURLcode Curl_ftp_connect(struct connectdata *conn) #ifdef KRB4 /* if not anonymous login, try a secure login */ - if(data->bits.krb4) { + if(data->set.krb4) { /* request data protection level (default is 'clear') */ Curl_sec_request_prot(conn, "private"); /* We set private first as default, in case the line below fails to set a valid level */ - Curl_sec_request_prot(conn, data->krb4_level); + Curl_sec_request_prot(conn, data->set.krb4_level); if(Curl_sec_login(conn) != 0) infof(data, "Logging in with password in cleartext!\n"); @@ -462,7 +462,7 @@ CURLcode Curl_ftp_connect(struct connectdata *conn) /* we may need to issue a KAUTH here to have access to the files * do it if user supplied a password */ - if(conn->data->passwd && *conn->data->passwd) + if(conn->data->set.passwd && *conn->data->set.passwd) Curl_krb_kauth(conn); #endif } @@ -530,16 +530,16 @@ CURLcode Curl_ftp_connect(struct connectdata *conn) /* argument is already checked for validity */ CURLcode Curl_ftp_done(struct connectdata *conn) { - struct UrlData *data = conn->data; + struct SessionHandle *data = conn->data; struct FTP *ftp = conn->proto.ftp; ssize_t nread; - char *buf = data->buffer; /* this is our buffer */ + char *buf = data->state.buffer; /* this is our buffer */ int ftpcode; - if(data->bits.upload) { - if((-1 != data->infilesize) && (data->infilesize != *ftp->bytecountp)) { + if(data->set.upload) { + if((-1 != data->set.infilesize) && (data->set.infilesize != *ftp->bytecountp)) { failf(data, "Wrote only partial file (%d out of %d bytes)", - *ftp->bytecountp, data->infilesize); + *ftp->bytecountp, data->set.infilesize); return CURLE_PARTIAL_FILE; } } @@ -550,7 +550,7 @@ CURLcode Curl_ftp_done(struct connectdata *conn) return CURLE_PARTIAL_FILE; } else if(!conn->bits.resume_done && - !data->bits.no_body && + !data->set.no_body && (0 == *ftp->bytecountp)) { failf(data, "No data was received!"); return CURLE_FTP_COULDNT_RETR_FILE; @@ -564,7 +564,7 @@ CURLcode Curl_ftp_done(struct connectdata *conn) sclose(conn->secondarysocket); conn->secondarysocket = -1; - if(!data->bits.no_body && !conn->bits.resume_done) { + if(!data->set.no_body && !conn->bits.resume_done) { /* now let's see what the server says about the transfer we just performed: */ nread = Curl_GetFTPResponse(conn->firstsocket, buf, conn, &ftpcode); @@ -581,8 +581,8 @@ CURLcode Curl_ftp_done(struct connectdata *conn) conn->bits.resume_done = FALSE; /* clean this for next connection */ /* Send any post-transfer QUOTE strings? */ - if(data->postquote) { - CURLcode result = _ftp_sendquote(conn, data->postquote); + if(data->set.postquote) { + CURLcode result = _ftp_sendquote(conn, data->set.postquote); return result; } @@ -603,7 +603,7 @@ CURLcode _ftp_sendquote(struct connectdata *conn, struct curl_slist *quote) ftpsendf(conn->firstsocket, conn, "%s", item->data); nread = Curl_GetFTPResponse(conn->firstsocket, - conn->data->buffer, conn, &ftpcode); + conn->data->state.buffer, conn, &ftpcode); if (nread < 0) return CURLE_OPERATION_TIMEOUTED; @@ -627,7 +627,7 @@ CURLcode _ftp_cwd(struct connectdata *conn, char *path) ftpsendf(conn->firstsocket, conn, "CWD %s", path); nread = Curl_GetFTPResponse(conn->firstsocket, - conn->data->buffer, conn, &ftpcode); + conn->data->state.buffer, conn, &ftpcode); if (nread < 0) return CURLE_OPERATION_TIMEOUTED; @@ -645,7 +645,7 @@ CURLcode _ftp_getfiletime(struct connectdata *conn, char *file) CURLcode result=CURLE_OK; int ftpcode; /* for ftp status */ ssize_t nread; - char *buf = conn->data->buffer; + char *buf = conn->data->state.buffer; /* we have requested to get the modified-time of the file, this is yet again a grey area as the MDTM is not kosher RFC959 */ @@ -666,7 +666,7 @@ CURLcode _ftp_getfiletime(struct connectdata *conn, char *file) sprintf(buf, "%04d%02d%02d %02d:%02d:%02d", year, month, day, hour, minute, second); /* now, convert this into a time() value: */ - conn->data->progress.filetime = curl_getdate(buf, &secs); + conn->data->info.filetime = curl_getdate(buf, &secs); } else { infof(conn->data, "unsupported MDTM reply format\n"); @@ -678,10 +678,10 @@ CURLcode _ftp_getfiletime(struct connectdata *conn, char *file) static CURLcode _ftp_transfertype(struct connectdata *conn, bool ascii) { - struct UrlData *data = conn->data; + struct SessionHandle *data = conn->data; int ftpcode; ssize_t nread; - char *buf=data->buffer; + char *buf=data->state.buffer; ftpsendf(conn->firstsocket, conn, "TYPE %s", ascii?"A":"I"); @@ -702,10 +702,10 @@ static CURLcode _ftp_getsize(struct connectdata *conn, char *file, ssize_t *size) { - struct UrlData *data = conn->data; + struct SessionHandle *data = conn->data; int ftpcode; ssize_t nread; - char *buf=data->buffer; + char *buf=data->state.buffer; ftpsendf(conn->firstsocket, conn, "SIZE %s", file); nread = Curl_GetFTPResponse(conn->firstsocket, buf, conn, &ftpcode); @@ -729,8 +729,8 @@ CURLcode _ftp(struct connectdata *conn) /* this is FTP and no proxy */ ssize_t nread; CURLcode result; - struct UrlData *data=conn->data; - char *buf = data->buffer; /* this is our buffer */ + struct SessionHandle *data=conn->data; + char *buf = data->state.buffer; /* this is our buffer */ /* for the ftp PORT mode */ int portsock=-1; #if defined (HAVE_INET_NTOA_R) @@ -750,8 +750,8 @@ CURLcode _ftp(struct connectdata *conn) int ftpcode; /* for ftp status */ /* Send any QUOTE strings? */ - if(data->quote) { - if ((result = _ftp_sendquote(conn, data->quote)) != CURLE_OK) + if(data->set.quote) { + if ((result = _ftp_sendquote(conn, data->set.quote)) != CURLE_OK) return result; } @@ -770,7 +770,7 @@ CURLcode _ftp(struct connectdata *conn) } /* Requested time of file? */ - if(data->bits.get_filetime && ftp->file) { + if(data->set.get_filetime && ftp->file) { result = _ftp_getfiletime(conn, ftp->file); if(result) return result; @@ -778,7 +778,7 @@ CURLcode _ftp(struct connectdata *conn) /* If we have selected NOBODY, it means that we only want file information. Which in FTP can't be much more than the file size! */ - if(data->bits.no_body) { + if(data->set.no_body) { /* The SIZE command is _not_ RFC 959 specified, and therefor many servers may not support it! It is however the only way we have to get a file's size! */ @@ -786,7 +786,7 @@ CURLcode _ftp(struct connectdata *conn) /* Some servers return different sizes for different modes, and thus we must set the proper type before we check the size */ - result = _ftp_transfertype(conn, data->bits.ftp_ascii); + result = _ftp_transfertype(conn, data->set.ftp_ascii); if(result) return result; @@ -804,13 +804,13 @@ CURLcode _ftp(struct connectdata *conn) well, we "emulate" a HTTP-style header in our output. */ #ifdef HAVE_STRFTIME - if(data->bits.get_filetime && data->progress.filetime) { + if(data->set.get_filetime && data->info.filetime) { struct tm *tm; #ifdef HAVE_LOCALTIME_R struct tm buffer; - tm = (struct tm *)localtime_r(&data->progress.filetime, &buffer); + tm = (struct tm *)localtime_r(&data->info.filetime, &buffer); #else - tm = localtime(&data->progress.filetime); + tm = localtime(&data->info.filetime); #endif /* format: "Tue, 15 Nov 1994 12:45:26 GMT" */ strftime(buf, BUFSIZE-1, "Last-Modified: %a, %d %b %Y %H:%M:%S %Z\r\n", @@ -825,7 +825,7 @@ CURLcode _ftp(struct connectdata *conn) } /* We have chosen to use the PORT command */ - if(data->bits.ftp_use_port) { + if(data->set.ftp_use_port) { #ifdef ENABLE_IPV6 struct addrinfo hints, *res, *ai; struct sockaddr_storage ss; @@ -1005,15 +1005,15 @@ CURLcode _ftp(struct connectdata *conn) unsigned short porttouse; char myhost[256] = ""; - if(data->ftpport) { - if(Curl_if2ip(data->ftpport, myhost, sizeof(myhost))) { + if(data->set.ftpport) { + if(Curl_if2ip(data->set.ftpport, myhost, sizeof(myhost))) { h = Curl_gethost(data, myhost, &hostdataptr); } else { - if(strlen(data->ftpport)>1) - h = Curl_gethost(data, data->ftpport, &hostdataptr); + if(strlen(data->set.ftpport)>1) + h = Curl_gethost(data, data->set.ftpport, &hostdataptr); if(h) - strcpy(myhost, data->ftpport); /* buffer overflow risk */ + strcpy(myhost, data->set.ftpport); /* buffer overflow risk */ } } if(! *myhost) { @@ -1172,7 +1172,7 @@ CURLcode _ftp(struct connectdata *conn) sprintf(newhost, "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]); newport = (port[0]<<8) + port[1]; - if(data->bits.httpproxy) { + if(data->change.proxy) { /* * This is a tunnel through a http proxy and we need to connect to the * proxy again here. We already have the name info for it since the @@ -1214,7 +1214,7 @@ CURLcode _ftp(struct connectdata *conn) if (conn->secondarysocket < 0) continue; - if(data->bits.verbose) { + if(data->set.verbose) { char hbuf[NI_MAXHOST]; char nbuf[NI_MAXHOST]; char sbuf[NI_MAXSERV]; @@ -1258,7 +1258,7 @@ CURLcode _ftp(struct connectdata *conn) serv_addr.sin_port = htons(connectport); - if(data->bits.verbose) { + if(data->set.verbose) { struct in_addr in; struct hostent * answer; @@ -1346,7 +1346,7 @@ CURLcode _ftp(struct connectdata *conn) } #endif /*ENABLE_IPV6*/ - if (data->bits.tunnel_thru_httpproxy) { + if (data->set.tunnel_thru_httpproxy) { /* We want "seamless" FTP operations through HTTP proxy tunnel */ result = Curl_ConnectHTTPProxyTunnel(conn, conn->secondarysocket, newhost, newport); @@ -1360,10 +1360,10 @@ CURLcode _ftp(struct connectdata *conn) /* we have the (new) data connection ready */ infof(data, "Connected the data stream!\n"); - if(data->bits.upload) { + if(data->set.upload) { /* Set type to binary (unless specified ASCII) */ - result = _ftp_transfertype(conn, data->bits.ftp_ascii); + result = _ftp_transfertype(conn, data->set.ftp_ascii); if(result) return result; @@ -1395,7 +1395,7 @@ CURLcode _ftp(struct connectdata *conn) /* do we still game? */ int passed=0; /* enable append instead */ - data->bits.ftp_append = 1; + data->set.ftp_append = 1; /* Now, let's read off the proper amount of bytes from the input. If we knew it was a proper file we could've just @@ -1408,7 +1408,8 @@ CURLcode _ftp(struct connectdata *conn) readthisamountnow = BUFSIZE; actuallyread = - data->fread(data->buffer, 1, readthisamountnow, data->in); + data->set.fread(data->state.buffer, 1, readthisamountnow, + data->set.in); passed += actuallyread; if(actuallyread != readthisamountnow) { @@ -1419,10 +1420,10 @@ CURLcode _ftp(struct connectdata *conn) while(passed != conn->resume_from); /* now, decrease the size of the read */ - if(data->infilesize>0) { - data->infilesize -= conn->resume_from; + if(data->set.infilesize>0) { + data->set.infilesize -= conn->resume_from; - if(data->infilesize <= 0) { + if(data->set.infilesize <= 0) { infof(data, "File already completely uploaded\n"); /* no data to transfer */ @@ -1440,8 +1441,8 @@ CURLcode _ftp(struct connectdata *conn) } } - /* Send everything on data->in to the socket */ - if(data->bits.ftp_append) + /* Send everything on data->set.in to the socket */ + if(data->set.ftp_append) /* we append onto the file instead of rewriting it */ ftpsendf(conn->firstsocket, conn, "APPE %s", ftp->file); else @@ -1457,7 +1458,7 @@ CURLcode _ftp(struct connectdata *conn) return CURLE_FTP_COULDNT_STOR_FILE; } - if(data->bits.ftp_use_port) { + if(data->set.ftp_use_port) { /* PORT means we are now awaiting the server to connect to us. */ result = AllowServerConnect(data, conn, portsock); if( result ) @@ -1469,7 +1470,7 @@ CURLcode _ftp(struct connectdata *conn) /* When we know we're uploading a specified file, we can get the file size prior to the actual upload. */ - Curl_pgrsSetUploadSize(data, data->infilesize); + Curl_pgrsSetUploadSize(data, data->set.infilesize); result = Curl_Transfer(conn, -1, -1, FALSE, NULL, /* no download */ conn->secondarysocket, bytecountp); @@ -1520,7 +1521,7 @@ CURLcode _ftp(struct connectdata *conn) from, to, totalsize); } - if((data->bits.ftp_list_only) || !ftp->file) { + if((data->set.ftp_list_only) || !ftp->file) { /* The specified path ends with a slash, and therefore we think this is a directory that is requested, use LIST. But before that we need to set ASCII transfer mode. */ @@ -1536,12 +1537,12 @@ CURLcode _ftp(struct connectdata *conn) standard in any way */ ftpsendf(conn->firstsocket, conn, "%s", - data->customrequest?data->customrequest: - (data->bits.ftp_list_only?"NLST":"LIST")); + data->set.customrequest?data->set.customrequest: + (data->set.ftp_list_only?"NLST":"LIST")); } else { /* Set type to binary (unless specified ASCII) */ - result = _ftp_transfertype(conn, data->bits.ftp_ascii); + result = _ftp_transfertype(conn, data->set.ftp_ascii); if(result) return result; @@ -1647,7 +1648,7 @@ CURLcode _ftp(struct connectdata *conn) int size=-1; /* default unknown size */ if(!dirlist && - !data->bits.ftp_ascii && + !data->set.ftp_ascii && (-1 == downloadsize)) { /* * It seems directory listings either don't show the size or very @@ -1684,7 +1685,7 @@ CURLcode _ftp(struct connectdata *conn) else if(downloadsize > -1) size = downloadsize; - if(data->bits.ftp_use_port) { + if(data->set.ftp_use_port) { result = AllowServerConnect(data, conn, portsock); if( result ) return result; @@ -1717,7 +1718,7 @@ CURLcode Curl_ftp(struct connectdata *conn) { CURLcode retcode; - struct UrlData *data = conn->data; + struct SessionHandle *data = conn->data; struct FTP *ftp; int dirlength=0; /* 0 forces strlen() */ @@ -1793,8 +1794,8 @@ size_t Curl_ftpsendf(int fd, struct connectdata *conn, vsnprintf(s, 250, fmt, ap); va_end(ap); - if(conn->data->bits.verbose) - fprintf(conn->data->err, "> %s\n", s); + if(conn->data->set.verbose) + fprintf(conn->data->set.err, "> %s\n", s); strcat(s, "\r\n"); /* append a trailing CRLF */ @@ -1811,10 +1812,6 @@ CURLcode Curl_ftp_disconnect(struct connectdata *conn) /* The FTP session may or may not have been allocated/setup at this point! */ if(ftp) { - if(ftp->user) - free(ftp->user); - if(ftp->passwd) - free(ftp->passwd); if(ftp->entrypath) free(ftp->entrypath); } diff --git a/lib/getinfo.c b/lib/getinfo.c index c3c110330..fef5fec67 100644 --- a/lib/getinfo.c +++ b/lib/getinfo.c @@ -35,22 +35,23 @@ * This is supposed to be called in the beginning of a permform() session * and should reset all session-info variables */ -CURLcode Curl_initinfo(struct UrlData *data) +CURLcode Curl_initinfo(struct SessionHandle *data) { struct Progress *pro = &data->progress; + struct PureInfo *info =&data->info; pro->t_nslookup = 0; pro->t_connect = 0; pro->t_pretransfer = 0; - pro->httpcode = 0; - pro->httpversion=0; - pro->filetime=0; + info->httpcode = 0; + info->httpversion=0; + info->filetime=0; return CURLE_OK; } -CURLcode Curl_getinfo(struct UrlData *data, CURLINFO info, ...) +CURLcode Curl_getinfo(struct SessionHandle *data, CURLINFO info, ...) { va_list arg; long *param_longp; @@ -80,19 +81,19 @@ CURLcode Curl_getinfo(struct UrlData *data, CURLINFO info, ...) switch(info) { case CURLINFO_EFFECTIVE_URL: - *param_charp = data->url?data->url:(char *)""; + *param_charp = data->change.url?data->change.url:(char *)""; break; case CURLINFO_HTTP_CODE: - *param_longp = data->progress.httpcode; + *param_longp = data->info.httpcode; break; case CURLINFO_FILETIME: - *param_longp = data->progress.filetime; + *param_longp = data->info.filetime; break; case CURLINFO_HEADER_SIZE: - *param_longp = data->header_size; + *param_longp = data->info.header_size; break; case CURLINFO_REQUEST_SIZE: - *param_longp = data->request_size; + *param_longp = data->info.request_size; break; case CURLINFO_TOTAL_TIME: *param_doublep = data->progress.timespent; @@ -119,7 +120,7 @@ CURLcode Curl_getinfo(struct UrlData *data, CURLINFO info, ...) *param_doublep = data->progress.ulspeed; break; case CURLINFO_SSL_VERIFYRESULT: - *param_longp = data->ssl.certverifyresult; + *param_longp = data->set.ssl.certverifyresult; break; case CURLINFO_CONTENT_LENGTH_DOWNLOAD: *param_doublep = data->progress.size_dl; diff --git a/lib/getinfo.h b/lib/getinfo.h index 6045fd189..23fdff1f4 100644 --- a/lib/getinfo.h +++ b/lib/getinfo.h @@ -22,7 +22,7 @@ * * $Id$ *****************************************************************************/ -CURLcode Curl_getinfo(struct UrlData *data, CURLINFO info, ...); -CURLcode Curl_initinfo(struct UrlData *data); +CURLcode Curl_getinfo(struct SessionHandle *data, CURLINFO info, ...); +CURLcode Curl_initinfo(struct SessionHandle *data); #endif diff --git a/lib/hostip.c b/lib/hostip.c index 9d2119f0d..5fdd9ddcd 100644 --- a/lib/hostip.c +++ b/lib/hostip.c @@ -89,7 +89,7 @@ static char *MakeIP(unsigned long num,char *addr, int addr_len) } #ifdef ENABLE_IPV6 -struct addrinfo *Curl_getaddrinfo(struct UrlData *data, +struct addrinfo *Curl_getaddrinfo(struct SessionHandle *data, char *hostname, int port) { @@ -119,7 +119,7 @@ struct addrinfo *Curl_getaddrinfo(struct UrlData *data, #define INADDR_NONE (unsigned long) ~0 #endif -struct hostent *Curl_gethost(struct UrlData *data, +struct hostent *Curl_gethost(struct SessionHandle *data, char *hostname, char **bufp) { diff --git a/lib/hostip.h b/lib/hostip.h index d7c9b26f1..5dab8e4e9 100644 --- a/lib/hostip.h +++ b/lib/hostip.h @@ -24,11 +24,11 @@ *****************************************************************************/ struct addrinfo; -struct addrinfo *Curl_getaddrinfo(struct UrlData *data, +struct addrinfo *Curl_getaddrinfo(struct SessionHandle *data, char *hostname, int port); -struct hostent *Curl_gethost(struct UrlData *data, +struct hostent *Curl_gethost(struct SessionHandle *data, char *hostname, char **bufp); diff --git a/lib/http.c b/lib/http.c index df5e58557..a1ab24b86 100644 --- a/lib/http.c +++ b/lib/http.c @@ -128,10 +128,10 @@ static size_t add_buffer_send(int sockfd, struct connectdata *conn, send_buffer *in) { size_t amount; - if(conn->data->bits.verbose) { - fputs("> ", conn->data->err); + if(conn->data->set.verbose) { + fputs("> ", conn->data->set.err); /* this data _may_ contain binary stuff */ - fwrite(in->buffer, in->size_used, 1, conn->data->err); + fwrite(in->buffer, in->size_used, 1, conn->data->set.err); } Curl_write(conn, sockfd, in->buffer, in->size_used, &amount); @@ -209,7 +209,7 @@ int GetLine(int sockfd, char *buf, struct connectdata *conn) ssize_t nread; int read_rc=1; char *ptr; - struct UrlData *data=conn->data; + struct SessionHandle *data=conn->data; ptr=buf; @@ -224,10 +224,10 @@ int GetLine(int sockfd, char *buf, struct connectdata *conn) } *ptr=0; /* zero terminate */ - if(data->bits.verbose) { - fputs("< ", data->err); - fwrite(buf, 1, nread, data->err); - fputs("\n", data->err); + if(data->set.verbose) { + fputs("< ", data->set.err); + fwrite(buf, 1, nread, data->set.err); + fputs("\n", data->set.err); } return nread>0?nread:0; } @@ -238,12 +238,12 @@ int GetLine(int sockfd, char *buf, struct connectdata *conn) * This function checks the linked list of custom HTTP headers for a particular * header (prefix). */ -static bool checkheaders(struct UrlData *data, const char *thisheader) +static bool checkheaders(struct SessionHandle *data, const char *thisheader) { struct curl_slist *head; size_t thislen = strlen(thisheader); - for(head = data->headers; head; head=head->next) { + for(head = data->set.headers; head; head=head->next) { if(strnequal(head->data, thisheader, thislen)) { return TRUE; } @@ -263,7 +263,7 @@ CURLcode Curl_ConnectHTTPProxyTunnel(struct connectdata *conn, { int httperror=0; int subversion=0; - struct UrlData *data=conn->data; + struct SessionHandle *data=conn->data; infof(data, "Establish HTTP proxy tunnel to %s:%d\n", hostname, remote_port); @@ -275,14 +275,14 @@ CURLcode Curl_ConnectHTTPProxyTunnel(struct connectdata *conn, "\r\n", hostname, remote_port, (conn->bits.proxy_user_passwd)?conn->allocptr.proxyuserpwd:"", - (data->useragent?conn->allocptr.uagent:"") + (data->set.useragent?conn->allocptr.uagent:"") ); /* wait for the proxy to send us a HTTP/1.0 200 OK header */ - while(GetLine(tunnelsocket, data->buffer, conn)) { - if('\r' == data->buffer[0]) + while(GetLine(tunnelsocket, data->state.buffer, conn)) { + if('\r' == data->state.buffer[0]) break; /* end of headers */ - if(2 == sscanf(data->buffer, "HTTP/1.%d %d", + if(2 == sscanf(data->state.buffer, "HTTP/1.%d %d", &subversion, &httperror)) { ; @@ -306,7 +306,7 @@ CURLcode Curl_ConnectHTTPProxyTunnel(struct connectdata *conn, */ CURLcode Curl_http_connect(struct connectdata *conn) { - struct UrlData *data; + struct SessionHandle *data; CURLcode result; data=conn->data; @@ -318,7 +318,7 @@ CURLcode Curl_http_connect(struct connectdata *conn) * has occured, can we start talking SSL */ if (conn->protocol & PROT_HTTPS) { - if (data->bits.httpproxy) { + if (data->change.proxy) { /* HTTPS through a proxy can only be done with a tunnel */ result = Curl_ConnectHTTPProxyTunnel(conn, conn->firstsocket, conn->hostname, conn->remote_port); @@ -332,10 +332,10 @@ CURLcode Curl_http_connect(struct connectdata *conn) return result; } - if(conn->bits.user_passwd && !data->bits.this_is_a_follow) { + if(conn->bits.user_passwd && !data->state.this_is_a_follow) { /* Authorization: is requested, this is not a followed location, get the original host name */ - data->auth_host = strdup(conn->hostname); + data->state.auth_host = strdup(conn->hostname); } return CURLE_OK; @@ -345,29 +345,29 @@ CURLcode Curl_http_connect(struct connectdata *conn) protocol-specific resources */ CURLcode Curl_http_close(struct connectdata *conn) { - if(conn->data->auth_host) - free(conn->data->auth_host); + if(conn->data->state.auth_host) + free(conn->data->state.auth_host); return CURLE_OK; } CURLcode Curl_http_done(struct connectdata *conn) { - struct UrlData *data; + struct SessionHandle *data; long *bytecount = &conn->bytecount; struct HTTP *http; data=conn->data; http=conn->proto.http; - if(HTTPREQ_POST_FORM == data->httpreq) { + if(HTTPREQ_POST_FORM == data->set.httpreq) { *bytecount = http->readbytecount + http->writebytecount; Curl_formclean(http->sendit); /* Now free that whole lot */ - data->fread = http->storefread; /* restore */ - data->in = http->in; /* restore */ + data->set.fread = http->storefread; /* restore */ + data->set.in = http->in; /* restore */ } - else if(HTTPREQ_PUT == data->httpreq) { + else if(HTTPREQ_PUT == data->set.httpreq) { *bytecount = http->readbytecount + http->writebytecount; } @@ -377,8 +377,8 @@ CURLcode Curl_http_done(struct connectdata *conn) CURLcode Curl_http(struct connectdata *conn) { - struct UrlData *data=conn->data; - char *buf = data->buffer; /* this is a short cut to the buffer */ + struct SessionHandle *data=conn->data; + char *buf = data->state.buffer; /* this is a short cut to the buffer */ CURLcode result=CURLE_OK; struct HTTP *http; struct Cookie *co=NULL; /* no cookies from start */ @@ -402,8 +402,8 @@ CURLcode Curl_http(struct connectdata *conn) conn->bits.close = FALSE; if ( (conn->protocol&(PROT_HTTP|PROT_FTP)) && - data->bits.upload) { - data->httpreq = HTTPREQ_PUT; + data->set.upload) { + data->set.httpreq = HTTPREQ_PUT; } /* The User-Agent string has been built in url.c already, because it might @@ -420,45 +420,45 @@ CURLcode Curl_http(struct connectdata *conn) /* To prevent the user+password to get sent to other than the original host due to a location-follow, we do some weirdo checks here */ - if(!data->bits.this_is_a_follow || - !data->auth_host || - strequal(data->auth_host, conn->hostname)) { - sprintf(data->buffer, "%s:%s", data->user, data->passwd); - if(Curl_base64_encode(data->buffer, strlen(data->buffer), + if(!data->state.this_is_a_follow || + !data->state.auth_host || + strequal(data->state.auth_host, conn->hostname)) { + sprintf(data->state.buffer, "%s:%s", + data->state.user, data->state.passwd); + if(Curl_base64_encode(data->state.buffer, strlen(data->state.buffer), &authorization) >= 0) { if(conn->allocptr.userpwd) free(conn->allocptr.userpwd); conn->allocptr.userpwd = aprintf( "Authorization: Basic %s\015\012", - authorization); + authorization); free(authorization); } } } - if((data->bits.http_set_referer) && !checkheaders(data, "Referer:")) { + if((data->change.referer) && !checkheaders(data, "Referer:")) { if(conn->allocptr.ref) free(conn->allocptr.ref); - conn->allocptr.ref = aprintf("Referer: %s\015\012", data->referer); + conn->allocptr.ref = aprintf("Referer: %s\015\012", data->change.referer); } - if(data->cookie && !checkheaders(data, "Cookie:")) { + if(data->set.cookie && !checkheaders(data, "Cookie:")) { if(conn->allocptr.cookie) free(conn->allocptr.cookie); - conn->allocptr.cookie = aprintf("Cookie: %s\015\012", data->cookie); + conn->allocptr.cookie = aprintf("Cookie: %s\015\012", data->set.cookie); } if(data->cookies) { co = Curl_cookie_getlist(data->cookies, - host, - ppath, + host, ppath, conn->protocol&PROT_HTTPS?TRUE:FALSE); } - if ((data->bits.httpproxy) && !(conn->protocol&PROT_HTTPS)) { + if ((data->change.proxy) && !(conn->protocol&PROT_HTTPS)) { /* The path sent to the proxy is in fact the entire URL */ - ppath = data->url; + ppath = data->change.url; } - if(HTTPREQ_POST_FORM == data->httpreq) { + if(HTTPREQ_POST_FORM == data->set.httpreq) { /* we must build the whole darned post sequence first, so that we have a size of the whole shebang before we start to send it */ - http->sendit = Curl_getFormData(data->httppost, &http->postsize); + http->sendit = Curl_getFormData(data->set.httppost, &http->postsize); } if(!checkheaders(data, "Host:")) { @@ -486,9 +486,9 @@ CURLcode Curl_http(struct connectdata *conn) if(!checkheaders(data, "Accept:")) http->p_accept = "Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, */*\r\n"; - if(( (HTTPREQ_POST == data->httpreq) || - (HTTPREQ_POST_FORM == data->httpreq) || - (HTTPREQ_PUT == data->httpreq) ) && + if(( (HTTPREQ_POST == data->set.httpreq) || + (HTTPREQ_POST_FORM == data->set.httpreq) || + (HTTPREQ_PUT == data->set.httpreq) ) && conn->resume_from) { /********************************************************************** * Resuming upload in HTTP means that we PUT or POST and that we have @@ -521,7 +521,8 @@ CURLcode Curl_http(struct connectdata *conn) readthisamountnow = BUFSIZE; actuallyread = - data->fread(data->buffer, 1, readthisamountnow, data->in); + data->set.fread(data->state.buffer, 1, readthisamountnow, + data->set.in); passed += actuallyread; if(actuallyread != readthisamountnow) { @@ -532,10 +533,10 @@ CURLcode Curl_http(struct connectdata *conn) } while(passed != conn->resume_from); /* loop until done */ /* now, decrease the size of the read */ - if(data->infilesize>0) { - data->infilesize -= conn->resume_from; + if(data->set.infilesize>0) { + data->set.infilesize -= conn->resume_from; - if(data->infilesize <= 0) { + if(data->set.infilesize <= 0) { failf(data, "File already completely uploaded\n"); return CURLE_PARTIAL_FILE; } @@ -549,16 +550,16 @@ CURLcode Curl_http(struct connectdata *conn) * or uploading and we always let customized headers override our internal * ones if any such are specified. */ - if((data->httpreq == HTTPREQ_GET) && + if((data->set.httpreq == HTTPREQ_GET) && !checkheaders(data, "Range:")) { conn->allocptr.rangeline = aprintf("Range: bytes=%s\r\n", conn->range); } - else if((data->httpreq != HTTPREQ_GET) && + else if((data->set.httpreq != HTTPREQ_GET) && !checkheaders(data, "Content-Range:")) { if(conn->resume_from) { /* This is because "resume" was selected */ - long total_expected_size= conn->resume_from + data->infilesize; + long total_expected_size= conn->resume_from + data->set.infilesize; conn->allocptr.rangeline = aprintf("Content-Range: bytes %s%ld/%ld\r\n", conn->range, total_expected_size-1, total_expected_size); @@ -567,14 +568,14 @@ CURLcode Curl_http(struct connectdata *conn) /* Range was selected and then we just pass the incoming range and append total size */ conn->allocptr.rangeline = aprintf("Content-Range: bytes %s/%d\r\n", - conn->range, data->infilesize); + conn->range, data->set.infilesize); } } } do { send_buffer *req_buffer; - struct curl_slist *headers=data->headers; + struct curl_slist *headers=data->set.headers; /* initialize a dynamic send-buffer */ req_buffer = add_buffer_init(); @@ -593,11 +594,11 @@ CURLcode Curl_http(struct connectdata *conn) "%s" /* accept */ "%s", /* referer */ - data->customrequest?data->customrequest: - (data->bits.no_body?"HEAD": - ((HTTPREQ_POST == data->httpreq) || - (HTTPREQ_POST_FORM == data->httpreq))?"POST": - (HTTPREQ_PUT == data->httpreq)?"PUT":"GET"), + data->set.customrequest?data->set.customrequest: + (data->set.no_body?"HEAD": + ((HTTPREQ_POST == data->set.httpreq) || + (HTTPREQ_POST_FORM == data->set.httpreq))?"POST": + (HTTPREQ_PUT == data->set.httpreq)?"PUT":"GET"), ppath, (conn->bits.proxy_user_passwd && conn->allocptr.proxyuserpwd)?conn->allocptr.proxyuserpwd:"", @@ -605,13 +606,13 @@ CURLcode Curl_http(struct connectdata *conn) conn->allocptr.userpwd:"", (conn->bits.use_range && conn->allocptr.rangeline)? conn->allocptr.rangeline:"", - (data->useragent && *data->useragent && conn->allocptr.uagent)? + (data->set.useragent && *data->set.useragent && conn->allocptr.uagent)? conn->allocptr.uagent:"", (conn->allocptr.cookie?conn->allocptr.cookie:""), /* Cookie: */ (conn->allocptr.host?conn->allocptr.host:""), /* Host: host */ http->p_pragma?http->p_pragma:"", http->p_accept?http->p_accept:"", - (data->bits.http_set_referer && conn->allocptr.ref)?conn->allocptr.ref:"" /* Referer: */ + (data->change.referer && conn->allocptr.ref)?conn->allocptr.ref:"" /* Referer: */ ); if(co) { @@ -636,7 +637,7 @@ CURLcode Curl_http(struct connectdata *conn) co=NULL; } - if(data->timecondition) { + if(data->set.timecondition) { struct tm *thistime; /* Phil Karn (Fri, 13 Apr 2001) pointed out that the If-Modified-Since @@ -651,9 +652,9 @@ CURLcode Curl_http(struct connectdata *conn) /* We assume that the presense of localtime_r() proves the presense of gmtime_r() which is a bit ugly but might work */ struct tm keeptime; - thistime = (struct tm *)gmtime_r(&data->timevalue, &keeptime); + thistime = (struct tm *)gmtime_r(&data->set.timevalue, &keeptime); #else - thistime = gmtime(&data->timevalue); + thistime = gmtime(&data->set.timevalue); #endif if(NULL == thistime) { failf(data, "localtime() failed!"); @@ -667,7 +668,7 @@ CURLcode Curl_http(struct connectdata *conn) /* TODO: Right, we *could* write a replacement here */ strcpy(buf, "no strftime() support"); #endif - switch(data->timecondition) { + switch(data->set.timecondition) { case TIMECOND_IFMODSINCE: default: add_bufferf(req_buffer, @@ -702,7 +703,7 @@ CURLcode Curl_http(struct connectdata *conn) headers = headers->next; } - if(HTTPREQ_POST_FORM == data->httpreq) { + if(HTTPREQ_POST_FORM == data->set.httpreq) { char contentType[256]; int linelength=0; if(Curl_FormInit(&http->form, http->sendit)) { @@ -710,13 +711,13 @@ CURLcode Curl_http(struct connectdata *conn) return CURLE_HTTP_POST_ERROR; } - http->storefread = data->fread; /* backup */ - http->in = data->in; /* backup */ + http->storefread = data->set.fread; /* backup */ + http->in = data->set.in; /* backup */ - data->fread = (curl_read_callback) + data->set.fread = (curl_read_callback) Curl_FormReader; /* set the read function to read from the generated form data */ - data->in = (FILE *)&http->form; + data->set.in = (FILE *)&http->form; add_bufferf(req_buffer, "Content-Length: %d\r\n", http->postsize-2); @@ -727,7 +728,7 @@ CURLcode Curl_http(struct connectdata *conn) there is one packet coming back from the web server) */ add_bufferf(req_buffer, "Expect: 100-continue\r\n"); - data->bits.expect100header = TRUE; + data->set.expect100header = TRUE; /* Get Content-Type: line from Curl_FormReadOneLine, which happens to always be the first line. We can know this for sure since @@ -747,7 +748,7 @@ CURLcode Curl_http(struct connectdata *conn) Curl_pgrsSetUploadSize(data, http->postsize); /* fire away the whole request to the server */ - data->request_size = + data->info.request_size = add_buffer_send(conn->firstsocket, conn, req_buffer); /* setup variables for the upcoming transfer */ @@ -760,22 +761,22 @@ CURLcode Curl_http(struct connectdata *conn) return result; } } - else if(HTTPREQ_PUT == data->httpreq) { + else if(HTTPREQ_PUT == data->set.httpreq) { /* Let's PUT the data to the server! */ - if(data->infilesize>0) { + if(data->set.infilesize>0) { add_bufferf(req_buffer, "Content-Length: %d\r\n\r\n", /* file size */ - data->infilesize ); + data->set.infilesize ); } else add_bufferf(req_buffer, "\015\012"); /* set the upload size to the progress meter */ - Curl_pgrsSetUploadSize(data, data->infilesize); + Curl_pgrsSetUploadSize(data, data->set.infilesize); /* this sends the buffer and frees all the buffer resources */ - data->request_size = + data->info.request_size = add_buffer_send(conn->firstsocket, conn, req_buffer); /* prepare for transfer */ @@ -788,17 +789,17 @@ CURLcode Curl_http(struct connectdata *conn) } else { - if(HTTPREQ_POST == data->httpreq) { + if(HTTPREQ_POST == data->set.httpreq) { /* this is the simple POST, using x-www-form-urlencoded style */ - if(!data->postfields) { + if(!data->set.postfields) { /* * This is an attempt to do a POST without having anything to * actually send. Let's make a NULL pointer equal "" here. Good/bad * ? */ - data->postfields = (char *)""; - data->postfieldsize = 0; /* it might been set to something illegal, + data->set.postfields = (char *)""; + data->set.postfieldsize = 0; /* it might been set to something illegal, anything > 0 would be! */ } @@ -807,32 +808,32 @@ CURLcode Curl_http(struct connectdata *conn) actually set your own */ add_bufferf(req_buffer, "Content-Length: %d\r\n", - (data->postfieldsize?data->postfieldsize: - strlen(data->postfields)) ); + (data->set.postfieldsize?data->set.postfieldsize: + strlen(data->set.postfields)) ); if(!checkheaders(data, "Content-Type:")) add_bufferf(req_buffer, "Content-Type: application/x-www-form-urlencoded\r\n"); /* and here comes the actual data */ - if(data->postfieldsize) { + if(data->set.postfieldsize) { add_buffer(req_buffer, "\r\n", 2); - add_buffer(req_buffer, data->postfields, - data->postfieldsize); + add_buffer(req_buffer, data->set.postfields, + data->set.postfieldsize); add_buffer(req_buffer, "\r\n", 2); } else { add_bufferf(req_buffer, "\r\n" "%s\r\n", - data->postfields ); + data->set.postfields ); } } else add_buffer(req_buffer, "\r\n", 2); /* issue the request */ - data->request_size = + data->info.request_size = add_buffer_send(conn->firstsocket, conn, req_buffer); /* HTTP GET/HEAD download: */ diff --git a/lib/krb4.c b/lib/krb4.c index 08d5bafc0..e95a060f3 100644 --- a/lib/krb4.c +++ b/lib/krb4.c @@ -248,17 +248,17 @@ krb4_auth(void *app_data, struct connectdata *conn) Curl_ftpsendf(conn->firstsocket, conn, "ADAT %s", p); nread = Curl_GetFTPResponse(conn->firstsocket, - conn->data->buffer, conn, NULL); + conn->data.set->buffer, conn, NULL); if(nread < 0) return /*CURLE_OPERATION_TIMEOUTED*/-1; free(p); - if(/*ret != COMPLETE*/conn->data->buffer[0] != '2'){ + if(/*ret != COMPLETE*/conn->data.set->buffer[0] != '2'){ printf("Server didn't accept auth data.\n"); return AUTH_ERROR; } - p = strstr(conn->data->buffer, "ADAT="); + p = strstr(conn->data.set->buffer, "ADAT="); if(!p){ printf("Remote host didn't send adat reply.\n"); return AUTH_ERROR; @@ -314,20 +314,20 @@ void Curl_krb_kauth(struct connectdata *conn) save = Curl_set_command_prot(conn, prot_private); Curl_ftpsendf(conn->firstsocket, conn, - "SITE KAUTH %s", conn->data->user); + "SITE KAUTH %s", conn->data.set->user); - nread = Curl_GetFTPResponse(conn->firstsocket, conn->data->buffer, + nread = Curl_GetFTPResponse(conn->firstsocket, conn->data.set->buffer, conn, NULL); if(nread < 0) return /*CURLE_OPERATION_TIMEOUTED*/; - if(/*ret != CONTINUE*/conn->data->buffer[0] != '3'){ + if(/*ret != CONTINUE*/conn->data.set->buffer[0] != '3'){ Curl_set_command_prot(conn, save); /*code = -1;***/ return; } - p = strstr(conn->data->buffer, "T="); + p = strstr(conn->data.set->buffer, "T="); if(!p) { printf("Bad reply from server.\n"); Curl_set_command_prot(conn, save); @@ -344,7 +344,7 @@ void Curl_krb_kauth(struct connectdata *conn) tkt.length = tmp; tktcopy.length = tkt.length; - p = strstr(conn->data->buffer, "P="); + p = strstr(conn->data.set->buffer, "P="); if(!p) { printf("Bad reply from server.\n"); Curl_set_command_prot(conn, save); @@ -354,7 +354,7 @@ void Curl_krb_kauth(struct connectdata *conn) for(; *p && *p != ' ' && *p != '\r' && *p != '\n'; p++); *p = 0; - des_string_to_key (conn->data->passwd, &key); + des_string_to_key (conn->data.set->passwd, &key); des_key_sched(&key, schedule); des_pcbc_encrypt((des_cblock*)tkt.dat, (des_cblock*)tktcopy.dat, @@ -383,7 +383,7 @@ void Curl_krb_kauth(struct connectdata *conn) Curl_ftpsendf(conn->firstsocket, conn, "SITE KAUTH %s %s", name, p); - nread = Curl_GetFTPResponse(conn->firstsocket, conn->data->buffer, + nread = Curl_GetFTPResponse(conn->firstsocket, conn->data.set->buffer, conn, NULL); if(nread < 0) return /*CURLE_OPERATION_TIMEOUTED*/; diff --git a/lib/ldap.c b/lib/ldap.c index b84eb4d30..77570c2e5 100644 --- a/lib/ldap.c +++ b/lib/ldap.c @@ -116,7 +116,7 @@ static void * DynaGetFunction(const char *name) static int WriteProc(void *param, char *text, int len) { - struct UrlData *data = (struct UrlData *)param; + struct SessionHandle *data = (struct SessionHandle *)param; len = 0; /* prevent compiler warning */ Curl_client_write(data, CLIENTWRITE_BODY, text, 0); return 0; @@ -142,9 +142,9 @@ CURLcode Curl_ldap(struct connectdata *conn) void *entryIterator; int ldaptext; - struct UrlData *data=conn->data; + struct SessionHandle *data=conn->data; - infof(data, "LDAP: %s %s\n", data->url); + infof(data, "LDAP: %s %s\n", data->change.url); DynaOpen(); if (libldap == NULL) { @@ -152,7 +152,7 @@ CURLcode Curl_ldap(struct connectdata *conn) return CURLE_LIBRARY_NOT_FOUND; } - ldaptext = data->bits.ftp_ascii; /* This is a dirty hack */ + ldaptext = data->set.ftp_ascii; /* This is a dirty hack */ /* The types are needed because ANSI C distinguishes between * pointer-to-object (data) and pointer-to-function. @@ -173,12 +173,12 @@ CURLcode Curl_ldap(struct connectdata *conn) conn->hostname, conn->port); status = CURLE_COULDNT_CONNECT; } else { - rc = ldap_simple_bind_s(server, data->user, data->passwd); + rc = ldap_simple_bind_s(server, data->state.user, data->state.passwd); if (rc != 0) { failf(data, "LDAP: %s", ldap_err2string(rc)); status = CURLE_LDAP_CANNOT_BIND; } else { - rc = ldap_url_search_s(server, data->url, 0, &result); + rc = ldap_url_search_s(server, data->change.url, 0, &result); if (rc != 0) { failf(data, "LDAP: %s", ldap_err2string(rc)); status = CURLE_LDAP_SEARCH_FAILED; diff --git a/lib/progress.c b/lib/progress.c index 093c93083..45bc407f3 100644 --- a/lib/progress.c +++ b/lib/progress.c @@ -93,17 +93,17 @@ static char *max5data(double bytes, char *max5) void Curl_pgrsDone(struct connectdata *conn) { - struct UrlData *data = conn->data; + struct SessionHandle *data = conn->data; if(!(data->progress.flags & PGRS_HIDE)) { data->progress.lastshow=0; Curl_pgrsUpdate(conn); /* the final (forced) update */ if(!data->progress.callback) /* only output if we don't use progress callback */ - fprintf(data->err, "\n"); + fprintf(data->set.err, "\n"); } } -void Curl_pgrsTime(struct UrlData *data, timerid timer) +void Curl_pgrsTime(struct SessionHandle *data, timerid timer) { switch(timer) { default: @@ -135,23 +135,23 @@ void Curl_pgrsTime(struct UrlData *data, timerid timer) } } -void Curl_pgrsStartNow(struct UrlData *data) +void Curl_pgrsStartNow(struct SessionHandle *data) { data->progress.speeder_c = 0; /* reset the progress meter display */ data->progress.start = Curl_tvnow(); } -void Curl_pgrsSetDownloadCounter(struct UrlData *data, double size) +void Curl_pgrsSetDownloadCounter(struct SessionHandle *data, double size) { data->progress.downloaded = size; } -void Curl_pgrsSetUploadCounter(struct UrlData *data, double size) +void Curl_pgrsSetUploadCounter(struct SessionHandle *data, double size) { data->progress.uploaded = size; } -void Curl_pgrsSetDownloadSize(struct UrlData *data, double size) +void Curl_pgrsSetDownloadSize(struct SessionHandle *data, double size) { if(size > 0) { data->progress.size_dl = size; @@ -159,7 +159,7 @@ void Curl_pgrsSetDownloadSize(struct UrlData *data, double size) } } -void Curl_pgrsSetUploadSize(struct UrlData *data, double size) +void Curl_pgrsSetUploadSize(struct SessionHandle *data, double size) { if(size > 0) { data->progress.size_ul = size; @@ -188,7 +188,7 @@ int Curl_pgrsUpdate(struct connectdata *conn) double total_transfer; double total_expected_transfer; - struct UrlData *data = conn->data; + struct SessionHandle *data = conn->data; int nowindex = data->progress.speeder_c% CURR_TIME; int checkindex; @@ -211,9 +211,9 @@ int Curl_pgrsUpdate(struct connectdata *conn) else if(!(data->progress.flags & PGRS_HEADERS_OUT)) { if (!data->progress.callback) { if(conn->resume_from) - fprintf(data->err, "** Resuming transfer from byte position %d\n", + fprintf(data->set.err, "** Resuming transfer from byte position %d\n", conn->resume_from); - fprintf(data->err, + fprintf(data->set.err, " %% Total %% Received %% Xferd Average Speed Time Curr.\n" " Dload Upload Total Current Left Speed\n"); } @@ -254,12 +254,12 @@ int Curl_pgrsUpdate(struct connectdata *conn) if(data->progress.flags & PGRS_HIDE) return 0; - else if(data->fprogress) { - result= data->fprogress(data->progress_client, - data->progress.size_dl, - data->progress.downloaded, - data->progress.size_ul, - data->progress.uploaded); + else if(data->set.fprogress) { + result= data->set.fprogress(data->set.progress_client, + data->progress.size_dl, + data->progress.downloaded, + data->progress.size_ul, + data->progress.uploaded); if(result) failf(data, "Callback aborted"); return result; @@ -310,7 +310,7 @@ int Curl_pgrsUpdate(struct connectdata *conn) if(total_expected_transfer) total_percen=(double)(total_transfer/total_expected_transfer)*100; - fprintf(data->err, + fprintf(data->set.err, "\r%3d %s %3d %s %3d %s %s %s %s %s %s %s", (int)total_percen, /* total % */ max5data(total_expected_transfer, max5[2]), /* total size */ @@ -328,7 +328,7 @@ int Curl_pgrsUpdate(struct connectdata *conn) ); /* we flush the output stream to make it appear as soon as possible */ - fflush(data->err); + fflush(data->set.err); return 0; } diff --git a/lib/progress.h b/lib/progress.h index 55ceb7422..3d0a6b084 100644 --- a/lib/progress.h +++ b/lib/progress.h @@ -37,13 +37,13 @@ typedef enum { } timerid; void Curl_pgrsDone(struct connectdata *); -void Curl_pgrsStartNow(struct UrlData *data); -void Curl_pgrsSetDownloadSize(struct UrlData *data, double size); -void Curl_pgrsSetUploadSize(struct UrlData *data, double size); -void Curl_pgrsSetDownloadCounter(struct UrlData *data, double size); -void Curl_pgrsSetUploadCounter(struct UrlData *data, double size); +void Curl_pgrsStartNow(struct SessionHandle *data); +void Curl_pgrsSetDownloadSize(struct SessionHandle *data, double size); +void Curl_pgrsSetUploadSize(struct SessionHandle *data, double size); +void Curl_pgrsSetDownloadCounter(struct SessionHandle *data, double size); +void Curl_pgrsSetUploadCounter(struct SessionHandle *data, double size); int Curl_pgrsUpdate(struct connectdata *); -void Curl_pgrsTime(struct UrlData *data, timerid timer); +void Curl_pgrsTime(struct SessionHandle *data, timerid timer); /* Don't show progress for sizes smaller than: */ diff --git a/lib/security.c b/lib/security.c index 39a80ee32..88b89b0fa 100644 --- a/lib/security.c +++ b/lib/security.c @@ -417,15 +417,15 @@ sec_prot_internal(struct connectdata *conn, int level) "PBSZ %u", s); /* wait for feedback */ nread = Curl_GetFTPResponse(conn->firstsocket, - conn->data->buffer, conn, NULL); + conn->data.set->buffer, conn, NULL); if(nread < 0) return /*CURLE_OPERATION_TIMEOUTED*/-1; - if(/*ret != COMPLETE*/conn->data->buffer[0] != '2'){ + if(/*ret != COMPLETE*/conn->data.set->buffer[0] != '2'){ failf(conn->data, "Failed to set protection buffer size.\n"); return -1; } conn->buffer_size = s; - p = strstr(/*reply_string*/conn->data->buffer, "PBSZ="); + p = strstr(/*reply_string*/conn->data.set->buffer, "PBSZ="); if(p) sscanf(p, "PBSZ=%u", &s); if(s < conn->buffer_size) @@ -436,10 +436,10 @@ sec_prot_internal(struct connectdata *conn, int level) "PROT %c", level["CSEP"]); /* wait for feedback */ nread = Curl_GetFTPResponse(conn->firstsocket, - conn->data->buffer, conn, NULL); + conn->data.set->buffer, conn, NULL); if(nread < 0) return /*CURLE_OPERATION_TIMEOUTED*/-1; - if(/*ret != COMPLETE*/conn->data->buffer[0] != '2'){ + if(/*ret != COMPLETE*/conn->data.set->buffer[0] != '2'){ failf(conn->data, "Failed to set protection level.\n"); return -1; } @@ -472,7 +472,7 @@ Curl_sec_login(struct connectdata *conn) int ret; struct Curl_sec_client_mech **m; ssize_t nread; - struct UrlData *data=conn->data; + struct SessionHandle *data=conn->data; for(m = mechs; *m && (*m)->name; m++) { void *tmp; @@ -494,18 +494,18 @@ Curl_sec_login(struct connectdata *conn) "AUTH %s", (*m)->name); /* wait for feedback */ nread = Curl_GetFTPResponse(conn->firstsocket, - conn->data->buffer, conn, NULL); + conn->data.set->buffer, conn, NULL); if(nread < 0) return /*CURLE_OPERATION_TIMEOUTED*/-1; - if(/*ret != CONTINUE*/conn->data->buffer[0] != '3'){ - if(/*code == 504*/strncmp(conn->data->buffer,"504",3) == 0) { + if(/*ret != CONTINUE*/conn->data.set->buffer[0] != '3'){ + if(/*code == 504*/strncmp(conn->data.set->buffer,"504",3) == 0) { infof(data, "%s is not supported by the server.\n", (*m)->name); } - else if(/*code == 534*/strncmp(conn->data->buffer,"534",3) == 0) { + else if(/*code == 534*/strncmp(conn->data.set->buffer,"534",3) == 0) { infof(data, "%s rejected as security mechanism.\n", (*m)->name); } - else if(/*ret == ERROR*/conn->data->buffer[0] == '5') { + else if(/*ret == ERROR*/conn->data.set->buffer[0] == '5') { infof(data, "The server doesn't support the FTP " "security extensions.\n"); return -1; diff --git a/lib/sendf.c b/lib/sendf.c index 6097919e0..93834940b 100644 --- a/lib/sendf.c +++ b/lib/sendf.c @@ -122,13 +122,13 @@ void curl_slist_free_all(struct curl_slist *list) /* Curl_infof() is for info message along the way */ -void Curl_infof(struct UrlData *data, const char *fmt, ...) +void Curl_infof(struct SessionHandle *data, const char *fmt, ...) { va_list ap; - if(data->bits.verbose) { + if(data->set.verbose) { va_start(ap, fmt); - fputs("* ", data->err); - vfprintf(data->err, fmt, ap); + fputs("* ", data->set.err); + vfprintf(data->set.err, fmt, ap); va_end(ap); } } @@ -136,12 +136,12 @@ void Curl_infof(struct UrlData *data, const char *fmt, ...) /* Curl_failf() is for messages stating why we failed, the LAST one will be returned for the user (if requested) */ -void Curl_failf(struct UrlData *data, const char *fmt, ...) +void Curl_failf(struct SessionHandle *data, const char *fmt, ...) { va_list ap; va_start(ap, fmt); - if(data->errorbuffer) - vsnprintf(data->errorbuffer, CURL_ERROR_SIZE, fmt, ap); + if(data->set.errorbuffer) + vsnprintf(data->set.errorbuffer, CURL_ERROR_SIZE, fmt, ap); va_end(ap); } @@ -149,7 +149,7 @@ void Curl_failf(struct UrlData *data, const char *fmt, ...) size_t Curl_sendf(int sockfd, struct connectdata *conn, const char *fmt, ...) { - struct UrlData *data = conn->data; + struct SessionHandle *data = conn->data; size_t bytes_written; char *s; va_list ap; @@ -158,8 +158,8 @@ size_t Curl_sendf(int sockfd, struct connectdata *conn, va_end(ap); if(!s) return 0; /* failure */ - if(data->bits.verbose) - fprintf(data->err, "> %s", s); + if(data->set.verbose) + fprintf(data->set.err, "> %s", s); /* Write the buffer to the socket */ Curl_write(conn, sockfd, s, strlen(s), &bytes_written); @@ -219,7 +219,7 @@ CURLcode Curl_write(struct connectdata *conn, int sockfd, The bit pattern defines to what "streams" to write to. Body and/or header. The defines are in sendf.h of course. */ -CURLcode Curl_client_write(struct UrlData *data, +CURLcode Curl_client_write(struct SessionHandle *data, int type, char *ptr, size_t len) @@ -230,22 +230,22 @@ CURLcode Curl_client_write(struct UrlData *data, len = strlen(ptr); if(type & CLIENTWRITE_BODY) { - wrote = data->fwrite(ptr, 1, len, data->out); + wrote = data->set.fwrite(ptr, 1, len, data->set.out); if(wrote != len) { failf (data, "Failed writing body"); return CURLE_WRITE_ERROR; } } if((type & CLIENTWRITE_HEADER) && - (data->fwrite_header || data->writeheader) ) { + (data->set.fwrite_header || data->set.writeheader) ) { /* * Write headers to the same callback or to the especially setup * header callback function (added after version 7.7.1). */ curl_write_callback writeit= - data->fwrite_header?data->fwrite_header:data->fwrite; + data->set.fwrite_header?data->set.fwrite_header:data->set.fwrite; - wrote = writeit(ptr, 1, len, data->writeheader); + wrote = writeit(ptr, 1, len, data->set.writeheader); if(wrote != len) { failf (data, "Failed writing header"); return CURLE_WRITE_ERROR; diff --git a/lib/sendf.h b/lib/sendf.h index ee1e628c1..67f3dd7f1 100644 --- a/lib/sendf.h +++ b/lib/sendf.h @@ -24,8 +24,8 @@ *****************************************************************************/ size_t Curl_sendf(int fd, struct connectdata *, const char *fmt, ...); -void Curl_infof(struct UrlData *, const char *fmt, ...); -void Curl_failf(struct UrlData *, const char *fmt, ...); +void Curl_infof(struct SessionHandle *, const char *fmt, ...); +void Curl_failf(struct SessionHandle *, const char *fmt, ...); #define infof Curl_infof #define failf Curl_failf @@ -41,7 +41,7 @@ typedef struct send_buffer send_buffer; #define CLIENTWRITE_HEADER 2 #define CLIENTWRITE_BOTH (CLIENTWRITE_BODY|CLIENTWRITE_HEADER) -CURLcode Curl_client_write(struct UrlData *data, int type, char *ptr, +CURLcode Curl_client_write(struct SessionHandle *data, int type, char *ptr, size_t len); /* internal read-function, does plain socket, SSL and krb4 */ diff --git a/lib/speedcheck.c b/lib/speedcheck.c index 3112d2575..274ceb108 100644 --- a/lib/speedcheck.c +++ b/lib/speedcheck.c @@ -34,36 +34,36 @@ #include "sendf.h" #include "speedcheck.h" -void Curl_speedinit(struct UrlData *data) +void Curl_speedinit(struct SessionHandle *data) { - memset(&data->keeps_speed, 0, sizeof(struct timeval)); + memset(&data->state.keeps_speed, 0, sizeof(struct timeval)); } -CURLcode Curl_speedcheck(struct UrlData *data, +CURLcode Curl_speedcheck(struct SessionHandle *data, struct timeval now) { if((data->progress.current_speed >= 0) && - data->low_speed_time && - (Curl_tvlong(data->keeps_speed) != 0) && - (data->progress.current_speed < data->low_speed_limit)) { + data->set.low_speed_time && + (Curl_tvlong(data->state.keeps_speed) != 0) && + (data->progress.current_speed < data->set.low_speed_limit)) { /* We are now below the "low speed limit". If we are below it for "low speed time" seconds we consider that enough reason to abort the download. */ - if( Curl_tvdiff(now, data->keeps_speed) > data->low_speed_time) { + if( Curl_tvdiff(now, data->state.keeps_speed) > data->set.low_speed_time) { /* we have been this slow for long enough, now die */ failf(data, "Operation too slow. " "Less than %d bytes/sec transfered the last %d seconds", - data->low_speed_limit, - data->low_speed_time); + data->set.low_speed_limit, + data->set.low_speed_time); return CURLE_OPERATION_TIMEOUTED; } } else { /* we keep up the required speed all right */ - data->keeps_speed = now; + data->state.keeps_speed = now; } return CURLE_OK; } diff --git a/lib/speedcheck.h b/lib/speedcheck.h index 6674048f3..08eca0d7d 100644 --- a/lib/speedcheck.h +++ b/lib/speedcheck.h @@ -27,8 +27,8 @@ #include "timeval.h" -void Curl_speedinit(struct UrlData *data); -CURLcode Curl_speedcheck(struct UrlData *data, +void Curl_speedinit(struct SessionHandle *data); +CURLcode Curl_speedcheck(struct SessionHandle *data, struct timeval now); #endif diff --git a/lib/ssluse.c b/lib/ssluse.c index 730ae41d3..50bc621fa 100644 --- a/lib/ssluse.c +++ b/lib/ssluse.c @@ -94,9 +94,9 @@ bool seed_enough(struct connectdata *conn, /* unused for now */ static int random_the_seed(struct connectdata *conn) { - char *buf = conn->data->buffer; /* point to the big buffer */ + char *buf = conn->data->state.buffer; /* point to the big buffer */ int nread=0; - struct UrlData *data=conn->data; + struct SessionHandle *data=conn->data; /* Q: should we add support for a random file name as a libcurl option? A: Yes, it is here */ @@ -104,13 +104,13 @@ int random_the_seed(struct connectdata *conn) #ifndef RANDOM_FILE /* if RANDOM_FILE isn't defined, we only perform this if an option tells us to! */ - if(data->ssl.random_file) + if(data->set.ssl.random_file) #define RANDOM_FILE "" /* doesn't matter won't be used */ #endif { /* let the option override the define */ - nread += RAND_load_file((data->ssl.random_file? - data->ssl.random_file:RANDOM_FILE), + nread += RAND_load_file((data->set.ssl.random_file? + data->set.ssl.random_file:RANDOM_FILE), 16384); if(seed_enough(conn, nread)) return nread; @@ -122,13 +122,13 @@ int random_the_seed(struct connectdata *conn) #ifndef EGD_SOCKET /* If we don't have the define set, we only do this if the egd-option is set */ - if(data->ssl.egdsocket) + if(data->set.ssl.egdsocket) #define EGD_SOCKET "" /* doesn't matter won't be used */ #endif { /* If there's an option and a define, the option overrides the define */ - int ret = RAND_egd(data->ssl.egdsocket?data->ssl.egdsocket:EGD_SOCKET); + int ret = RAND_egd(data->set.ssl.egdsocket?data->set.ssl.egdsocket:EGD_SOCKET); if(-1 != ret) { nread += ret; if(seed_enough(conn, nread)) @@ -176,23 +176,23 @@ int cert_stuff(struct connectdata *conn, char *cert_file, char *key_file) { - struct UrlData *data = conn->data; + struct SessionHandle *data = conn->data; if (cert_file != NULL) { SSL *ssl; X509 *x509; - if(data->cert_passwd) { + if(data->set.cert_passwd) { #ifndef HAVE_USERDATA_IN_PWD_CALLBACK /* * If password has been given, we store that in the global * area (*shudder*) for a while: */ - strcpy(global_passwd, data->cert_passwd); + strcpy(global_passwd, data->set.cert_passwd); #else /* * We set the password in the callback userdata */ - SSL_CTX_set_default_passwd_cb_userdata(conn->ssl.ctx, data->cert_passwd); + SSL_CTX_set_default_passwd_cb_userdata(conn->ssl.ctx, data->set.cert_passwd); #endif /* Set passwd callback: */ SSL_CTX_set_default_passwd_cb(conn->ssl.ctx, passwd_callback); @@ -331,11 +331,11 @@ void Curl_SSL_cleanup(void) /* * This sets up a session cache to the specified size. */ -CURLcode Curl_SSL_InitSessions(struct UrlData *data, long amount) +CURLcode Curl_SSL_InitSessions(struct SessionHandle *data, long amount) { struct curl_ssl_session *session; - if(data->ssl.session) + if(data->set.ssl.session) /* this is just a precaution to prevent multiple inits */ return CURLE_OK; @@ -348,9 +348,9 @@ CURLcode Curl_SSL_InitSessions(struct UrlData *data, long amount) memset(session, 0, amount * sizeof(struct curl_ssl_session)); /* store the info in the SSL section */ - data->ssl.numsessions = amount; - data->ssl.session = session; - data->ssl.sessionage = 1; /* this is brand new */ + data->set.ssl.numsessions = amount; + data->set.ssl.session = session; + data->set.ssl.sessionage = 1; /* this is brand new */ return CURLE_OK; } @@ -363,19 +363,19 @@ static int Get_SSL_Session(struct connectdata *conn, SSL_SESSION **ssl_sessionid) { struct curl_ssl_session *check; - struct UrlData *data = conn->data; + struct SessionHandle *data = conn->data; long i; - for(i=0; i< data->ssl.numsessions; i++) { - check = &data->ssl.session[i]; + for(i=0; i< data->set.ssl.numsessions; i++) { + check = &data->set.ssl.session[i]; if(!check->sessionid) /* not session ID means blank entry */ continue; if(strequal(conn->name, check->name) && (conn->remote_port == check->remote_port) ) { /* yes, we have a session ID! */ - data->ssl.sessionage++; /* increase general age */ - check->age = data->ssl.sessionage; /* set this as used in this age */ + data->set.ssl.sessionage++; /* increase general age */ + check->age = data->set.ssl.sessionage; /* set this as used in this age */ *ssl_sessionid = check->sessionid; return FALSE; } @@ -409,15 +409,15 @@ static int Kill_Single_Session(struct curl_ssl_session *session) * This function is called when the 'data' struct is going away. Close * down everything and free all resources! */ -int Curl_SSL_Close_All(struct UrlData *data) +int Curl_SSL_Close_All(struct SessionHandle *data) { int i; - for(i=0; i< data->ssl.numsessions; i++) + for(i=0; i< data->set.ssl.numsessions; i++) /* the single-killer function handles empty table slots */ - Kill_Single_Session(&data->ssl.session[i]); + Kill_Single_Session(&data->set.ssl.session[i]); /* free the cache data */ - free(data->ssl.session); + free(data->set.ssl.session); return 0; } @@ -430,8 +430,8 @@ static int Store_SSL_Session(struct connectdata *conn) SSL_SESSION *ssl_sessionid; struct curl_ssl_session *store; int i; - struct UrlData *data=conn->data; /* the mother of all structs */ - int oldest_age=data->ssl.session[0].age; /* zero if unused */ + struct SessionHandle *data=conn->data; /* the mother of all structs */ + int oldest_age=data->set.ssl.session[0].age; /* zero if unused */ /* ask OpenSSL, say please */ ssl_sessionid = SSL_get1_session(conn->ssl.handle); @@ -444,21 +444,21 @@ static int Store_SSL_Session(struct connectdata *conn) the oldest if necessary) */ /* find an empty slot for us, or find the oldest */ - for(i=0; (issl.numsessions) && data->ssl.session[i].sessionid; i++) { - if(data->ssl.session[i].age < oldest_age) { - oldest_age = data->ssl.session[i].age; - store = &data->ssl.session[i]; + for(i=0; (iset.ssl.numsessions) && data->set.ssl.session[i].sessionid; i++) { + if(data->set.ssl.session[i].age < oldest_age) { + oldest_age = data->set.ssl.session[i].age; + store = &data->set.ssl.session[i]; } } - if(i == data->ssl.numsessions) + if(i == data->set.ssl.numsessions) /* cache is full, we must "kill" the oldest entry! */ Kill_Single_Session(store); else - store = &data->ssl.session[i]; /* use this slot */ + store = &data->set.ssl.session[i]; /* use this slot */ /* now init the session struct wisely */ store->sessionid = ssl_sessionid; - store->age = data->ssl.sessionage; /* set current age */ + store->age = data->set.ssl.sessionage; /* set current age */ store->name = strdup(conn->name); /* clone host name */ store->remote_port = conn->remote_port; /* port number */ @@ -472,7 +472,7 @@ Curl_SSLConnect(struct connectdata *conn) CURLcode retcode = CURLE_OK; #ifdef USE_SSLEAY - struct UrlData *data = conn->data; + struct SessionHandle *data = conn->data; int err; char * str; SSL_METHOD *req_method; @@ -484,7 +484,7 @@ Curl_SSLConnect(struct connectdata *conn) /* Make funny stuff to get random input */ random_the_seed(conn); - switch(data->ssl.version) { + switch(data->set.ssl.version) { default: req_method = SSLv23_client_method(); break; @@ -503,21 +503,21 @@ Curl_SSLConnect(struct connectdata *conn) return CURLE_OUT_OF_MEMORY; } - if(data->cert) { - if (!cert_stuff(conn, data->cert, data->cert)) { + if(data->set.cert) { + if (!cert_stuff(conn, data->set.cert, data->set.cert)) { /* failf() is already done in cert_stuff() */ return CURLE_SSL_CONNECT_ERROR; } } - if(data->ssl.verifypeer){ + if(data->set.ssl.verifypeer){ SSL_CTX_set_verify(conn->ssl.ctx, SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT| SSL_VERIFY_CLIENT_ONCE, cert_verify_callback); if (!SSL_CTX_load_verify_locations(conn->ssl.ctx, - data->ssl.CAfile, - data->ssl.CApath)) { + data->set.ssl.CAfile, + data->set.ssl.CApath)) { failf(data,"error setting cerficate verify locations\n"); return CURLE_SSL_CONNECT_ERROR; } @@ -587,7 +587,7 @@ Curl_SSLConnect(struct connectdata *conn) infof(data, "\t subject: %s\n", str); CRYPTO_free(str); - if (data->ssl.verifyhost) { + if (data->set.ssl.verifyhost) { char peer_CN[257]; if (X509_NAME_get_text_by_NID(X509_get_subject_name(conn->ssl.server_cert), NID_commonName, peer_CN, sizeof(peer_CN)) < 0) { failf(data, "SSL: unable to obtain common name from peer certificate"); @@ -596,7 +596,7 @@ Curl_SSLConnect(struct connectdata *conn) } if (!strequal(peer_CN, conn->hostname)) { - if (data->ssl.verifyhost > 1) { + if (data->set.ssl.verifyhost > 1) { failf(data, "SSL: certificate subject name '%s' does not match target host name '%s'", peer_CN, conn->hostname); X509_free(conn->ssl.server_cert); @@ -622,16 +622,16 @@ Curl_SSLConnect(struct connectdata *conn) /* We could do all sorts of certificate verification stuff here before deallocating the certificate. */ - if(data->ssl.verifypeer) { - data->ssl.certverifyresult=SSL_get_verify_result(conn->ssl.handle); - if (data->ssl.certverifyresult != X509_V_OK) { + if(data->set.ssl.verifypeer) { + data->set.ssl.certverifyresult=SSL_get_verify_result(conn->ssl.handle); + if (data->set.ssl.certverifyresult != X509_V_OK) { failf(data, "SSL certificate verify result: %d\n", - data->ssl.certverifyresult); + data->set.ssl.certverifyresult); retcode = CURLE_SSL_PEER_CERTIFICATE; } } else - data->ssl.certverifyresult=0; + data->set.ssl.certverifyresult=0; X509_free(conn->ssl.server_cert); #else /* USE_SSLEAY */ diff --git a/lib/ssluse.h b/lib/ssluse.h index 47a1a1842..8ac4bf61b 100644 --- a/lib/ssluse.h +++ b/lib/ssluse.h @@ -28,10 +28,10 @@ void Curl_SSL_init(void); /* Global SSL init */ void Curl_SSL_cleanup(void); /* Global SSL cleanup */ /* init the SSL session ID cache */ -CURLcode Curl_SSL_InitSessions(struct UrlData *, long); +CURLcode Curl_SSL_InitSessions(struct SessionHandle *, long); void Curl_SSL_Close(struct connectdata *conn); /* close a SSL connection */ /* tell the SSL stuff to close down all open information regarding connections (and thus session ID caching etc) */ -int Curl_SSL_Close_All(struct UrlData *data); +int Curl_SSL_Close_All(struct SessionHandle *data); #endif diff --git a/lib/telnet.c b/lib/telnet.c index 2507e5c64..2508892b0 100644 --- a/lib/telnet.c +++ b/lib/telnet.c @@ -105,7 +105,7 @@ void telrcv(struct connectdata *, unsigned char *inbuf, /* Data received from socket */ int count); /* Number of bytes received */ -static void printoption(struct UrlData *data, +static void printoption(struct SessionHandle *data, const char *direction, int cmd, int option); @@ -114,7 +114,7 @@ static void send_negotiation(struct connectdata *, int cmd, int option); static void set_local_option(struct connectdata *, int cmd, int option); static void set_remote_option(struct connectdata *, int cmd, int option); -static void printsub(struct UrlData *data, +static void printsub(struct SessionHandle *data, int direction, unsigned char *pointer, int length); static void suboption(struct connectdata *); @@ -215,13 +215,13 @@ static void negotiate(struct connectdata *conn) } } -static void printoption(struct UrlData *data, +static void printoption(struct SessionHandle *data, const char *direction, int cmd, int option) { const char *fmt; const char *opt; - if (data->bits.verbose) + if (data->set.verbose) { if (cmd == IAC) { @@ -627,14 +627,14 @@ void rec_dont(struct connectdata *conn, int option) } -static void printsub(struct UrlData *data, +static void printsub(struct SessionHandle *data, int direction, /* '<' or '>' */ unsigned char *pointer, /* where suboption data is */ int length) /* length of suboption data */ { int i = 0; - if (data->bits.verbose) + if (data->set.verbose) { if (direction) { @@ -745,7 +745,7 @@ static int check_telnet_options(struct connectdata *conn) char option_keyword[128]; char option_arg[256]; char *buf; - struct UrlData *data = conn->data; + struct SessionHandle *data = conn->data; struct TELNET *tn = (struct TELNET *)conn->proto.telnet; /* Add the user name as an environment variable if it @@ -753,13 +753,13 @@ static int check_telnet_options(struct connectdata *conn) if(conn->bits.user_passwd) { char *buf = malloc(256); - sprintf(buf, "USER,%s", data->user); + sprintf(buf, "USER,%s", data->state.user); tn->telnet_vars = curl_slist_append(tn->telnet_vars, buf); tn->us_preferred[TELOPT_NEW_ENVIRON] = YES; } - for(head = data->telnet_options; head; head=head->next) { + for(head = data->set.telnet_options; head; head=head->next) { if(sscanf(head->data, "%127[^= ]%*[ =]%255s", option_keyword, option_arg) == 2) { @@ -814,7 +814,7 @@ static void suboption(struct connectdata *conn) int tmplen; char varname[128]; char varval[128]; - struct UrlData *data = conn->data; + struct SessionHandle *data = conn->data; struct TELNET *tn = (struct TELNET *)conn->proto.telnet; printsub(data, '<', (unsigned char *)tn->subbuffer, SB_LEN(tn)+2); @@ -868,7 +868,7 @@ void telrcv(struct connectdata *conn, { unsigned char c; int index = 0; - struct UrlData *data = conn->data; + struct SessionHandle *data = conn->data; struct TELNET *tn = (struct TELNET *)conn->proto.telnet; while(count--) @@ -1031,13 +1031,13 @@ CURLcode Curl_telnet_done(struct connectdata *conn) CURLcode Curl_telnet(struct connectdata *conn) { CURLcode code; - struct UrlData *data = conn->data; + struct SessionHandle *data = conn->data; int sockfd = conn->firstsocket; fd_set readfd; fd_set keepfd; bool keepon = TRUE; - char *buf = data->buffer; + char *buf = data->state.buffer; ssize_t nread; struct TELNET *tn; diff --git a/lib/transfer.c b/lib/transfer.c index 1609529a5..22d8b8bf5 100644 --- a/lib/transfer.c +++ b/lib/transfer.c @@ -209,16 +209,16 @@ Transfer(struct connectdata *c_conn) int writetype; /* the highest fd we use + 1 */ - struct UrlData *data; + struct SessionHandle *data; struct connectdata *conn = (struct connectdata *)c_conn; char *buf; int maxfd; data = conn->data; /* there's the root struct */ - buf = data->buffer; + buf = data->state.buffer; maxfd = (conn->sockfd>conn->writesockfd?conn->sockfd:conn->writesockfd)+1; - hbufp = data->headerbuff; + hbufp = data->state.headerbuff; myalarm (0); /* switch off the alarm-style timeout */ @@ -244,7 +244,7 @@ Transfer(struct connectdata *c_conn) } /* we want header and/or body, if neither then don't do this! */ if(conn->getheader || - !data->bits.no_body) { + !data->set.no_body) { fd_set readfd; fd_set writefd; fd_set rkeepfd; @@ -267,7 +267,7 @@ Transfer(struct connectdata *c_conn) FD_ZERO (&writefd); /* clear it */ if(conn->writesockfd != -1) { - if (data->bits.expect100header) + if (data->set.expect100header) /* wait with write until we either got 100-continue or a timeout */ write_after_100_header = TRUE; else { @@ -350,19 +350,19 @@ Transfer(struct connectdata *c_conn) * We enlarge the header buffer if it seems to be too * smallish */ - if (hbuflen + (int)str_length >= data->headersize) { + if (hbuflen + (int)str_length >= data->state.headersize) { char *newbuff; long newsize=MAX((hbuflen+str_length)*3/2, - data->headersize*2); - hbufp_index = hbufp - data->headerbuff; - newbuff = (char *)realloc(data->headerbuff, newsize); + data->state.headersize*2); + hbufp_index = hbufp - data->state.headerbuff; + newbuff = (char *)realloc(data->state.headerbuff, newsize); if(!newbuff) { failf (data, "Failed to alloc memory for big header!"); return CURLE_READ_ERROR; } - data->headersize=newsize; - data->headerbuff = newbuff; - hbufp = data->headerbuff + hbufp_index; + data->state.headersize=newsize; + data->state.headerbuff = newbuff; + hbufp = data->state.headerbuff + hbufp_index; } strcpy (hbufp, str); hbufp += strlen (str); @@ -378,19 +378,19 @@ Transfer(struct connectdata *c_conn) * fit in the allocated header buffer, or else we enlarge * it. */ - if (hbuflen + (str - str_start) >= data->headersize) { + if (hbuflen + (str - str_start) >= data->state.headersize) { char *newbuff; long newsize=MAX((hbuflen+(str-str_start))*3/2, - data->headersize*2); - hbufp_index = hbufp - data->headerbuff; - newbuff = (char *)realloc(data->headerbuff, newsize); + data->state.headersize*2); + hbufp_index = hbufp - data->state.headerbuff; + newbuff = (char *)realloc(data->state.headerbuff, newsize); if(!newbuff) { failf (data, "Failed to alloc memory for big header!"); return CURLE_READ_ERROR; } - data->headersize= newsize; - data->headerbuff = newbuff; - hbufp = data->headerbuff + hbufp_index; + data->state.headersize= newsize; + data->state.headerbuff = newbuff; + hbufp = data->state.headerbuff + hbufp_index; } /* copy to end of line */ @@ -399,7 +399,7 @@ Transfer(struct connectdata *c_conn) hbuflen += str - str_start; *hbufp = 0; - p = data->headerbuff; + p = data->state.headerbuff; /**** * We now have a FULL header line that p points to @@ -449,15 +449,15 @@ Transfer(struct connectdata *c_conn) /* now, only output this if the header AND body are requested: */ writetype = CLIENTWRITE_HEADER; - if (data->bits.http_include_header) + if (data->set.http_include_header) writetype |= CLIENTWRITE_BODY; - urg = Curl_client_write(data, writetype, data->headerbuff, - p - data->headerbuff); + urg = Curl_client_write(data, writetype, data->state.headerbuff, + p - data->state.headerbuff); if(urg) return urg; - data->header_size += p - data->headerbuff; + data->info.header_size += p - data->state.headerbuff; if(!header) { /* @@ -466,7 +466,7 @@ Transfer(struct connectdata *c_conn) * If we requested a "no body", this is a good time to get * out and return home. */ - if(data->bits.no_body) + if(data->set.no_body) return CURLE_OK; if(!conn->bits.close) { @@ -489,7 +489,7 @@ Transfer(struct connectdata *c_conn) /* We continue reading headers, so reset the line-based header parsing variables hbufp && hbuflen */ - hbufp = data->headerbuff; + hbufp = data->state.headerbuff; hbuflen = 0; continue; } @@ -516,17 +516,17 @@ Transfer(struct connectdata *c_conn) } if (nc) { - data->progress.httpcode = httpcode; - data->progress.httpversion = httpversion; + data->info.httpcode = httpcode; + data->info.httpversion = httpversion; /* 404 -> URL not found! */ if ( - ( ((data->bits.http_follow_location) && + ( ((data->set.http_follow_location) && (httpcode >= 400)) || - (!data->bits.http_follow_location && + (!data->set.http_follow_location && (httpcode >= 300))) - && (data->bits.http_fail_on_error)) { + && (data->set.http_fail_on_error)) { /* If we have been told to fail hard on HTTP-errors, here is the check for that: */ /* serious error, go home! */ @@ -624,14 +624,14 @@ Transfer(struct connectdata *c_conn) } else if(strnequal("Last-Modified:", p, strlen("Last-Modified:")) && - (data->timecondition || data->bits.get_filetime) ) { + (data->set.timecondition || data->set.get_filetime) ) { time_t secs=time(NULL); timeofdoc = curl_getdate(p+strlen("Last-Modified:"), &secs); - if(data->bits.get_filetime) - data->progress.filetime = timeofdoc; + if(data->set.get_filetime) + data->info.filetime = timeofdoc; } else if ((httpcode >= 300 && httpcode < 400) && - (data->bits.http_follow_location) && + (data->set.http_follow_location) && strnequal("Location:", p, 9)) { /* this is the URL that the server advices us to get instead */ char *ptr; @@ -660,17 +660,17 @@ Transfer(struct connectdata *c_conn) */ writetype = CLIENTWRITE_HEADER; - if (data->bits.http_include_header) + if (data->set.http_include_header) writetype |= CLIENTWRITE_BODY; urg = Curl_client_write(data, writetype, p, hbuflen); if(urg) return urg; - data->header_size += hbuflen; + data->info.header_size += hbuflen; /* reset hbufp pointer && hbuflen */ - hbufp = data->headerbuff; + hbufp = data->state.headerbuff; hbuflen = 0; } while (*str); /* header line within buffer */ @@ -706,7 +706,7 @@ Transfer(struct connectdata *c_conn) } else if (conn->resume_from && !content_range && - (data->httpreq==HTTPREQ_GET)) { + (data->set.httpreq==HTTPREQ_GET)) { /* we wanted to resume a download, although the server doesn't seem to support this and we did this with a GET (if it wasn't a GET we did a POST or PUT resume) */ @@ -714,23 +714,23 @@ Transfer(struct connectdata *c_conn) "byte ranges. Cannot resume."); return CURLE_HTTP_RANGE_ERROR; } - else if(data->timecondition && !conn->range) { + else if(data->set.timecondition && !conn->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 HTTP/1.1 client */ - if((timeofdoc > 0) && (data->timevalue > 0)) { - switch(data->timecondition) { + if((timeofdoc > 0) && (data->set.timevalue > 0)) { + switch(data->set.timecondition) { case TIMECOND_IFMODSINCE: default: - if(timeofdoc < data->timevalue) { + if(timeofdoc < data->set.timevalue) { infof(data, "The requested document is not new enough\n"); return CURLE_OK; } break; case TIMECOND_IFUNMODSINCE: - if(timeofdoc > data->timevalue) { + if(timeofdoc > data->set.timevalue) { infof(data, "The requested document is not old enough\n"); return CURLE_OK; @@ -801,10 +801,10 @@ Transfer(struct connectdata *c_conn) int i, si; size_t bytes_written; - if(data->crlf) - buf = data->buffer; /* put it back on the buffer */ + if(data->set.crlf) + buf = data->state.buffer; /* put it back on the buffer */ - nread = data->fread(buf, 1, conn->upload_bufsize, data->in); + nread = data->set.fread(buf, 1, conn->upload_bufsize, data->set.in); /* the signed int typecase of nread of for systems that has unsigned size_t */ @@ -818,7 +818,7 @@ Transfer(struct connectdata *c_conn) Curl_pgrsSetUploadCounter(data, (double)writebytecount); /* convert LF to CRLF if so asked */ - if (data->crlf) { + if (data->set.crlf) { for(i = 0, si = 0; i < (int)nread; i++, si++) { if (buf[i] == 0x0a) { scratch[si++] = 0x0d; @@ -863,7 +863,7 @@ Transfer(struct connectdata *c_conn) conn->upload_bufsize=(long)min(data->progress.ulspeed, BUFSIZE); } - if (data->timeout && (Curl_tvdiff (now, start) > data->timeout)) { + if (data->set.timeout && (Curl_tvdiff (now, start) > data->set.timeout)) { failf (data, "Operation timed out with %d out of %d bytes received", bytecount, conn->size); return CURLE_OPERATION_TIMEOUTED; @@ -876,7 +876,7 @@ Transfer(struct connectdata *c_conn) * returning. */ - if(!(data->bits.no_body) && contentlength && + if(!(data->set.no_body) && contentlength && (bytecount != contentlength)) { failf(data, "transfer closed with %d bytes remaining to read", contentlength-bytecount); @@ -898,14 +898,14 @@ Transfer(struct connectdata *c_conn) return CURLE_OK; } -CURLcode Curl_perform(struct UrlData *data) +CURLcode Curl_perform(struct SessionHandle *data) { CURLcode res; struct connectdata *conn=NULL; - bool port=TRUE; /* allow data->use_port to set port to use */ + bool port=TRUE; /* allow data->set.use_port to set port to use */ char *newurl = NULL; /* possibly a new URL to follow to! */ - if(!data->url) + if(!data->change.url) /* we can't do anything wihout URL */ return CURLE_URL_MALFORMAT; @@ -913,11 +913,11 @@ CURLcode Curl_perform(struct UrlData *data) /* Init the SSL session ID cache here. We do it here since we want to do it after the *_setopt() calls (that could change the size) but before any transfer. */ - Curl_SSL_InitSessions(data, data->ssl.numsessions); + Curl_SSL_InitSessions(data, data->set.ssl.numsessions); #endif - data->followlocation=0; /* reset the location-follow counter */ - data->bits.this_is_a_follow = FALSE; /* reset this */ + data->set.followlocation=0; /* reset the location-follow counter */ + data->state.this_is_a_follow = FALSE; /* reset this */ Curl_initinfo(data); /* reset session-specific information "variables" */ @@ -964,30 +964,28 @@ CURLcode Curl_perform(struct UrlData *data) port=TRUE; /* by default we use the user set port number even after a Location: */ - if (data->maxredirs && (data->followlocation >= data->maxredirs)) { - failf(data,"Maximum (%d) redirects followed", data->maxredirs); + if (data->set.maxredirs && (data->set.followlocation >= data->set.maxredirs)) { + failf(data,"Maximum (%d) redirects followed", data->set.maxredirs); res=CURLE_TOO_MANY_REDIRECTS; break; } /* mark the next request as a followed location: */ - data->bits.this_is_a_follow = TRUE; + data->state.this_is_a_follow = TRUE; - data->followlocation++; /* count location-followers */ + data->set.followlocation++; /* count location-followers */ - if(data->bits.http_auto_referer) { + if(data->set.http_auto_referer) { /* We are asked to automatically set the previous URL as the referer when we get the next URL. We pick the ->url field, which may or may not be 100% correct */ - if(data->free_referer) { + if(data->change.referer_alloc) /* If we already have an allocated referer, free this first */ - free(data->referer); - } + free(data->change.referer); - data->referer = strdup(data->url); - data->free_referer = TRUE; /* yes, free this later */ - data->bits.http_set_referer = TRUE; /* might have been false */ + data->change.referer = strdup(data->change.url); + data->change.referer_alloc = TRUE; /* yes, free this later */ } if(2 != sscanf(newurl, "%15[^:]://%c", prot, &letter)) { @@ -1005,7 +1003,7 @@ CURLcode Curl_perform(struct UrlData *data) /* we must make our own copy of the URL to play with, as it may point to read-only data */ - char *url_clone=strdup(data->url); + char *url_clone=strdup(data->change.url); if(!url_clone) return CURLE_OUT_OF_MEMORY; @@ -1055,16 +1053,16 @@ CURLcode Curl_perform(struct UrlData *data) port = FALSE; } - if(data->bits.urlstringalloc) - free(data->url); + if(data->change.url_alloc) + free(data->change.url); + else + data->change.url_alloc = TRUE; /* the URL is allocated */ /* TBD: set the URL with curl_setopt() */ - data->url = newurl; + data->change.url = newurl; newurl = NULL; /* don't free! */ - data->bits.urlstringalloc = TRUE; /* the URL is allocated */ - - infof(data, "Follows Location: to new URL: '%s'\n", data->url); + infof(data, "Follows Location: to new URL: '%s'\n", data->change.url); /* * We get here when the HTTP code is 300-399. We need to perform @@ -1072,7 +1070,7 @@ CURLcode Curl_perform(struct UrlData *data) * Discussed on the curl mailing list and posted about on the 26th * of January 2001. */ - switch(data->progress.httpcode) { + switch(data->info.httpcode) { case 300: /* Multiple Choices */ case 301: /* Moved Permanently */ case 306: /* Not used */ @@ -1103,7 +1101,7 @@ CURLcode Curl_perform(struct UrlData *data) case 303: /* See Other */ /* Disable both types of POSTs, since doing a second POST when * following isn't what anyone would want! */ - data->httpreq = HTTPREQ_GET; /* enforce GET request */ + data->set.httpreq = HTTPREQ_GET; /* enforce GET request */ infof(data, "Disables POST, goes with GET\n"); break; case 304: /* Not Modified */ @@ -1132,7 +1130,7 @@ CURLcode Curl_perform(struct UrlData *data) free(newurl); /* make sure the alarm is switched off! */ - if(data->timeout || data->connecttimeout) + if(data->set.timeout || data->set.connecttimeout) myalarm(0); return res; diff --git a/lib/transfer.h b/lib/transfer.h index 3254a966b..c35f7c6fb 100644 --- a/lib/transfer.h +++ b/lib/transfer.h @@ -22,7 +22,7 @@ * * $Id$ *****************************************************************************/ -CURLcode Curl_perform(struct UrlData *data); +CURLcode Curl_perform(struct SessionHandle *data); /* This sets up a forthcoming transfer */ CURLcode diff --git a/lib/url.c b/lib/url.c index 20111d0ed..571362bf6 100644 --- a/lib/url.c +++ b/lib/url.c @@ -122,11 +122,11 @@ #endif /* Local static prototypes */ -static int ConnectionKillOne(struct UrlData *data); -static bool ConnectionExists(struct UrlData *data, +static int ConnectionKillOne(struct SessionHandle *data); +static bool ConnectionExists(struct SessionHandle *data, struct connectdata *needle, struct connectdata **usethis); -static unsigned int ConnectionStore(struct UrlData *data, +static unsigned int ConnectionStore(struct SessionHandle *data, struct connectdata *conn); @@ -143,7 +143,7 @@ RETSIGTYPE alarmfunc(int signal) } #endif -CURLcode Curl_close(struct UrlData *data) +CURLcode Curl_close(struct SessionHandle *data) { /* Loop through all open connections and kill them one by one */ while(-1 != ConnectionKillOne(data)); @@ -153,39 +153,25 @@ CURLcode Curl_close(struct UrlData *data) Curl_SSL_Close_All(data); #endif - if(data->bits.proxystringalloc) { - data->bits.proxystringalloc=FALSE;; - free(data->proxy); - data->proxy=NULL; + if(data->change.proxy_alloc) + free(data->change.proxy); + if(data->change.referer_alloc) + free(data->change.referer); + if(data->change.url_alloc) + free(data->change.url); - /* Since we allocated the string the previous round, it means that we - "discovered" the proxy in the environment variables and thus we must - switch off that knowledge again... */ - data->bits.httpproxy=FALSE; - } - - /* check for allocated [URL] memory to free: */ - if(data->freethis) - free(data->freethis); - - if(data->headerbuff) - free(data->headerbuff); + if(data->state.headerbuff) + free(data->state.headerbuff); - if(data->free_referer) - free(data->referer); - if(data->bits.urlstringalloc) - /* the URL is allocated, free it! */ - free(data->url); - - if(data->cookiejar) + if(data->set.cookiejar) /* we have a "destination" for all the cookies to get dumped to */ - Curl_cookie_output(data->cookies, data->cookiejar); + Curl_cookie_output(data->cookies, data->set.cookiejar); Curl_cookie_cleanup(data->cookies); /* free the connection cache */ - free(data->connects); + free(data->state.connects); free(data); return CURLE_OK; @@ -205,66 +191,67 @@ int my_getpass(void *clientp, const char *prompt, char* buffer, int buflen ) } -CURLcode Curl_open(struct UrlData **curl) +CURLcode Curl_open(struct SessionHandle **curl) { /* We don't yet support specifying the URL at this point */ - struct UrlData *data; + struct SessionHandle *data; #ifdef HAVE_SIGACTION struct sigaction sigact; #endif /* Very simple start-up: alloc the struct, init it with zeroes and return */ - data = (struct UrlData *)malloc(sizeof(struct UrlData)); + data = (struct SessionHandle *)malloc(sizeof(struct SessionHandle)); if(data) { - memset(data, 0, sizeof(struct UrlData)); + memset(data, 0, sizeof(struct SessionHandle)); /* We do some initial setup here, all those fields that can't be just 0 */ - data-> headerbuff=(char*)malloc(HEADERSIZE); - if(!data->headerbuff) { + data->state.headerbuff=(char*)malloc(HEADERSIZE); + if(!data->state.headerbuff) { free(data); /* free the memory again */ return CURLE_OUT_OF_MEMORY; } - data->headersize=HEADERSIZE; + data->state.headersize=HEADERSIZE; - data->out = stdout; /* default output to stdout */ - data->in = stdin; /* default input from stdin */ - data->err = stderr; /* default stderr to stderr */ + data->set.out = stdout; /* default output to stdout */ + data->set.in = stdin; /* default input from stdin */ + data->set.err = stderr; /* default stderr to stderr */ /* use fwrite as default function to store output */ - data->fwrite = (curl_write_callback)fwrite; + data->set.fwrite = (curl_write_callback)fwrite; /* use fread as default function to read input */ - data->fread = (curl_read_callback)fread; + data->set.fread = (curl_read_callback)fread; /* set the default passwd function */ - data->fpasswd = my_getpass; + data->set.fpasswd = my_getpass; - data->infilesize = -1; /* we don't know any size */ + data->set.infilesize = -1; /* we don't know any size */ - data->current_speed = -1; /* init to negative == impossible */ + data->state.current_speed = -1; /* init to negative == impossible */ - data->httpreq = HTTPREQ_GET; /* Default HTTP request */ + data->set.httpreq = HTTPREQ_GET; /* Default HTTP request */ /* make libcurl quiet by default: */ - data->bits.hide_progress = TRUE; /* CURLOPT_NOPROGRESS changes these */ + data->set.hide_progress = TRUE; /* CURLOPT_NOPROGRESS changes these */ data->progress.flags |= PGRS_HIDE; /* Set the default size of the SSL session ID cache */ - data->ssl.numsessions = 5; + data->set.ssl.numsessions = 5; /* create an array with connection data struct pointers */ - data->numconnects = 5; /* hard-coded right now */ - data->connects = (struct connectdata **) - malloc(sizeof(struct connectdata *) * data->numconnects); + data->state.numconnects = 5; /* hard-coded right now */ + data->state.connects = (struct connectdata **) + malloc(sizeof(struct connectdata *) * data->state.numconnects); - if(!data->connects) { + if(!data->state.connects) { free(data); return CURLE_OUT_OF_MEMORY; } - memset(data->connects, 0, sizeof(struct connectdata *)*data->numconnects); + memset(data->state.connects, 0, + sizeof(struct connectdata *)*data->state.numconnects); *curl = data; @@ -294,7 +281,7 @@ CURLcode Curl_open(struct UrlData **curl) return CURLE_OUT_OF_MEMORY; } -CURLcode Curl_setopt(struct UrlData *data, CURLoption option, ...) +CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option, ...) { va_list param; char *cookiefile; @@ -307,13 +294,13 @@ CURLcode Curl_setopt(struct UrlData *data, CURLoption option, ...) * This is the path name to a file that contains random data to seed * the random SSL stuff with. The file is only used for reading. */ - data->ssl.random_file = va_arg(param, char *); + data->set.ssl.random_file = va_arg(param, char *); break; case CURLOPT_EGDSOCKET: /* * The Entropy Gathering Daemon socket pathname */ - data->ssl.egdsocket = va_arg(param, char *); + data->set.ssl.egdsocket = va_arg(param, char *); break; case CURLOPT_MAXCONNECTS: /* @@ -324,30 +311,30 @@ CURLcode Curl_setopt(struct UrlData *data, CURLoption option, ...) long newconnects= va_arg(param, long); struct connectdata **newptr; - if(newconnects < data->numconnects) { + if(newconnects < data->state.numconnects) { /* Since this number is *decreased* from the existing number, we must close the possibly open connections that live on the indexes that are being removed! */ int i; - for(i=newconnects; i< data->numconnects; i++) - Curl_disconnect(data->connects[i]); + for(i=newconnects; i< data->state.numconnects; i++) + Curl_disconnect(data->state.connects[i]); } if(newconnects) { newptr= (struct connectdata **) - realloc(data->connects, + realloc(data->state.connects, sizeof(struct connectdata *) * newconnects); if(!newptr) /* we closed a few connections in vain, but so what? */ return CURLE_OUT_OF_MEMORY; - data->connects = newptr; - data->numconnects = newconnects; + data->state.connects = newptr; + data->state.numconnects = newconnects; } else { /* zero makes NO cache at all */ - if(data->connects) - free(data->connects); - data->connects=NULL; - data->numconnects=0; + if(data->state.connects) + free(data->state.connects); + data->state.connects=NULL; + data->state.numconnects=0; } } break; @@ -356,34 +343,34 @@ CURLcode Curl_setopt(struct UrlData *data, CURLoption option, ...) * When this transfer is done, it must not be left to be reused by a * subsequent transfer but shall be closed immediately. */ - data->bits.reuse_forbid = va_arg(param, long)?TRUE:FALSE; + data->set.reuse_forbid = va_arg(param, long)?TRUE:FALSE; break; case CURLOPT_FRESH_CONNECT: /* * This transfer shall not use a previously cached connection but * should be made with a fresh new connect! */ - data->bits.reuse_fresh = va_arg(param, long)?TRUE:FALSE; + data->set.reuse_fresh = va_arg(param, long)?TRUE:FALSE; break; case CURLOPT_VERBOSE: /* * Verbose means infof() calls that give a lot of information about * the connection and transfer procedures as well as internal choices. */ - data->bits.verbose = va_arg(param, long)?TRUE:FALSE; + data->set.verbose = va_arg(param, long)?TRUE:FALSE; break; case CURLOPT_HEADER: /* * Set to include the header in the general data output stream. */ - data->bits.http_include_header = va_arg(param, long)?TRUE:FALSE; + data->set.http_include_header = va_arg(param, long)?TRUE:FALSE; break; case CURLOPT_NOPROGRESS: /* * Shut off the internal supported progress meter */ - data->bits.hide_progress = va_arg(param, long)?TRUE:FALSE; - if(data->bits.hide_progress) + data->set.hide_progress = va_arg(param, long)?TRUE:FALSE; + if(data->set.hide_progress) data->progress.flags |= PGRS_HIDE; else data->progress.flags &= ~PGRS_HIDE; @@ -392,55 +379,55 @@ CURLcode Curl_setopt(struct UrlData *data, CURLoption option, ...) /* * Do not include the body part in the output data stream. */ - data->bits.no_body = va_arg(param, long)?TRUE:FALSE; + data->set.no_body = va_arg(param, long)?TRUE:FALSE; break; case CURLOPT_FAILONERROR: /* * Don't output the >=300 error code HTML-page, but instead only * return error. */ - data->bits.http_fail_on_error = va_arg(param, long)?TRUE:FALSE; + data->set.http_fail_on_error = va_arg(param, long)?TRUE:FALSE; break; case CURLOPT_UPLOAD: /* * We want to sent data to the remote host */ - data->bits.upload = va_arg(param, long)?TRUE:FALSE; - if(data->bits.upload) + data->set.upload = va_arg(param, long)?TRUE:FALSE; + if(data->set.upload) /* If this is HTTP, PUT is what's needed to "upload" */ - data->httpreq = HTTPREQ_PUT; + data->set.httpreq = HTTPREQ_PUT; break; case CURLOPT_FILETIME: /* * Try to get the file time of the remote document. The time will * later (possibly) become available using curl_easy_getinfo(). */ - data->bits.get_filetime = va_arg(param, long)?TRUE:FALSE; + data->set.get_filetime = va_arg(param, long)?TRUE:FALSE; break; case CURLOPT_FTPLISTONLY: /* * An FTP option that changes the command to one that asks for a list * only, no file info details. */ - data->bits.ftp_list_only = va_arg(param, long)?TRUE:FALSE; + data->set.ftp_list_only = va_arg(param, long)?TRUE:FALSE; break; case CURLOPT_FTPAPPEND: /* * We want to upload and append to an existing (FTP) file. */ - data->bits.ftp_append = va_arg(param, long)?TRUE:FALSE; + data->set.ftp_append = va_arg(param, long)?TRUE:FALSE; break; case CURLOPT_NETRC: /* * Parse the $HOME/.netrc file */ - data->bits.use_netrc = va_arg(param, long)?TRUE:FALSE; + data->set.use_netrc = va_arg(param, long)?TRUE:FALSE; break; case CURLOPT_FOLLOWLOCATION: /* * Follow Location: header hints on a HTTP-server. */ - data->bits.http_follow_location = va_arg(param, long)?TRUE:FALSE; + data->set.http_follow_location = va_arg(param, long)?TRUE:FALSE; break; case CURLOPT_TRANSFERTEXT: /* @@ -449,7 +436,7 @@ CURLcode Curl_setopt(struct UrlData *data, CURLoption option, ...) * * Transfer using ASCII (instead of BINARY). */ - data->bits.ftp_ascii = va_arg(param, long)?TRUE:FALSE; + data->set.ftp_ascii = va_arg(param, long)?TRUE:FALSE; break; case CURLOPT_PUT: /* @@ -457,7 +444,7 @@ CURLcode Curl_setopt(struct UrlData *data, CURLoption option, ...) * FALSE, don't set the httpreq. We can't know what to revert it to! */ if(va_arg(param, long)) - data->httpreq = HTTPREQ_PUT; + data->set.httpreq = HTTPREQ_PUT; break; #if 0 /* obsolete stuff, kept here a while for informational purposes */ @@ -465,7 +452,7 @@ CURLcode Curl_setopt(struct UrlData *data, CURLoption option, ...) /* * Stay absolutely quiet. */ - data->bits.mute = va_arg(param, long)?TRUE:FALSE; + data->set.mute = va_arg(param, long)?TRUE:FALSE; break; #endif case CURLOPT_TIMECONDITION: @@ -473,21 +460,21 @@ CURLcode Curl_setopt(struct UrlData *data, CURLoption option, ...) * Set HTTP time condition. This must be one of the defines in the * curl/curl.h header file. */ - data->timecondition = va_arg(param, long); + data->set.timecondition = va_arg(param, long); break; case CURLOPT_TIMEVALUE: /* * This is the value to compare with the remote document with the * method set with CURLOPT_TIMECONDITION */ - data->timevalue = va_arg(param, long); + data->set.timevalue = va_arg(param, long); break; case CURLOPT_SSLVERSION: /* * Set explicit SSL version to try to connect with, as some SSL * implementations are lame. */ - data->ssl.version = va_arg(param, long); + data->set.ssl.version = va_arg(param, long); break; case CURLOPT_COOKIEFILE: @@ -503,61 +490,61 @@ CURLcode Curl_setopt(struct UrlData *data, CURLoption option, ...) /* * Set cookie file name to dump all cookies to when we're done. */ - data->cookiejar = cookiefile = (char *)va_arg(param, void *); + data->set.cookiejar = cookiefile = (char *)va_arg(param, void *); break; case CURLOPT_WRITEHEADER: /* * Custom pointer to pass the header write callback function */ - data->writeheader = (void *)va_arg(param, void *); + data->set.writeheader = (void *)va_arg(param, void *); break; case CURLOPT_COOKIE: /* * Cookie string to send to the remote server in the request. */ - data->cookie = va_arg(param, char *); + data->set.cookie = va_arg(param, char *); break; case CURLOPT_ERRORBUFFER: /* * Error buffer provided by the caller to get the human readable * error string in. */ - data->errorbuffer = va_arg(param, char *); + data->set.errorbuffer = va_arg(param, char *); break; case CURLOPT_FILE: /* * FILE pointer to write to or include in the data write callback */ - data->out = va_arg(param, FILE *); + data->set.out = va_arg(param, FILE *); break; case CURLOPT_FTPPORT: /* * Use FTP PORT, this also specifies which IP address to use */ - data->ftpport = va_arg(param, char *); - data->bits.ftp_use_port = data->ftpport?1:0; + data->set.ftpport = va_arg(param, char *); + data->set.ftp_use_port = data->set.ftpport?1:0; break; case CURLOPT_HTTPHEADER: /* * Set a list with HTTP headers to use (or replace internals with) */ - data->headers = va_arg(param, struct curl_slist *); + data->set.headers = va_arg(param, struct curl_slist *); break; case CURLOPT_CUSTOMREQUEST: /* * Set a custom string to use as request */ - data->customrequest = va_arg(param, char *); - if(data->customrequest) - data->httpreq = HTTPREQ_CUSTOM; + data->set.customrequest = va_arg(param, char *); + if(data->set.customrequest) + data->set.httpreq = HTTPREQ_CUSTOM; break; case CURLOPT_HTTPPOST: /* * Set to make us do HTTP POST */ - data->httppost = va_arg(param, struct HttpPost *); - if(data->httppost) - data->httpreq = HTTPREQ_POST_FORM; + data->set.httppost = va_arg(param, struct HttpPost *); + if(data->set.httppost) + data->set.httpreq = HTTPREQ_POST_FORM; break; case CURLOPT_HTTPGET: @@ -565,7 +552,7 @@ CURLcode Curl_setopt(struct UrlData *data, CURLoption option, ...) * Set to force us do HTTP GET */ if(va_arg(param, long)) - data->httpreq = HTTPREQ_GET; + data->set.httpreq = HTTPREQ_GET; break; case CURLOPT_INFILE: @@ -573,276 +560,279 @@ CURLcode Curl_setopt(struct UrlData *data, CURLoption option, ...) * FILE pointer to read the file to be uploaded from. Or possibly * used as argument to the read callback. */ - data->in = va_arg(param, FILE *); + data->set.in = va_arg(param, FILE *); break; case CURLOPT_INFILESIZE: /* * If known, this should inform curl about the file size of the * to-be-uploaded file. */ - data->infilesize = va_arg(param, long); + data->set.infilesize = va_arg(param, long); break; case CURLOPT_LOW_SPEED_LIMIT: /* * The low speed limit that if transfers are below this for * CURLOPT_LOW_SPEED_TIME, the transfer is aborted. */ - data->low_speed_limit=va_arg(param, long); + data->set.low_speed_limit=va_arg(param, long); break; case CURLOPT_LOW_SPEED_TIME: /* * The low speed time that if transfers are below the set * CURLOPT_LOW_SPEED_LIMIT during this time, the transfer is aborted. */ - data->low_speed_time=va_arg(param, long); + data->set.low_speed_time=va_arg(param, long); break; case CURLOPT_URL: /* * The URL to fetch. */ - if(data->bits.urlstringalloc) { + if(data->change.url_alloc) { /* the already set URL is allocated, free it first! */ - free(data->url); - data->bits.urlstringalloc=FALSE; + free(data->change.url); + data->change.url_alloc=FALSE; } - data->url = va_arg(param, char *); + data->set.set_url = va_arg(param, char *); + data->change.url = data->set.set_url; break; case CURLOPT_PORT: /* * The port number to use when getting the URL */ - data->use_port = va_arg(param, long); + data->set.use_port = va_arg(param, long); break; case CURLOPT_POST: /* Does this option serve a purpose anymore? */ if(va_arg(param, long)) - data->httpreq = HTTPREQ_POST; + data->set.httpreq = HTTPREQ_POST; break; case CURLOPT_POSTFIELDS: /* * A string with POST data. Makes curl HTTP POST. */ - data->postfields = va_arg(param, char *); - if(data->postfields) - data->httpreq = HTTPREQ_POST; + data->set.postfields = va_arg(param, char *); + if(data->set.postfields) + data->set.httpreq = HTTPREQ_POST; break; case CURLOPT_POSTFIELDSIZE: /* * The size of the POSTFIELD data, if curl should now do a strlen * to find out. Enables binary posts. */ - data->postfieldsize = va_arg(param, long); + data->set.postfieldsize = va_arg(param, long); break; case CURLOPT_REFERER: /* * String to set in the HTTP Referer: field. */ - data->referer = va_arg(param, char *); - data->bits.http_set_referer = (data->referer && *data->referer)?1:0; + if(data->change.referer_alloc) { + free(data->change.referer); + data->change.referer_alloc = FALSE; + } + data->set.set_referer = va_arg(param, char *); + data->change.referer = data->set.set_referer; break; case CURLOPT_AUTOREFERER: /* * Switch on automatic referer that gets set if curl follows locations. */ - data->bits.http_auto_referer = va_arg(param, long)?1:0; + data->set.http_auto_referer = va_arg(param, long)?1:0; break; case CURLOPT_PROXY: /* * Set proxy server:port to use as HTTP proxy */ - if(data->bits.proxystringalloc) { + if(data->change.proxy_alloc) { /* * The already set string is allocated, free that first */ - data->bits.proxystringalloc=FALSE;; - free(data->proxy); + data->change.proxy_alloc=FALSE;; + free(data->change.proxy); } - data->proxy = va_arg(param, char *); - data->bits.httpproxy = data->proxy?1:0; + data->set.set_proxy = va_arg(param, char *); + data->change.proxy = data->set.set_proxy; break; case CURLOPT_HTTPPROXYTUNNEL: /* * Tunnel operations through the proxy instead of normal proxy use */ - data->bits.tunnel_thru_httpproxy = va_arg(param, long)?TRUE:FALSE; + data->set.tunnel_thru_httpproxy = va_arg(param, long)?TRUE:FALSE; break; case CURLOPT_PROXYPORT: /* * Explicitly set HTTP proxy port number. */ - data->proxyport = va_arg(param, long); + data->set.proxyport = va_arg(param, long); break; case CURLOPT_TIMEOUT: /* * The maximum time you allow curl to use for a single transfer * operation. */ - data->timeout = va_arg(param, long); + data->set.timeout = va_arg(param, long); break; case CURLOPT_CONNECTTIMEOUT: /* * The maximum time you allow curl to use to connect. */ - data->connecttimeout = va_arg(param, long); + data->set.connecttimeout = va_arg(param, long); break; case CURLOPT_MAXREDIRS: /* * The maximum amount of hops you allow curl to follow Location: * headers. This should mostly be used to detect never-ending loops. */ - data->maxredirs = va_arg(param, long); + data->set.maxredirs = va_arg(param, long); break; case CURLOPT_USERAGENT: /* * String to use in the HTTP User-Agent field */ - data->useragent = va_arg(param, char *); + data->set.useragent = va_arg(param, char *); break; case CURLOPT_USERPWD: /* * user:password to use in the operation */ - data->userpwd = va_arg(param, char *); + data->set.userpwd = va_arg(param, char *); break; case CURLOPT_POSTQUOTE: /* * List of RAW FTP commands to use after a transfer */ - data->postquote = va_arg(param, struct curl_slist *); + data->set.postquote = va_arg(param, struct curl_slist *); break; case CURLOPT_QUOTE: /* * List of RAW FTP commands to use before a transfer */ - data->quote = va_arg(param, struct curl_slist *); + data->set.quote = va_arg(param, struct curl_slist *); break; case CURLOPT_PROGRESSFUNCTION: /* * Progress callback function */ - data->fprogress = va_arg(param, curl_progress_callback); + data->set.fprogress = va_arg(param, curl_progress_callback); data->progress.callback = TRUE; /* no longer internal */ break; case CURLOPT_PROGRESSDATA: /* * Custom client data to pass to the progress callback */ - data->progress_client = va_arg(param, void *); + data->set.progress_client = va_arg(param, void *); break; case CURLOPT_PASSWDFUNCTION: /* * Password prompt callback */ - data->fpasswd = va_arg(param, curl_passwd_callback); + data->set.fpasswd = va_arg(param, curl_passwd_callback); break; case CURLOPT_PASSWDDATA: /* * Custom client data to pass to the password callback */ - data->passwd_client = va_arg(param, void *); + data->set.passwd_client = va_arg(param, void *); break; case CURLOPT_PROXYUSERPWD: /* * user:password needed to use the proxy */ - data->proxyuserpwd = va_arg(param, char *); + data->set.proxyuserpwd = va_arg(param, char *); break; case CURLOPT_RANGE: /* * What range of the file you want to transfer */ - data->set_range = va_arg(param, char *); - data->bits.set_range = data->set_range?1:0; + data->set.set_range = va_arg(param, char *); break; case CURLOPT_RESUME_FROM: /* * Resume transfer at the give file position */ - data->set_resume_from = va_arg(param, long); + data->set.set_resume_from = va_arg(param, long); break; case CURLOPT_STDERR: /* * Set to a FILE * that should receive all error writes. This * defaults to stderr for normal operations. */ - data->err = va_arg(param, FILE *); + data->set.err = va_arg(param, FILE *); break; case CURLOPT_HEADERFUNCTION: /* * Set header write callback */ - data->fwrite_header = va_arg(param, curl_write_callback); + data->set.fwrite_header = va_arg(param, curl_write_callback); break; case CURLOPT_WRITEFUNCTION: /* * Set data write callback */ - data->fwrite = va_arg(param, curl_write_callback); + data->set.fwrite = va_arg(param, curl_write_callback); break; case CURLOPT_READFUNCTION: /* * Read data callback */ - data->fread = va_arg(param, curl_read_callback); + data->set.fread = va_arg(param, curl_read_callback); break; case CURLOPT_SSLCERT: /* * String that holds file name of the SSL certificate to use */ - data->cert = va_arg(param, char *); + data->set.cert = va_arg(param, char *); break; case CURLOPT_SSLCERTPASSWD: /* * String that holds the SSL certificate password. */ - data->cert_passwd = va_arg(param, char *); + data->set.cert_passwd = va_arg(param, char *); break; case CURLOPT_CRLF: /* - * Kludgy option to enable CRLF convertions. Subject for - * removal. + * Kludgy option to enable CRLF convertions. Subject for removal. */ - data->crlf = va_arg(param, long); + data->set.crlf = va_arg(param, long)?TRUE:FALSE; break; case CURLOPT_INTERFACE: /* * Set what interface to bind to when performing an operation and thus * what from-IP your connection will use. */ - data->device = va_arg(param, char *); + data->set.device = va_arg(param, char *); break; case CURLOPT_KRB4LEVEL: /* * A string that defines the krb4 security level. */ - data->krb4_level = va_arg(param, char *); - data->bits.krb4=data->krb4_level?TRUE:FALSE; + data->set.krb4_level = va_arg(param, char *); + data->set.krb4=data->set.krb4_level?TRUE:FALSE; break; case CURLOPT_SSL_VERIFYPEER: /* * Enable peer SSL verifying. */ - data->ssl.verifypeer = va_arg(param, long); + data->set.ssl.verifypeer = va_arg(param, long); break; case CURLOPT_SSL_VERIFYHOST: /* * Enable verification of the CN contained in the peer certificate */ - data->ssl.verifyhost = va_arg(param, long); + data->set.ssl.verifyhost = va_arg(param, long); break; case CURLOPT_CAINFO: /* * Set CA info for SSL connection. Specify file name of the CA certificate */ - data->ssl.CAfile = va_arg(param, char *); - data->ssl.CApath = NULL; /*This does not work on windows.*/ + data->set.ssl.CAfile = va_arg(param, char *); + data->set.ssl.CApath = NULL; /*This does not work on windows.*/ break; case CURLOPT_TELNETOPTIONS: /* * Set a linked list of telnet options */ - data->telnet_options = va_arg(param, struct curl_slist *); + data->set.telnet_options = va_arg(param, struct curl_slist *); break; default: /* unknown tag and its companion, just ignore: */ @@ -869,7 +859,7 @@ CURLcode Curl_disconnect(struct connectdata *conn) if(-1 != conn->connectindex) { /* unlink ourselves! */ infof(conn->data, "Closing live connection (#%d)\n", conn->connectindex); - conn->data->connects[conn->connectindex] = NULL; + conn->data->state.connects[conn->connectindex] = NULL; } if(conn->curl_disconnect) @@ -958,19 +948,19 @@ static bool SocketIsDead(int sock) * thus should be used instead. */ static bool -ConnectionExists(struct UrlData *data, +ConnectionExists(struct SessionHandle *data, struct connectdata *needle, struct connectdata **usethis) { long i; struct connectdata *check; - for(i=0; i< data->numconnects; i++) { + for(i=0; i< data->state.numconnects; i++) { /* * Note that if we use a HTTP proxy, we check connections to that * proxy and not to the actual remote server. */ - check = data->connects[i]; + check = data->state.connects[i]; if(!check) /* NULL pointer means not filled-in entry */ continue; @@ -984,8 +974,8 @@ ConnectionExists(struct UrlData *data, if(strequal(needle->protostr, "FTP")) { /* This is FTP, verify that we're using the same name and password as well */ - if(!strequal(needle->data->user, check->proto.ftp->user) || - !strequal(needle->data->passwd, check->proto.ftp->passwd)) { + if(!strequal(needle->data->state.user, check->proto.ftp->user) || + !strequal(needle->data->state.passwd, check->proto.ftp->passwd)) { /* one of them was different */ continue; } @@ -994,7 +984,7 @@ ConnectionExists(struct UrlData *data, if(dead) { infof(data, "Connection %d seems to be dead!\n", i); Curl_disconnect(check); /* disconnect resources */ - data->connects[i]=NULL; /* nothing here */ + data->state.connects[i]=NULL; /* nothing here */ continue; /* try another one now */ } @@ -1023,7 +1013,7 @@ ConnectionExists(struct UrlData *data, * of the connections to kill. */ static int -ConnectionKillOne(struct UrlData *data) +ConnectionKillOne(struct SessionHandle *data) { long i; struct connectdata *conn; @@ -1035,8 +1025,8 @@ ConnectionKillOne(struct UrlData *data) now = Curl_tvnow(); - for(i=0; i< data->numconnects; i++) { - conn = data->connects[i]; + for(i=0; i< data->state.numconnects; i++) { + conn = data->state.connects[i]; if(!conn) continue; @@ -1044,7 +1034,7 @@ ConnectionKillOne(struct UrlData *data) /* * By using the set policy, we score each connection. */ - switch(data->closepolicy) { + switch(data->set.closepolicy) { case CURLCLOSEPOLICY_LEAST_RECENTLY_USED: default: /* @@ -1070,10 +1060,10 @@ ConnectionKillOne(struct UrlData *data) if(connindex >= 0) { /* the winner gets the honour of being disconnected */ - result = Curl_disconnect(data->connects[connindex]); + result = Curl_disconnect(data->state.connects[connindex]); /* clean the array entry */ - data->connects[connindex] = NULL; + data->state.connects[connindex] = NULL; } return connindex; /* return the available index or -1 */ @@ -1088,28 +1078,28 @@ ConnectionKillOne(struct UrlData *data) * this call. */ static unsigned int -ConnectionStore(struct UrlData *data, +ConnectionStore(struct SessionHandle *data, struct connectdata *conn) { long i; - for(i=0; i< data->numconnects; i++) { - if(!data->connects[i]) + for(i=0; i< data->state.numconnects; i++) { + if(!data->state.connects[i]) break; } - if(i == data->numconnects) { + if(i == data->state.numconnects) { /* there was no room available, kill one */ i = ConnectionKillOne(data); infof(data, "Connection (#%d) was killed to make room\n", i); } - data->connects[i] = conn; /* fill in this */ + data->state.connects[i] = conn; /* fill in this */ conn->connectindex = i; /* make the child know where the pointer to this particular data is stored */ return i; } -static CURLcode ConnectPlease(struct UrlData *data, +static CURLcode ConnectPlease(struct SessionHandle *data, struct connectdata *conn) { #if defined(WIN32) @@ -1146,7 +1136,7 @@ static CURLcode ConnectPlease(struct UrlData *data, /************************************************************* * Select device to bind socket to *************************************************************/ - if (data->device && (strlen(data->device)<255)) { + if (data->set.device && (strlen(data->set.device)<255)) { struct sockaddr_in sa; struct hostent *h=NULL; char *hostdataptr=NULL; @@ -1154,16 +1144,16 @@ static CURLcode ConnectPlease(struct UrlData *data, char myhost[256] = ""; unsigned long in; - if(Curl_if2ip(data->device, myhost, sizeof(myhost))) { + if(Curl_if2ip(data->set.device, myhost, sizeof(myhost))) { h = Curl_gethost(data, myhost, &hostdataptr); } else { - if(strlen(data->device)>1) { - h = Curl_gethost(data, data->device, &hostdataptr); + if(strlen(data->set.device)>1) { + h = Curl_gethost(data, data->set.device, &hostdataptr); } if(h) { - /* we know data->device is shorter than the myhost array */ - strcpy(myhost, data->device); + /* we know data->set.device is shorter than the myhost array */ + strcpy(myhost, data->set.device); } } @@ -1283,7 +1273,7 @@ static CURLcode ConnectPlease(struct UrlData *data, #if defined(WIN32) FD_ZERO (&connectfd); FD_SET(conn->firstsocket, &connectfd); - if (conn->data->connecttimeout > 0) { + if (conn->data->set.connecttimeout > 0) { nonblock = 1; } ioctlsocket(conn->firstsocket, FIONBIO, &nonblock); @@ -1293,7 +1283,7 @@ static CURLcode ConnectPlease(struct UrlData *data, sizeof(conn->serv_addr) ) < 0) { #if defined(WIN32) - conntimeout.tv_sec = conn->data->connecttimeout; + conntimeout.tv_sec = conn->data->set.connecttimeout; conntimeout.tv_usec = 0; if(-1 != select (conn->firstsocket + 1, NULL, &connectfd, NULL, &conntimeout)) { if (FD_ISSET(conn->firstsocket, &connectfd)) { @@ -1355,9 +1345,9 @@ static CURLcode ConnectPlease(struct UrlData *data, return CURLE_OK; } -static CURLcode Connect(struct UrlData *data, +static CURLcode Connect(struct SessionHandle *data, struct connectdata **in_connect, - bool allow_port) /* allow data->use_port ? */ + bool allow_port) /* allow data->set.use_port ? */ { char *tmp; char *buf; @@ -1372,7 +1362,7 @@ static CURLcode Connect(struct UrlData *data, * Check input data *************************************************************/ - if(!data->url) + if(!data->change.url) return CURLE_URL_MALFORMAT; /* First, split up the current URL in parts so that we can use the @@ -1399,10 +1389,10 @@ static CURLcode Connect(struct UrlData *data, conn->firstsocket = -1; /* no file descriptor */ conn->secondarysocket = -1; /* no file descriptor */ conn->connectindex = -1; /* no index */ - conn->bits.httpproxy = data->bits.httpproxy; /* proxy-or-not status */ - conn->bits.use_range = data->bits.set_range; /* range status */ - conn->range = data->set_range; /* clone the range setting */ - conn->resume_from = data->set_resume_from; /* inherite resume_from */ + conn->bits.httpproxy = data->change.proxy?TRUE:FALSE; /* proxy-or-not */ + conn->bits.use_range = data->set.set_range?TRUE:FALSE; /* range status */ + conn->range = data->set.set_range; /* clone the range setting */ + conn->resume_from = data->set.set_resume_from; /* inherite resume_from */ /* Default protocol-independent behavior doesn't support persistant connections, so we set this to force-close. Protocols that support @@ -1410,8 +1400,8 @@ static CURLcode Connect(struct UrlData *data, conn->bits.close = TRUE; /* inherite initial knowledge from the data struct */ - conn->bits.user_passwd = data->userpwd?1:0; - conn->bits.proxy_user_passwd = data->proxyuserpwd?1:0; + conn->bits.user_passwd = data->set.userpwd?1:0; + conn->bits.proxy_user_passwd = data->set.proxyuserpwd?1:0; /* maxdownload must be -1 on init, as 0 is a valid value! */ conn->maxdownload = -1; /* might have been used previously! */ @@ -1426,7 +1416,7 @@ static CURLcode Connect(struct UrlData *data, * other parts of the code will rely on this fact ***********************************************************/ #define LEAST_PATH_ALLOC 256 - urllen=strlen(data->url); + urllen=strlen(data->change.url); if(urllen < LEAST_PATH_ALLOC) urllen=LEAST_PATH_ALLOC; @@ -1442,7 +1432,7 @@ static CURLcode Connect(struct UrlData *data, * proxy -- and we don't know if we will need to use SSL until we parse the * url ... ************************************************************/ - if((2 == sscanf(data->url, "%64[^:]://%[^\n]", + if((2 == sscanf(data->change.url, "%64[^:]://%[^\n]", conn->protostr, conn->path)) && strequal(conn->protostr, "file")) { /* @@ -1486,7 +1476,7 @@ static CURLcode Connect(struct UrlData *data, strcpy(conn->gname, "curl.haxx.se"); strcpy(conn->path, "/"); - if (2 > sscanf(data->url, + if (2 > sscanf(data->change.url, "%64[^\n:]://%256[^\n/]%[^\n]", conn->protostr, conn->gname, conn->path)) { @@ -1494,7 +1484,7 @@ static CURLcode Connect(struct UrlData *data, * The URL was badly formatted, let's try the browser-style _without_ * protocol specified like 'http://'. */ - if((1 > sscanf(data->url, "%256[^\n/]%[^\n]", + if((1 > sscanf(data->change.url, "%256[^\n/]%[^\n]", conn->gname, conn->path)) ) { /* * We couldn't even get this format. @@ -1533,30 +1523,31 @@ static CURLcode Connect(struct UrlData *data, } } - buf = data->buffer; /* this is our buffer */ + buf = data->state.buffer; /* this is our buffer */ /************************************************************* * Take care of user and password authentication stuff *************************************************************/ - if(conn->bits.user_passwd && !data->bits.use_netrc) { - data->user[0] =0; - data->passwd[0]=0; + if(conn->bits.user_passwd && !data->set.use_netrc) { + data->state.user[0] =0; + data->state.passwd[0]=0; - if(*data->userpwd != ':') { + if(*data->set.userpwd != ':') { /* the name is given, get user+password */ - sscanf(data->userpwd, "%127[^:]:%127[^\n]", - data->user, data->passwd); + sscanf(data->set.userpwd, "%127[^:]:%127[^\n]", + data->state.user, data->state.passwd); } else /* no name given, get the password only */ - sscanf(data->userpwd+1, "%127[^\n]", data->passwd); + sscanf(data->set.userpwd+1, "%127[^\n]", data->state.passwd); /* check for password, if no ask for one */ - if( !data->passwd[0] ) { - if(!data->fpasswd || - data->fpasswd(data->passwd_client, - "password:", data->passwd, sizeof(data->passwd))) + if( !data->state.passwd[0] ) { + if(!data->set.fpasswd || + data->set.fpasswd(data->set.passwd_client, + "password:", data->state.passwd, + sizeof(data->state.passwd))) return CURLE_BAD_PASSWORD_ENTERED; } } @@ -1565,25 +1556,25 @@ static CURLcode Connect(struct UrlData *data, * Take care of proxy authentication stuff *************************************************************/ if(conn->bits.proxy_user_passwd) { - data->proxyuser[0] =0; - data->proxypasswd[0]=0; + data->state.proxyuser[0] =0; + data->state.proxypasswd[0]=0; - if(*data->proxyuserpwd != ':') { + if(*data->set.proxyuserpwd != ':') { /* the name is given, get user+password */ - sscanf(data->proxyuserpwd, "%127[^:]:%127[^\n]", - data->proxyuser, data->proxypasswd); + sscanf(data->set.proxyuserpwd, "%127[^:]:%127[^\n]", + data->state.proxyuser, data->state.proxypasswd); } else /* no name given, get the password only */ - sscanf(data->proxyuserpwd+1, "%127[^\n]", data->proxypasswd); + sscanf(data->set.proxyuserpwd+1, "%127[^\n]", data->state.proxypasswd); /* check for password, if no ask for one */ - if( !data->proxypasswd[0] ) { - if(!data->fpasswd || - data->fpasswd( data->passwd_client, + if( !data->state.proxypasswd[0] ) { + if(!data->set.fpasswd || + data->set.fpasswd( data->set.passwd_client, "proxy password:", - data->proxypasswd, - sizeof(data->proxypasswd))) + data->state.proxypasswd, + sizeof(data->state.proxypasswd))) return CURLE_BAD_PASSWORD_ENTERED; } @@ -1600,7 +1591,7 @@ static CURLcode Connect(struct UrlData *data, /************************************************************* * Detect what (if any) proxy to use *************************************************************/ - if(!data->bits.httpproxy) { + if(!data->change.proxy) { /* If proxy was not specified, we check for default proxy environment * variables, to enable i.e Lynx compliance: * @@ -1690,9 +1681,8 @@ static CURLcode Connect(struct UrlData *data, if(proxy && *proxy) { /* we have a proxy here to set */ - data->proxy = proxy; - data->bits.proxystringalloc=1; /* this needs to be freed later */ - data->bits.httpproxy=1; + data->change.proxy = proxy; + data->change.proxy_alloc=TRUE; /* this needs to be freed later */ } } /* if (!nope) - it wasn't specified non-proxy */ } /* NO_PROXY wasn't specified or '*' */ @@ -1703,22 +1693,19 @@ static CURLcode Connect(struct UrlData *data, /************************************************************* * No protocol but proxy usage needs attention *************************************************************/ - if((conn->protocol&PROT_MISSING) && data->bits.httpproxy ) { + if((conn->protocol&PROT_MISSING) && data->change.proxy ) { /* We're guessing prefixes here and since we're told to use a proxy, we need to add the protocol prefix to the URL string before we continue! */ char *reurl; - reurl = aprintf("%s://%s", conn->protostr, data->url); + reurl = aprintf("%s://%s", conn->protostr, data->change.url); if(!reurl) return CURLE_OUT_OF_MEMORY; - data->url = reurl; - if(data->freethis) - free(data->freethis); - data->freethis = reurl; - + data->change.url = reurl; + data->change.url_alloc = TRUE; /* free this later */ conn->protocol &= ~PROT_MISSING; /* switch that one off again */ } @@ -1744,16 +1731,16 @@ static CURLcode Connect(struct UrlData *data, /************************************************************* * Set timeout if that is being used *************************************************************/ - if(data->timeout || data->connecttimeout) { + if(data->set.timeout || data->set.connecttimeout) { /* We set the timeout on the connection/resolving phase first, separately * from the download/upload part to allow a maximum time on everything */ /* myalarm() makes a signal get sent when the timeout fires off, and that will abort system calls */ - if(data->connecttimeout) - myalarm(data->connecttimeout); + if(data->set.connecttimeout) + myalarm(data->set.connecttimeout); else - myalarm(data->timeout); + myalarm(data->set.timeout); } /************************************************************* @@ -1761,7 +1748,7 @@ static CURLcode Connect(struct UrlData *data, *************************************************************/ if (strequal(conn->protostr, "HTTP")) { - conn->port = (data->use_port && allow_port)?data->use_port:PORT_HTTP; + conn->port = (data->set.use_port && allow_port)?data->set.use_port:PORT_HTTP; conn->remote_port = PORT_HTTP; conn->protocol |= PROT_HTTP; conn->curl_do = Curl_http; @@ -1771,7 +1758,7 @@ static CURLcode Connect(struct UrlData *data, else if (strequal(conn->protostr, "HTTPS")) { #ifdef USE_SSLEAY - conn->port = (data->use_port && allow_port)?data->use_port:PORT_HTTPS; + conn->port = (data->set.use_port && allow_port)?data->set.use_port:PORT_HTTPS; conn->remote_port = PORT_HTTPS; conn->protocol |= PROT_HTTP; conn->protocol |= PROT_HTTPS; @@ -1787,7 +1774,7 @@ static CURLcode Connect(struct UrlData *data, #endif /* !USE_SSLEAY */ } else if (strequal(conn->protostr, "GOPHER")) { - conn->port = (data->use_port && allow_port)?data->use_port:PORT_GOPHER; + conn->port = (data->set.use_port && allow_port)?data->set.use_port:PORT_GOPHER; conn->remote_port = PORT_GOPHER; /* Skip // in path if present */ if (isdigit((int)conn->path[1])) { @@ -1813,12 +1800,12 @@ static CURLcode Connect(struct UrlData *data, #endif /* !USE_SSLEAY */ } - conn->port = (data->use_port && allow_port)?data->use_port:PORT_FTP; + conn->port = (data->set.use_port && allow_port)?data->set.use_port:PORT_FTP; conn->remote_port = PORT_FTP; conn->protocol |= PROT_FTP; - if(data->bits.httpproxy && - !data->bits.tunnel_thru_httpproxy) { + if(data->change.proxy && + !data->set.tunnel_thru_httpproxy) { /* Unless we have asked to tunnel ftp operations through the proxy, we switch and use HTTP operations only */ if(conn->protocol & PROT_FTPS) { @@ -1852,15 +1839,15 @@ static CURLcode Connect(struct UrlData *data, command = toupper(type[6]); switch(command) { case 'A': /* ASCII mode */ - data->bits.ftp_ascii = 1; + data->set.ftp_ascii = 1; break; case 'D': /* directory mode */ - data->bits.ftp_list_only = 1; + data->set.ftp_list_only = 1; break; case 'I': /* binary mode */ default: /* switch off ASCII */ - data->bits.ftp_ascii = 0; + data->set.ftp_ascii = 0; break; } } @@ -1869,21 +1856,21 @@ static CURLcode Connect(struct UrlData *data, /* telnet testing factory */ conn->protocol |= PROT_TELNET; - conn->port = (data->use_port && allow_port)?data->use_port: PORT_TELNET; + conn->port = (data->set.use_port && allow_port)?data->set.use_port: PORT_TELNET; conn->remote_port = PORT_TELNET; conn->curl_do = Curl_telnet; conn->curl_done = Curl_telnet_done; } else if (strequal(conn->protostr, "DICT")) { conn->protocol |= PROT_DICT; - conn->port = (data->use_port && allow_port)?data->use_port:PORT_DICT; + conn->port = (data->set.use_port && allow_port)?data->set.use_port:PORT_DICT; conn->remote_port = PORT_DICT; conn->curl_do = Curl_dict; conn->curl_done = NULL; /* no DICT-specific done */ } else if (strequal(conn->protostr, "LDAP")) { conn->protocol |= PROT_LDAP; - conn->port = (data->use_port && allow_port)?data->use_port:PORT_LDAP; + conn->port = (data->set.use_port && allow_port)?data->set.use_port:PORT_LDAP; conn->remote_port = PORT_LDAP; conn->curl_do = Curl_ldap; conn->curl_done = NULL; /* no LDAP-specific done */ @@ -1916,8 +1903,10 @@ static CURLcode Connect(struct UrlData *data, /************************************************************* * .netrc scanning coming up *************************************************************/ - if(data->bits.use_netrc) { - if(Curl_parsenetrc(conn->hostname, data->user, data->passwd)) { + if(data->set.use_netrc) { + if(Curl_parsenetrc(conn->hostname, + data->state.user, + data->state.passwd)) { infof(data, "Couldn't find host %s in the .netrc file, using defaults", conn->hostname); } @@ -1926,10 +1915,10 @@ static CURLcode Connect(struct UrlData *data, /* weather we failed or not, we don't know which fields that were filled in anyway */ - if(!data->user[0]) - strcpy(data->user, CURL_DEFAULT_USER); - if(!data->passwd[0]) - strcpy(data->passwd, CURL_DEFAULT_PASSWORD); + if(!data->state.user[0]) + strcpy(data->state.user, CURL_DEFAULT_USER); + if(!data->state.passwd[0]) + strcpy(data->state.passwd, CURL_DEFAULT_PASSWORD); } else if(!(conn->bits.user_passwd) && (conn->protocol & (PROT_FTP|PROT_HTTP)) ) { @@ -1941,22 +1930,22 @@ static CURLcode Connect(struct UrlData *data, if((ptr=strchr(conn->name, '@'))) { /* there's a user+password given here, to the left of the @ */ - data->user[0] =0; - data->passwd[0]=0; + data->state.user[0] =0; + data->state.passwd[0]=0; if(*conn->name != ':') { /* the name is given, get user+password */ sscanf(conn->name, "%127[^:@]:%127[^@]", - data->user, data->passwd); + data->state.user, data->state.passwd); } else /* no name given, get the password only */ - sscanf(conn->name+1, "%127[^@]", data->passwd); + sscanf(conn->name+1, "%127[^@]", data->state.passwd); - if(data->user[0]) { - char *newname=curl_unescape(data->user, 0); - if(strlen(newname) < sizeof(data->user)) { - strcpy(data->user, newname); + if(data->state.user[0]) { + char *newname=curl_unescape(data->state.user, 0); + if(strlen(newname) < sizeof(data->state.user)) { + strcpy(data->state.user, newname); } /* if the new name is longer than accepted, then just use the unconverted name, it'll be wrong but what the heck */ @@ -1964,17 +1953,18 @@ static CURLcode Connect(struct UrlData *data, } /* check for password, if no ask for one */ - if( !data->passwd[0] ) { - if(!data->fpasswd || - data->fpasswd(data->passwd_client, - "password:",data->passwd,sizeof(data->passwd))) + if( !data->state.passwd[0] ) { + if(!data->set.fpasswd || + data->set.fpasswd(data->set.passwd_client, + "password:", data->state.passwd, + sizeof(data->state.passwd))) return CURLE_BAD_PASSWORD_ENTERED; } else { /* we have a password found in the URL, decode it! */ - char *newpasswd=curl_unescape(data->passwd, 0); - if(strlen(newpasswd) < sizeof(data->passwd)) { - strcpy(data->passwd, newpasswd); + char *newpasswd=curl_unescape(data->state.passwd, 0); + if(strlen(newpasswd) < sizeof(data->state.passwd)) { + strcpy(data->state.passwd, newpasswd); } free(newpasswd); } @@ -1983,8 +1973,8 @@ static CURLcode Connect(struct UrlData *data, conn->bits.user_passwd=TRUE; /* enable user+password */ } else { - strcpy(data->user, CURL_DEFAULT_USER); - strcpy(data->passwd, CURL_DEFAULT_PASSWORD); + strcpy(data->state.user, CURL_DEFAULT_USER); + strcpy(data->state.passwd, CURL_DEFAULT_PASSWORD); } } @@ -2025,7 +2015,7 @@ static CURLcode Connect(struct UrlData *data, conn->remote_port = atoi(tmp); } - if(data->bits.httpproxy) { + if(data->change.proxy) { /* If this is supposed to use a proxy, we need to figure out the proxy host name name, so that we can re-use an existing connection that may exist registered to the same proxy host. */ @@ -2035,7 +2025,7 @@ static CURLcode Connect(struct UrlData *data, /* We need to make a duplicate of the proxy so that we can modify the string safely. */ - char *proxydup=strdup(data->proxy); + char *proxydup=strdup(data->change.proxy); /* We use 'proxyptr' to point to the proxy name from now on... */ char *proxyptr=proxydup; @@ -2064,10 +2054,10 @@ static CURLcode Connect(struct UrlData *data, /* now set the local port number */ conn->port = atoi(prox_portno); } - else if(data->proxyport) { + else if(data->set.proxyport) { /* None given in the proxy string, then get the default one if it is given */ - conn->port = data->proxyport; + conn->port = data->set.proxyport; } /* now, clone the cleaned proxy host name */ @@ -2084,7 +2074,7 @@ static CURLcode Connect(struct UrlData *data, /* reuse_fresh is set TRUE if we are told to use a fresh connection by force */ - if(!data->bits.reuse_fresh && + if(!data->set.reuse_fresh && ConnectionExists(data, conn, &conn_temp)) { /* * We already have a connection for this, we got the former connection @@ -2122,7 +2112,7 @@ static CURLcode Connect(struct UrlData *data, * If we're doing a resumed transfer, we need to setup our stuff * properly. */ - conn->resume_from = data->set_resume_from; + conn->resume_from = data->set.set_resume_from; if (conn->resume_from) { snprintf(resumerange, sizeof(resumerange), "%d-", conn->resume_from); if (conn->bits.rangestringalloc == TRUE) @@ -2133,9 +2123,9 @@ static CURLcode Connect(struct UrlData *data, conn->bits.use_range = TRUE; /* enable range download */ conn->bits.rangestringalloc = TRUE; /* mark range string allocated */ } - else if (data->set_range) { + else if (data->set.set_range) { /* There is a range, but is not a resume, useful for random ftp access */ - conn->range = strdup(data->set_range); + conn->range = strdup(data->set.set_range); conn->bits.rangestringalloc = TRUE; /* mark range string allocated */ conn->bits.use_range = TRUE; /* enable range download */ } @@ -2155,7 +2145,7 @@ static CURLcode Connect(struct UrlData *data, /************************************************************* * Resolve the name of the server or proxy *************************************************************/ - if(!data->bits.httpproxy) { + if(!data->change.proxy) { /* If not connecting via a proxy, extract the port from the URL, if it is * there, thus overriding any defaults that might have been set above. */ conn->port = conn->remote_port; /* it is the same port */ @@ -2199,9 +2189,9 @@ static CURLcode Connect(struct UrlData *data, *************************************************************/ if(conn->bits.proxy_user_passwd) { char *authorization; - snprintf(data->buffer, BUFSIZE, "%s:%s", - data->proxyuser, data->proxypasswd); - if(Curl_base64_encode(data->buffer, strlen(data->buffer), + snprintf(data->state.buffer, BUFSIZE, "%s:%s", + data->state.proxyuser, data->state.proxypasswd); + if(Curl_base64_encode(data->state.buffer, strlen(data->state.buffer), &authorization) >= 0) { if(conn->allocptr.proxyuserpwd) free(conn->allocptr.proxyuserpwd); @@ -2215,12 +2205,12 @@ static CURLcode Connect(struct UrlData *data, * Send user-agent to HTTP proxies even if the target protocol * isn't HTTP. *************************************************************/ - if((conn->protocol&PROT_HTTP) || data->bits.httpproxy) { - if(data->useragent) { + if((conn->protocol&PROT_HTTP) || data->change.proxy) { + if(data->set.useragent) { if(conn->allocptr.uagent) free(conn->allocptr.uagent); conn->allocptr.uagent = - aprintf("User-Agent: %s\015\012", data->useragent); + aprintf("User-Agent: %s\015\012", data->set.useragent); } } @@ -2286,7 +2276,7 @@ static CURLcode Connect(struct UrlData *data, * characters (you get mangled text files, and corrupted binary files when * you download to stdout and redirect it to a file). */ - if ((data->out)->_handle == NULL) { + if ((data->set.out)->_handle == NULL) { _fsetmode(stdout, "b"); } #endif @@ -2294,7 +2284,7 @@ static CURLcode Connect(struct UrlData *data, return CURLE_OK; } -CURLcode Curl_connect(struct UrlData *data, +CURLcode Curl_connect(struct SessionHandle *data, struct connectdata **in_connect, bool allow_port) { @@ -2319,7 +2309,7 @@ CURLcode Curl_connect(struct UrlData *data, CURLcode Curl_done(struct connectdata *conn) { - struct UrlData *data=conn->data; + struct SessionHandle *data=conn->data; CURLcode result; /* cleanups done even if the connection is re-used */ @@ -2343,13 +2333,13 @@ CURLcode Curl_done(struct connectdata *conn) Curl_pgrsDone(conn); /* done with the operation */ - /* if data->bits.reuse_forbid is TRUE, it means the libcurl client has + /* if data->set.reuse_forbid is TRUE, it means the libcurl client has forced us to close this no matter what we think. if conn->bits.close is TRUE, it means that the connection should be closed in spite of all our efforts to be nice, due to protocol restrictions in our or the server's end */ - if(data->bits.reuse_forbid || + if(data->set.reuse_forbid || ((CURLE_OK == result) && conn->bits.close)) result = Curl_disconnect(conn); /* close the connection */ else diff --git a/lib/url.h b/lib/url.h index d710c74c8..c842a97f2 100644 --- a/lib/url.h +++ b/lib/url.h @@ -27,10 +27,10 @@ * Prototypes for library-wide functions provided by url.c */ -CURLcode Curl_open(struct UrlData **curl); -CURLcode Curl_setopt(struct UrlData *data, CURLoption option, ...); -CURLcode Curl_close(struct UrlData *data); /* the opposite of curl_open() */ -CURLcode Curl_connect(struct UrlData *, +CURLcode Curl_open(struct SessionHandle **curl); +CURLcode Curl_setopt(struct SessionHandle *data, CURLoption option, ...); +CURLcode Curl_close(struct SessionHandle *data); /* the opposite of curl_open() */ +CURLcode Curl_connect(struct SessionHandle *, struct connectdata **, bool allow_port); CURLcode Curl_do(struct connectdata *); diff --git a/lib/urldata.h b/lib/urldata.h index 72e288142..b13745ef3 100644 --- a/lib/urldata.h +++ b/lib/urldata.h @@ -195,8 +195,8 @@ struct ConnectBits { bool close; /* if set, we close the connection after this request */ bool reuse; /* if set, this is a re-used connection */ bool chunk; /* if set, this is a chunked transfer-encoding */ - bool httpproxy; /* if set, this transfer is done through a http proxy */ - bool user_passwd; /* do we use user+password for this connection? */ + bool httpproxy; /* if set, this transfer is done through a http proxy */ + bool user_passwd; /* do we use user+password for this connection? */ bool proxy_user_passwd; /* user+password for the proxy? */ bool use_range; @@ -212,7 +212,7 @@ struct ConnectBits { */ struct connectdata { /**** Fields set when inited and not modified again */ - struct UrlData *data; /* link to the root CURL struct */ + struct SessionHandle *data; /* link to the root CURL struct */ int connectindex; /* what index in the connects index this particular struct has */ @@ -348,9 +348,21 @@ struct connectdata { void *generic; } proto; +}; +/* + * Struct to keep statistical and informational data. + */ +struct PureInfo { + int httpcode; + int httpversion; + time_t filetime; /* If requested, this is might get set. It may be 0 if + the time was unretrievable */ + long header_size; /* size of read header(s) in bytes */ + long request_size; /* the amount of bytes sent in the request(s) */ }; + struct Progress { long lastshow; /* time() of the last displayed progress meter or NULL to force redraw at next call */ @@ -368,17 +380,12 @@ struct Progress { double dlspeed; double ulspeed; - struct timeval start; - struct timeval t_startsingle; - /* various data stored for possible later report */ double t_nslookup; double t_connect; double t_pretransfer; - int httpcode; - int httpversion; - time_t filetime; /* If requested, this is might get set. It may be 0 if - the time was unretrievable */ + struct timeval start; + struct timeval t_startsingle; #define CURR_TIME 5 double speeder[ CURR_TIME ]; @@ -395,197 +402,182 @@ typedef enum { HTTPREQ_LAST /* last in list */ } Curl_HttpReq; -/* This struct is for boolean settings that define how to behave during - this session. */ -struct Configbits { - bool get_filetime; - bool tunnel_thru_httpproxy; - bool ftp_append; - bool ftp_ascii; - bool ftp_list_only; - bool ftp_use_port; - bool hide_progress; - bool http_fail_on_error; - bool http_follow_location; - bool http_include_header; - bool http_set_referer; - bool http_auto_referer; /* set "correct" referer when following location: */ - bool httpproxy; - bool no_body; - bool set_port; - bool set_range; - bool upload; - bool use_netrc; - bool verbose; +/* + * Values that are generated, temporary or calculated internally for a + * "session handle" must be defined within the 'struct urlstate'. This struct + * will be used within the SessionHandle struct. When the 'SessionHandle' + * struct is cloned, this data MUST NOT be copied. + * + * Remember that any "state" information goes globally for the curl handle. + * Session-data MUST be put in the connectdata struct and here. */ +#define MAX_CURL_USER_LENGTH 256 +#define MAX_CURL_PASSWORD_LENGTH 256 + +struct UrlState { + /* buffers to store authentication data in, as parsed from input options */ + char user[MAX_CURL_USER_LENGTH]; + char passwd[MAX_CURL_PASSWORD_LENGTH]; + char proxyuser[MAX_CURL_USER_LENGTH]; + char proxypasswd[MAX_CURL_PASSWORD_LENGTH]; + + struct timeval keeps_speed; /* for the progress meter really */ + + /* 'connects' will be an allocated array with pointers. If the pointer is + set, it holds an allocated connection. */ + struct connectdata **connects; + long numconnects; /* size of the 'connects' array */ + + char *headerbuff; /* allocated buffer to store headers in */ + int headersize; /* size of the allocation */ + + char buffer[BUFSIZE+1]; /* buffer with size BUFSIZE */ + + double current_speed; /* the ProgressShow() funcion sets this */ + bool this_is_a_follow; /* this is a followed Location: request */ - bool krb4; /* kerberos4 connection requested */ - bool proxystringalloc; /* the http proxy string is malloc()'ed */ - bool urlstringalloc; /* the URL string is malloc()'ed */ - bool reuse_forbid; /* if this is forbidden to be reused, close - after use */ - bool reuse_fresh; /* do not re-use an existing connection for this - transfer */ - bool expect100header; /* TRUE if we added Expect: 100-continue to the - HTTP header */ + + char *auth_host; /* if set, this should be the host name that we will + sent authorization to, no else. Used to make Location: + following not keep sending user+password... This is + strdup() data. + */ }; + /* - * As of April 11, 2000 we're now trying to split up the urldata struct in - * three different parts: - * - * (Global) - * 1 - No matter how many hosts and requests that are being performed, this - * goes for all of them. - * - * (Session) - * 2 - Host and protocol-specific. No matter if we do several transfers to and - * from this host, these variables stay the same. - * - * (Request) - * 3 - Request-specific. Variables that are of interest for this particular - * transfer being made right now. THIS IS WRONG STRUCT FOR THOSE. - * - * In Febrary 2001, this is being done stricter. The 'connectdata' struct - * MUST have all the connection oriented stuff as we may now have several - * simultaneous connections and connection structs in memory. - * - * From now on, the 'UrlData' must only contain data that is set once to go + * This 'DynamicStatic' struct defines dynamic states that actually change + * values in the 'UserDefined' area, which MUST be taken into consideration + * if the UserDefined struct is cloned or similar. You can probably just + * copy these, but each one indicate a special action on other data. + */ + +struct DynamicStatic { + char *url; /* work URL, copied from UserDefined */ + bool url_alloc; /* URL string is malloc()'ed */ + char *proxy; /* work proxy, copied from UserDefined */ + bool proxy_alloc; /* http proxy string is malloc()'ed */ + char *referer; /* referer string */ + bool referer_alloc; /* referer sting is malloc()ed */ +}; + +/* + * This 'UserDefined' struct must only contain data that is set once to go * for many (perhaps) independent connections. Values that are generated or - * calculated internally MUST NOT be a part of this struct. + * calculated internally for the "session handle" MUST be defined within the + * 'struct urlstate' instead. The only exceptions MUST note the changes in + * the 'DynamicStatic' struct. */ -struct UrlData { - /*************** Global - specific items ************/ +struct UserDefined { FILE *err; /* the stderr writes goes here */ char *errorbuffer; /* store failure messages in here */ - - /*************** Session - specific items ************/ - char *proxy; /* if proxy, set it here */ char *proxyuserpwd; /* Proxy , if used */ long proxyport; /* If non-zero, use this port number by default. If the proxy string features a ":[port]" that one will override - this. */ - - - long header_size; /* size of read header(s) in bytes */ - long request_size; /* the amount of bytes sent in the request(s) */ - + this. */ void *out; /* the fetched file goes here */ void *in; /* the uploaded file is read from here */ void *writeheader; /* write the header to this is non-NULL */ - - char *url; /* what to get */ - char *freethis; /* if non-NULL, an allocated string for the URL */ - long use_port; /* which port to use (when not using default) */ - struct Configbits bits; /* new-style (v7) flag data */ - struct ssl_config_data ssl; /* this is for ssl-stuff */ - - char *userpwd; /* , if used */ - char *set_range; /* range, if used. See README for detailed specification on - this syntax. */ - - /* stuff related to HTTP */ - - long followlocation; - long maxredirs; /* maximum no. of http(s) redirects to follow */ - char *referer; + char *set_url; /* what original URL to work on */ + char *set_proxy; /* proxy to use */ + long use_port; /* which port to use (when not using default) */ + char *userpwd; /* , if used */ + char *set_range; /* range, if used. See README for detailed specification + on this syntax. */ + long followlocation; /* as in HTTP Location: */ + long maxredirs; /* maximum no. of http(s) redirects to follow */ + char *set_referer; /* custom string */ bool free_referer; /* set TRUE if 'referer' points to a string we allocated */ char *useragent; /* User-Agent string */ - char *postfields; /* if POST, set the fields' values here */ + char *postfields; /* if POST, set the fields' values here */ size_t postfieldsize; /* if POST, this might have a size to use instead of strlen(), and then the data *may* be binary (contain zero bytes) */ - - /* stuff related to FTP */ - char *ftpport; /* port to send with the PORT command */ - - /* general things */ - char *device; /* Interface to use */ - - /* function that stores the output:*/ - curl_write_callback fwrite; - - /* optional function that stores the header output:*/ - curl_write_callback fwrite_header; - - /* function that reads the input:*/ - curl_read_callback fread; - - /* function that wants progress information */ - curl_progress_callback fprogress; + char *ftpport; /* port to send with the FTP PORT command */ + char *device; /* network interface to use */ + curl_write_callback fwrite; /* function that stores the output */ + curl_write_callback fwrite_header; /* function that stores headers */ + curl_read_callback fread; /* function that reads the input */ + curl_progress_callback fprogress; /* function for progress information */ void *progress_client; /* pointer to pass to the progress callback */ - - /* function to call instead of the internal for password */ - curl_passwd_callback fpasswd; - void *passwd_client; /* pointer to pass to the passwd callback */ - - long timeout; /* in seconds, 0 means no timeout */ - long connecttimeout; /* in seconds, 0 means no timeout */ - long infilesize; /* size of file to upload, -1 means unknown */ - - char buffer[BUFSIZE+1]; /* buffer with size BUFSIZE */ - - double current_speed; /* the ProgressShow() funcion sets this */ - + curl_passwd_callback fpasswd; /* call for password */ + void *passwd_client; /* pass to the passwd callback */ + long timeout; /* in seconds, 0 means no timeout */ + long connecttimeout; /* in seconds, 0 means no timeout */ + long infilesize; /* size of file to upload, -1 means unknown */ long low_speed_limit; /* bytes/second */ long low_speed_time; /* number of seconds */ - - int set_resume_from; /* continue [ftp] transfer from here */ - - char *cookie; /* HTTP cookie string to send */ - + int set_resume_from; /* continue [ftp] transfer from here */ + char *cookie; /* HTTP cookie string to send */ struct curl_slist *headers; /* linked list of extra headers */ struct HttpPost *httppost; /* linked list of POST data */ - - char *cert; /* PEM-formatted certificate */ - char *cert_passwd; /* plain text certificate password */ - - struct CookieInfo *cookies; - char *cookiejar; /* dump all cookies to this file */ - - long crlf; + char *cert; /* PEM-formatted certificate */ + char *cert_passwd; /* plain text certificate password */ + char *cookiejar; /* dump all cookies to this file */ + bool crlf; /* convert crlf on ftp upload(?) */ struct curl_slist *quote; /* before the transfer */ struct curl_slist *postquote; /* after the transfer */ - - /* Telnet negotiation options */ struct curl_slist *telnet_options; /* linked list of telnet options */ - - TimeCond timecondition; /* kind of comparison */ + TimeCond timecondition; /* kind of time/date comparison */ time_t timevalue; /* what time to compare with */ - - Curl_HttpReq httpreq; /* what kind of HTTP request (if any) is this */ - - char *customrequest; /* http/ftp request to use */ - - char *headerbuff; /* allocated buffer to store headers in */ - int headersize; /* size of the allocation */ - - struct Progress progress; /* for all the progress meter data */ - -#define MAX_CURL_USER_LENGTH 128 -#define MAX_CURL_PASSWORD_LENGTH 128 - + curl_closepolicy closepolicy; /* connection cache close concept */ + Curl_HttpReq httpreq; /* what kind of HTTP request (if any) is this */ + char *customrequest; /* HTTP/FTP request to use */ char *auth_host; /* if set, this is the allocated string to the host name * to which to send the authorization data to, and no other * host (which location-following otherwise could lead to) */ - - /* buffers to store authentication data in */ - char user[MAX_CURL_USER_LENGTH]; - char passwd[MAX_CURL_PASSWORD_LENGTH]; - char proxyuser[MAX_CURL_USER_LENGTH]; - char proxypasswd[MAX_CURL_PASSWORD_LENGTH]; - char *krb4_level; /* what security level */ - struct timeval keeps_speed; /* this should be request-specific */ + struct ssl_config_data ssl; /* user defined SSL stuff */ - /* 'connects' will be an allocated array with pointers. If the pointer is - set, it holds an allocated connection. */ - struct connectdata **connects; - long numconnects; /* size of the 'connects' array */ - curl_closepolicy closepolicy; +/* Here follows boolean settings that define how to behave during + this session. They are STATIC, set by libcurl users or at least initially + and they don't change during operations. */ + + bool get_filetime; + bool tunnel_thru_httpproxy; + bool ftp_append; + bool ftp_ascii; + bool ftp_list_only; + bool ftp_use_port; + bool hide_progress; + bool http_fail_on_error; + bool http_follow_location; + bool http_include_header; + bool http_set_referer; + bool http_auto_referer; /* set "correct" referer when following location: */ + bool no_body; + bool set_port; + bool upload; + bool use_netrc; + bool verbose; + bool krb4; /* kerberos4 connection requested */ + bool reuse_forbid; /* forbidden to be reused, close after use */ + bool reuse_fresh; /* do not re-use an existing connection */ + bool expect100header; /* TRUE if we added Expect: 100-continue */ +}; +/* + * In August 2001, this struct was redesigned and is since stricter than + * before. The 'connectdata' struct MUST have all the connection oriented + * stuff as we may now have several simultaneous connections and connection + * structs in memory. + * + * From now on, the 'SessionHandle' must only contain data that is set once to + * go for many (perhaps) independent connections. Values that are generated or + * calculated internally for the "session handle" must be defined within the + * 'struct urlstate' instead. */ + +struct SessionHandle { + 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 */ + struct Progress progress; /* for all the progress meter data */ + struct UrlState state; /* struct for fields used for state info and + other dynamic purposes */ + struct PureInfo info; /* stats, reports and info data */ }; #define LIBCURL_NAME "libcurl" -- cgit v1.2.3