diff options
Diffstat (limited to 'Source/CTest/Curl/transfer.c')
-rw-r--r-- | Source/CTest/Curl/transfer.c | 1184 |
1 files changed, 844 insertions, 340 deletions
diff --git a/Source/CTest/Curl/transfer.c b/Source/CTest/Curl/transfer.c index ca7731b..93df4c5 100644 --- a/Source/CTest/Curl/transfer.c +++ b/Source/CTest/Curl/transfer.c @@ -1,16 +1,16 @@ /*************************************************************************** - * _ _ ____ _ - * Project ___| | | | _ \| | - * / __| | | | |_) | | - * | (__| |_| | _ <| |___ + * _ _ ____ _ + * Project ___| | | | _ \| | + * / __| | | | |_) | | + * | (__| |_| | _ <| |___ * \___|\___/|_| \_\_____| * - * Copyright (C) 1998 - 2002, Daniel Stenberg, <daniel@haxx.se>, et al. + * Copyright (C) 1998 - 2004, Daniel Stenberg, <daniel@haxx.se>, et al. * * This software is licensed as described in the file COPYING, which * you should have received as part of this distribution. The terms * are also available at http://curl.haxx.se/docs/copyright.html. - * + * * You may opt to use, copy, modify, merge, publish, distribute and/or sell * copies of the Software, and permit persons to whom the Software is * furnished to do so, under the terms of the COPYING file. @@ -29,24 +29,27 @@ #include <stdarg.h> #include <stdlib.h> #include <ctype.h> +#ifdef HAVE_SYS_TYPES_H #include <sys/types.h> +#endif #include <sys/stat.h> #include <errno.h> +#include "strtoofft.h" #include "strequal.h" #if defined(WIN32) && !defined(__GNUC__) || defined(__MINGW32__) -#include <winsock.h> #include <time.h> #include <io.h> #else #ifdef HAVE_SYS_SOCKET_H #include <sys/socket.h> #endif +#ifdef HAVE_NETINET_IN_H #include <netinet/in.h> +#endif #include <sys/time.h> -#include <sys/resource.h> #ifdef HAVE_UNISTD_H #include <unistd.h> #endif @@ -57,7 +60,9 @@ #ifdef HAVE_NET_IF_H #include <net/if.h> #endif +#ifdef HAVE_SYS_IOCTL_H #include <sys/ioctl.h> +#endif #include <signal.h> #ifdef HAVE_SYS_PARAM_H @@ -79,34 +84,32 @@ #include "urldata.h" #include <curl/curl.h> -#include <curl/types.h> #include "netrc.h" -#include "content_encoding.h" /* content encoding support. 08/27/02 jhrg */ - +#include "content_encoding.h" #include "hostip.h" #include "transfer.h" #include "sendf.h" #include "speedcheck.h" -#include "getpass.h" #include "progress.h" #include "getdate.h" #include "http.h" #include "url.h" #include "getinfo.h" #include "ssluse.h" +#include "http_digest.h" +#include "http_ntlm.h" +#include "http_negotiate.h" +#include "share.h" +#include "memory.h" #define _MPRINTF_REPLACE /* use our functions only */ #include <curl/mprintf.h> /* The last #include file should be: */ -#ifdef MALLOCDEBUG #include "memdebug.h" -#endif -#ifndef min -#define min(a, b) ((a) < (b) ? (a) : (b)) -#endif +#define CURL_TIMEOUT_EXPECT_100 1000 /* counting ms here */ enum { KEEP_NONE, @@ -122,10 +125,10 @@ static struct timeval notimeout={0,0}; * This function will call the read callback to fill our buffer with data * to upload. */ -static int fillbuffer(struct connectdata *conn, - int bytes) +CURLcode Curl_fillreadbuffer(struct connectdata *conn, int bytes, int *nreadp) { - int buffersize = bytes; + struct SessionHandle *data = conn->data; + size_t buffersize = (size_t)bytes; int nread; if(conn->bits.upload_chunky) { @@ -133,10 +136,17 @@ static int fillbuffer(struct connectdata *conn, buffersize -= (8 + 2 + 2); /* 32bit hex + CRLF + CRLF */ conn->upload_fromhere += 10; /* 32bit hex + CRLF */ } - + + /* this function returns a size_t, so we typecast to int to prevent warnings + with picky compilers */ nread = (int)conn->fread(conn->upload_fromhere, 1, buffersize, conn->fread_in); - + + if(nread == CURL_READFUNC_ABORT) { + failf(data, "operation aborted by callback\n"); + return CURLE_ABORTED_BY_CALLBACK; + } + if(!conn->bits.forbidchunk && conn->bits.upload_chunky) { /* if chunked Transfer-Encoding */ char hexbuffer[11]; @@ -148,18 +158,21 @@ static int fillbuffer(struct connectdata *conn, /* copy the prefix to the buffer */ memcpy(conn->upload_fromhere, hexbuffer, hexlen); - if(nread>hexlen) { - /* append CRLF to the data */ - memcpy(conn->upload_fromhere + - nread, "\r\n", 2); - nread+=2; - } - else { + + /* always append CRLF to the data */ + memcpy(conn->upload_fromhere + nread, "\r\n", 2); + + if((nread - hexlen) == 0) { /* mark this as done once this chunk is transfered */ conn->keep.upload_done = TRUE; } + + nread+=2; /* for the added CRLF */ } - return nread; + + *nreadp = nread; + + return CURLE_OK; } /* @@ -185,15 +198,20 @@ checkhttpprefix(struct SessionHandle *data, return FALSE; } + +/* + * Curl_readwrite() is the low-level function to be called when data is to + * be read and written to/from the connection. + */ CURLcode Curl_readwrite(struct connectdata *conn, bool *done) { struct Curl_transfer_keeper *k = &conn->keep; struct SessionHandle *data = conn->data; - int result; + CURLcode result; ssize_t nread; /* number of bytes read */ int didwhat=0; - + /* These two are used only if no other select() or _fdset() have been invoked before this. This typicly happens if you use the multi interface and call curl_multi_perform() without calling curl_multi_fdset() @@ -203,7 +221,8 @@ CURLcode Curl_readwrite(struct connectdata *conn, fd_set *readfdp = k->readfdp; fd_set *writefdp = k->writefdp; - + curl_off_t contentlength; + if((k->keepon & KEEP_READ) && !readfdp) { /* reading is requested, but no socket descriptor pointer was set */ FD_ZERO(&extrareadfd); @@ -225,31 +244,39 @@ CURLcode Curl_readwrite(struct connectdata *conn, do { /* If we still have reading to do, we check if we have a readable - socket. Sometimes the reafdp is NULL, it no fd_set was done using + socket. Sometimes the reafdp is NULL, if no fd_set was done using the multi interface and then we can do nothing but to attempt a read to be sure. */ if((k->keepon & KEEP_READ) && - (FD_ISSET(conn->sockfd, readfdp))) { + (!readfdp || FD_ISSET(conn->sockfd, readfdp))) { - bool readdone = FALSE; + bool readdone = TRUE; /* This is where we loop until we have read everything there is to read or we get a EWOULDBLOCK */ do { + size_t buffersize = data->set.buffer_size? + data->set.buffer_size:BUFSIZE -1; - /* read! */ - result = Curl_read(conn, conn->sockfd, k->buf, - data->set.buffer_size? - data->set.buffer_size:BUFSIZE -1, - &nread); + /* receive data from the network! */ + int readrc = Curl_read(conn, conn->sockfd, k->buf, buffersize, &nread); - if(0>result) + /* subzero, this would've blocked */ + if(0>readrc) break; /* get out of loop */ + + /* get the CURLcode from the int */ + result = (CURLcode)readrc; + if(result>0) - return (CURLcode)result; + return result; - if ((k->bytecount == 0) && (k->writebytecount == 0)) + if ((k->bytecount == 0) && (k->writebytecount == 0)) { Curl_pgrsTime(data, TIMER_STARTTRANSFER); + if(k->wait100_after_headers) + /* set time stamp to compare with when waiting for the 100 */ + k->start100 = Curl_tvnow(); + } didwhat |= KEEP_READ; @@ -271,20 +298,23 @@ CURLcode Curl_readwrite(struct connectdata *conn, k->str = k->buf; /* Since this is a two-state thing, we check if we are parsing - headers at the moment or not. */ + headers at the moment or not. */ if (k->header) { /* we are in parse-the-header-mode */ bool stop_reading = FALSE; /* header line within buffer loop */ do { - int hbufp_index; - + size_t hbufp_index; + size_t rest_length; + size_t full_length; + int writetype; + /* str_start is start of line within buf */ k->str_start = k->str; - + k->end_ptr = strchr (k->str_start, '\n'); - + if (!k->end_ptr) { /* Not a complete header line within buffer, append the data to the end of the headerbuff. */ @@ -292,9 +322,9 @@ CURLcode Curl_readwrite(struct connectdata *conn, if (k->hbuflen + nread >= data->state.headersize) { /* We enlarge the header buffer as it is too small */ char *newbuff; - long newsize=MAX((k->hbuflen+nread)*3/2, - data->state.headersize*2); - hbufp_index = (int)(k->hbufp - data->state.headerbuff); + size_t newsize=CURLMAX((k->hbuflen+nread)*3/2, + data->state.headersize*2); + hbufp_index = k->hbufp - data->state.headerbuff; newbuff = (char *)realloc(data->state.headerbuff, newsize); if(!newbuff) { failf (data, "Failed to alloc memory for big header!"); @@ -317,27 +347,29 @@ CURLcode Curl_readwrite(struct connectdata *conn, } } - break; /* read more and try again */ + break; /* read more and try again */ } - /* decrease the size of the remaining buffer */ - nread -= (int)((k->end_ptr - k->str)+1); + /* decrease the size of the remaining (supposed) header line */ + rest_length = (k->end_ptr - k->str)+1; + nread -= rest_length; k->str = k->end_ptr + 1; /* move past new line */ + full_length = k->str - k->str_start; + /* * We're about to copy a chunk of data to the end of the * already received header. We make sure that the full string - * fit in the allocated header buffer, or else we enlarge + * fit in the allocated header buffer, or else we enlarge * it. */ - if (k->hbuflen + (k->str - k->str_start) >= + if (k->hbuflen + full_length >= data->state.headersize) { char *newbuff; - long newsize=(long)MAX((k->hbuflen+ - (k->str-k->str_start))*3/2, - data->state.headersize*2); - hbufp_index = (int)(k->hbufp - data->state.headerbuff); + size_t newsize=CURLMAX((k->hbuflen+full_length)*3/2, + data->state.headersize*2); + hbufp_index = k->hbufp - data->state.headerbuff; newbuff = (char *)realloc(data->state.headerbuff, newsize); if(!newbuff) { failf (data, "Failed to alloc memory for big header!"); @@ -349,13 +381,14 @@ CURLcode Curl_readwrite(struct connectdata *conn, } /* copy to end of line */ - strncpy (k->hbufp, k->str_start, k->str - k->str_start); - k->hbufp += k->str - k->str_start; - k->hbuflen += (int)(k->str - k->str_start); + strncpy (k->hbufp, k->str_start, full_length); + k->hbufp += full_length; + k->hbuflen += full_length; *k->hbufp = 0; - + k->end_ptr = k->hbufp; + k->p = data->state.headerbuff; - + /**** * We now have a FULL header line that p points to *****/ @@ -366,13 +399,20 @@ CURLcode Curl_readwrite(struct connectdata *conn, !checkhttpprefix(data, data->state.headerbuff)) { /* this is not the beginning of a HTTP first header line */ k->header = FALSE; - k->badheader = HEADER_PARTHEADER; + if(nread) + /* since there's more, this is a partial bad header */ + k->badheader = HEADER_PARTHEADER; + else { + /* this was all we read so its all a bad header */ + k->badheader = HEADER_ALLBAD; + nread = (ssize_t)rest_length; + } break; } } if (('\n' == *k->p) || ('\r' == *k->p)) { - int headerlen; + size_t headerlen; /* Zero-length header line means end of headers! */ if ('\r' == *k->p) @@ -382,9 +422,9 @@ CURLcode Curl_readwrite(struct connectdata *conn, if(100 == k->httpcode) { /* - * we have made a HTTP PUT or POST and this is 1.1-lingo + * We have made a HTTP PUT or POST and this is 1.1-lingo * that tells us that the server is OK with this and ready - * to receive our stuff. + * to receive the data. * However, we'll get more headers now so we must get * back into the header-parsing state! */ @@ -414,23 +454,66 @@ CURLcode Curl_readwrite(struct connectdata *conn, FD_ZERO(&k->wkeepfd); } +#ifndef CURL_DISABLE_HTTP + /* + * When all the headers have been parsed, see if we should give + * up and return an error. + */ + if (Curl_http_should_fail(conn)) { + failf (data, "The requested URL returned error: %d", + k->httpcode); + return CURLE_HTTP_RETURNED_ERROR; + } +#endif /* CURL_DISABLE_HTTP */ + /* now, only output this if the header AND body are requested: */ - k->writetype = CLIENTWRITE_HEADER; - if (data->set.http_include_header) - k->writetype |= CLIENTWRITE_BODY; + writetype = CLIENTWRITE_HEADER; + if (data->set.include_header) + writetype |= CLIENTWRITE_BODY; - headerlen = (int)(k->p - data->state.headerbuff); + headerlen = k->p - data->state.headerbuff; - result = Curl_client_write(data, k->writetype, + result = Curl_client_write(data, writetype, data->state.headerbuff, headerlen); if(result) - return (CURLcode)result; + return result; data->info.header_size += headerlen; conn->headerbytecount += headerlen; + conn->deductheadercount = + (100 == k->httpcode)?conn->headerbytecount:0; + + if (conn->resume_from && + !k->content_range && + (data->set.httpreq==HTTPREQ_GET)) { + if(k->httpcode == 416) { + /* "Requested Range Not Satisfiable" */ + stop_reading = TRUE; + } + else { + /* 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) */ + failf (data, "HTTP server doesn't seem to support " + "byte ranges. Cannot resume."); + return CURLE_HTTP_RANGE_ERROR; + } + } +#ifndef CURL_DISABLE_HTTP + if(!stop_reading) { + /* Curl_http_auth_act() checks what authentication methods + * that are available and decides which one (if any) to + * use. It will set 'newurl' if an auth metod was picked. */ + result = Curl_http_auth_act(conn); + + if(result) + return result; + } +#endif /* CURL_DISABLE_HTTP */ + if(!k->header) { /* * really end-of-headers. @@ -438,21 +521,39 @@ CURLcode Curl_readwrite(struct connectdata *conn, * If we requested a "no body", this is a good time to get * out and return home. */ - if(data->set.no_body) + if(conn->bits.no_body) stop_reading = TRUE; - else if(!conn->bits.close) { - /* If this is not the last request before a close, we must - set the maximum download size to the size of the - expected document or else, we won't know when to stop - reading! */ - if(-1 != conn->size) - conn->maxdownload = conn->size; + else { + /* If we know the expected size of this document, we set the + maximum download size to the size of the expected + document or else, we won't know when to stop reading! + + Note that we set the download maximum even if we read a + "Connection: close" header, to make sure that + "Content-Length: 0" still prevents us from attempting to + read the (missing) response-body. + */ + /* According to RFC2616 section 4.4, we MUST ignore + Content-Length: headers if we are now receiving data + using chunked Transfer-Encoding. + */ + if(conn->bits.chunk) + conn->size=-1; + + } + if(-1 != conn->size) { + /* We do this operation even if no_body is true, since this + data might be retrieved later with curl_easy_getinfo() + and its CURLINFO_CONTENT_LENGTH_DOWNLOAD option. */ + + Curl_pgrsSetDownloadSize(data, conn->size); + conn->maxdownload = conn->size; } /* If max download size is *zero* (nothing) we already have nothing and can safely return ok now! */ if(0 == conn->maxdownload) stop_reading = TRUE; - + if(stop_reading) { /* we make sure that this socket isn't read more now */ k->keepon &= ~KEEP_READ; @@ -472,15 +573,15 @@ CURLcode Curl_readwrite(struct connectdata *conn, /* * Checks for special headers coming up. */ - + if (!k->headerline++) { /* This is the first header, it MUST be the error code line or else we consiser this to be the body right away! */ int httpversion_major; - int nc=sscanf (k->p, " HTTP/%d.%d %3d", - &httpversion_major, - &k->httpversion, - &k->httpcode); + int nc=sscanf(k->p, " HTTP/%d.%d %3d", + &httpversion_major, + &k->httpversion, + &k->httpcode); if (nc==3) { k->httpversion += 10 * httpversion_major; } @@ -488,9 +589,9 @@ CURLcode Curl_readwrite(struct connectdata *conn, /* this is the real world, not a Nirvana NCSA 1.5.x returns this crap when asked for HTTP/1.1 */ - nc=sscanf (k->p, " HTTP %3d", &k->httpcode); + nc=sscanf(k->p, " HTTP %3d", &k->httpcode); k->httpversion = 10; - + /* If user has set option HTTP200ALIASES, compare header line against list of aliases */ @@ -508,13 +609,21 @@ CURLcode Curl_readwrite(struct connectdata *conn, data->info.httpcode = k->httpcode; data->info.httpversion = k->httpversion; - /* 404 -> URL not found! */ + /* + * This code executes as part of processing the header. As a + * result, it's not totally clear how to interpret the + * response code yet as that depends on what other headers may + * be present. 401 and 407 may be errors, but may be OK + * depending on how authentication is working. Other codes + * are definitely errors, so give up here. + */ if (data->set.http_fail_on_error && - (k->httpcode >= 400)) { - /* If we have been told to fail hard on HTTP-errors, - here is the check for that: */ + (k->httpcode >= 400) && + (k->httpcode != 401) && + (k->httpcode != 407)) { /* serious error, go home! */ - failf (data, "The requested file was not found"); + failf (data, "The requested URL returned error: %d", + k->httpcode); return CURLE_HTTP_RETURNED_ERROR; } @@ -532,10 +641,14 @@ CURLcode Curl_readwrite(struct connectdata *conn, * message-body, and thus is always terminated by the first * empty line after the header fields. */ /* FALLTHROUGH */ + case 416: /* Requested Range Not Satisfiable, it has the + Content-Length: set as the "real" document but no + actual response is sent. */ case 304: - /* (quote from RFC2616, section 10.3.5): The 304 response MUST - * NOT contain a message-body, and thus is always terminated - * by the first empty line after the header fields. */ + /* (quote from RFC2616, section 10.3.5): The 304 response + * MUST NOT contain a message-body, and thus is always + * terminated by the first empty line after the header + * fields. */ conn->size=0; conn->maxdownload=0; break; @@ -550,37 +663,64 @@ CURLcode Curl_readwrite(struct connectdata *conn, } } - /* check for Content-Length: header lines to get size */ - if (checkprefix("Content-Length:", k->p) && - sscanf (k->p+15, " %ld", &k->contentlength)) { - conn->size = k->contentlength; - Curl_pgrsSetDownloadSize(data, k->contentlength); + /* Check for Content-Length: header lines to get size. Ignore + the header completely if we get a 416 response as then we're + resuming a document that we don't get, and this header contains + info about the true size of the document we didn't get now. */ + if ((k->httpcode != 416) && + checkprefix("Content-Length:", k->p)) { + contentlength = curlx_strtoofft(k->p+15, NULL, 10); + if (data->set.max_filesize && + contentlength > data->set.max_filesize) { + failf(data, "Maximum file size exceeded"); + return CURLE_FILESIZE_EXCEEDED; + } + if(contentlength >= 0) + conn->size = contentlength; + else { + /* Negative Content-Length is really odd, and we know it + happens for example when older Apache servers send large + files */ + conn->bits.close = TRUE; + infof(data, "Negative content-length: %" FORMAT_OFF_T + ", closing after transfer\n", contentlength); + } } /* check for Content-Type: header lines to get the mime-type */ else if (checkprefix("Content-Type:", k->p)) { char *start; char *end; - int len; - + size_t len; + /* Find the first non-space letter */ - for(start=k->p+14; + for(start=k->p+13; *start && isspace((int)*start); start++); - /* count all non-space letters following */ - for(end=start, len=0; - *end && !isspace((int)*end); - end++, len++); + end = strchr(start, '\r'); + if(!end) + end = strchr(start, '\n'); - /* allocate memory of a cloned copy */ - data->info.contenttype = malloc(len + 1); - if (NULL == data->info.contenttype) - return CURLE_OUT_OF_MEMORY; + if(end) { + /* skip all trailing space letters */ + for(; isspace((int)*end) && (end > start); end--); - /* copy the content-type string */ - memcpy(data->info.contenttype, start, len); - data->info.contenttype[len] = 0; /* zero terminate */ + /* get length of the type */ + len = end-start+1; + + /* allocate memory of a cloned copy */ + Curl_safefree(data->info.contenttype); + + data->info.contenttype = malloc(len + 1); + if (NULL == data->info.contenttype) + return CURLE_OUT_OF_MEMORY; + + /* copy the content-type string */ + memcpy(data->info.contenttype, start, len); + data->info.contenttype[len] = 0; /* zero terminate */ + } } +#ifndef CURL_DISABLE_HTTP else if((k->httpversion == 10) && conn->bits.httpproxy && Curl_compareheader(k->p, @@ -632,12 +772,12 @@ CURLcode Curl_readwrite(struct connectdata *conn, else if (checkprefix("Content-Encoding:", k->p) && data->set.encoding) { /* - * Process Content-Encoding. Look for the values: identity, gzip, - * defalte, compress, x-gzip and x-compress. x-gzip and + * Process Content-Encoding. Look for the values: identity, + * gzip, deflate, compress, x-gzip and x-compress. x-gzip and * x-compress are the same as gzip and compress. (Sec 3.5 RFC - * 2616). zlib cannot handle compress, and gzip is not currently - * implemented. However, errors are handled further down when the - * response body is processed 08/27/02 jhrg */ + * 2616). zlib cannot handle compress. However, errors are + * handled further down when the response body is processed + */ char *start; /* Find the first non-space letter */ @@ -645,33 +785,51 @@ CURLcode Curl_readwrite(struct connectdata *conn, *start && isspace((int)*start); start++); - /* Record the content-encoding for later use. 08/27/02 jhrg */ + /* Record the content-encoding for later use */ if (checkprefix("identity", start)) k->content_encoding = IDENTITY; else if (checkprefix("deflate", start)) k->content_encoding = DEFLATE; - else if (checkprefix("gzip", start) + else if (checkprefix("gzip", start) || checkprefix("x-gzip", start)) k->content_encoding = GZIP; - else if (checkprefix("compress", start) + else if (checkprefix("compress", start) || checkprefix("x-compress", start)) k->content_encoding = COMPRESS; } - else if (checkprefix("Content-Range:", k->p)) { - if (sscanf (k->p+14, " bytes %d-", &k->offset) || - sscanf (k->p+14, " bytes: %d-", &k->offset)) { - /* This second format was added August 1st 2000 by Igor - Khristophorov since Sun's webserver JavaWebServer/1.1.1 - obviously sends the header this way! :-( */ - if (conn->resume_from == k->offset) { - /* we asked for a resume and we got it */ - k->content_range = TRUE; - } - } + else if (Curl_compareheader(k->p, "Content-Range:", "bytes")) { + /* Content-Range: bytes [num]- + Content-Range: bytes: [num]- + + The second format was added August 1st 2000 by Igor + Khristophorov since Sun's webserver JavaWebServer/1.1.1 + obviously sends the header this way! :-( */ + + char *ptr = strstr(k->p, "bytes"); + ptr+=5; + + if(*ptr == ':') + /* stupid colon skip */ + ptr++; + + k->offset = curlx_strtoofft(ptr, NULL, 10); + + if (conn->resume_from == k->offset) + /* we asked for a resume and we got it */ + k->content_range = TRUE; } else if(data->cookies && checkprefix("Set-Cookie:", k->p)) { - Curl_cookie_add(data->cookies, TRUE, k->p+11, conn->name); + Curl_share_lock(data, CURL_LOCK_DATA_COOKIE, + CURL_LOCK_ACCESS_SINGLE); + Curl_cookie_add(data, + data->cookies, TRUE, k->p+11, + /* If there is a custom-set Host: name, use it + here, or else use real peer host name. */ + conn->allocptr.cookiehost? + conn->allocptr.cookiehost:conn->host.name, + conn->path); + Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE); } else if(checkprefix("Last-Modified:", k->p) && (data->set.timecondition || data->set.get_filetime) ) { @@ -681,53 +839,70 @@ CURLcode Curl_readwrite(struct connectdata *conn, if(data->set.get_filetime) data->info.filetime = k->timeofdoc; } + else if((checkprefix("WWW-Authenticate:", k->p) && + (401 == k->httpcode)) || + (checkprefix("Proxy-authenticate:", k->p) && + (407 == k->httpcode))) { + result = Curl_http_input_auth(conn, k->httpcode, k->p); + if(result) + return result; + } else if ((k->httpcode >= 300 && k->httpcode < 400) && - (data->set.http_follow_location) && checkprefix("Location:", k->p)) { - /* this is the URL that the server advices us to get instead */ - char *ptr; - char *start=k->p; - char backup; - - start += 9; /* pass "Location:" */ - - /* Skip spaces and tabs. We do this to support multiple - white spaces after the "Location:" keyword. */ - while(*start && isspace((int)*start )) - start++; - ptr = start; /* start scanning here */ - - /* scan through the string to find the end */ - while(*ptr && !isspace((int)*ptr)) + if(data->set.http_follow_location) { + /* this is the URL that the server advices us to get instead */ + char *ptr; + char *start=k->p; + char backup; + + start += 9; /* pass "Location:" */ + + /* Skip spaces and tabs. We do this to support multiple + white spaces after the "Location:" keyword. */ + while(*start && isspace((int)*start )) + start++; + + /* Scan through the string from the end to find the last + non-space. k->end_ptr points to the actual terminating zero + letter, move pointer one letter back and start from + there. This logic strips off trailing whitespace, but keeps + any embedded whitespace. */ + ptr = k->end_ptr-1; + while((ptr>=start) && isspace((int)*ptr)) + ptr--; ptr++; - backup = *ptr; /* store the ending letter */ - if(ptr != start) { - *ptr = '\0'; /* zero terminate */ - conn->newurl = strdup(start); /* clone string */ - *ptr = backup; /* restore ending letter */ + + backup = *ptr; /* store the ending letter */ + if(ptr != start) { + *ptr = '\0'; /* zero terminate */ + conn->newurl = strdup(start); /* clone string */ + *ptr = backup; /* restore ending letter */ + if(!conn->newurl) + return CURLE_OUT_OF_MEMORY; + } } } +#endif /* CURL_DISABLE_HTTP */ /* * End of header-checks. Write them to the client. */ - k->writetype = CLIENTWRITE_HEADER; - if (data->set.http_include_header) - k->writetype |= CLIENTWRITE_BODY; + writetype = CLIENTWRITE_HEADER; + if (data->set.include_header) + writetype |= CLIENTWRITE_BODY; if(data->set.verbose) Curl_debug(data, CURLINFO_HEADER_IN, - k->p, k->hbuflen); + k->p, k->hbuflen, conn->host.dispname); - result = Curl_client_write(data, k->writetype, k->p, - k->hbuflen); + result = Curl_client_write(data, writetype, k->p, k->hbuflen); if(result) - return (CURLcode)result; + return result; data->info.header_size += k->hbuflen; conn->headerbytecount += k->hbuflen; - + /* reset hbufp pointer && hbuflen */ k->hbufp = data->state.headerbuff; k->hbuflen = 0; @@ -748,38 +923,36 @@ CURLcode Curl_readwrite(struct connectdata *conn, parsing, where the beginning of the buffer is headers and the end is non-headers. */ if (k->str && !k->header && (nread > 0)) { - + if(0 == k->bodywrites) { /* These checks are only made the first time we are about to write a piece of the body */ if(conn->protocol&PROT_HTTP) { /* HTTP-only checks */ + if (conn->newurl) { - /* abort after the headers if "follow Location" is set */ - infof (data, "Follow to new URL: %s\n", conn->newurl); - k->keepon &= ~KEEP_READ; - FD_ZERO(&k->rkeepfd); - *done = TRUE; - return CURLE_OK; - } - else if (conn->resume_from && - !k->content_range && - (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) */ - failf (data, "HTTP server doesn't seem to support " - "byte ranges. Cannot resume."); - return CURLE_HTTP_RANGE_ERROR; + if(conn->bits.close) { + /* Abort after the headers if "follow Location" is set + and we're set to close anyway. */ + k->keepon &= ~KEEP_READ; + FD_ZERO(&k->rkeepfd); + *done = TRUE; + return CURLE_OK; + } + /* We have a new url to load, but since we want to be able + to re-use this connection properly, we read the full + response in "ignore more" */ + k->ignorebody = TRUE; + infof(data, "Ignoring the response-body\n"); } - else if(data->set.timecondition && !conn->range) { + 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((k->timeofdoc > 0) && (data->set.timevalue > 0)) { switch(data->set.timecondition) { - case TIMECOND_IFMODSINCE: + case CURL_TIMECOND_IFMODSINCE: default: if(k->timeofdoc < data->set.timevalue) { infof(data, @@ -788,7 +961,7 @@ CURLcode Curl_readwrite(struct connectdata *conn, return CURLE_OK; } break; - case TIMECOND_IFUNMODSINCE: + case CURL_TIMECOND_IFUNMODSINCE: if(k->timeofdoc > data->set.timevalue) { infof(data, "The requested document is not old enough\n"); @@ -808,14 +981,17 @@ CURLcode Curl_readwrite(struct connectdata *conn, if(data->set.verbose) { if(k->badheader) { Curl_debug(data, CURLINFO_DATA_IN, data->state.headerbuff, - k->hbuflen); + k->hbuflen, conn->host.dispname); if(k->badheader == HEADER_PARTHEADER) - Curl_debug(data, CURLINFO_DATA_IN, k->str, nread); + Curl_debug(data, CURLINFO_DATA_IN, k->str, nread, + conn->host.dispname); } else - Curl_debug(data, CURLINFO_DATA_IN, k->str, nread); + Curl_debug(data, CURLINFO_DATA_IN, k->str, nread, + conn->host.dispname); } +#ifndef CURL_DISABLE_HTTP if(conn->bits.chunk) { /* * Bless me father for I have sinned. Here comes a chunked @@ -831,7 +1007,7 @@ CURLcode Curl_readwrite(struct connectdata *conn, failf(data, "Failed writing data"); return CURLE_WRITE_ERROR; } - failf(data, "Received problem in the chunky parser"); + failf(data, "Received problem %d in the chunky parser", res); return CURLE_RECV_ERROR; } else if(CHUNKE_STOP == res) { @@ -845,10 +1021,11 @@ CURLcode Curl_readwrite(struct connectdata *conn, } /* If it returned OK, we just keep going */ } +#endif /* CURL_DISABLE_HTTP */ if((-1 != conn->maxdownload) && (k->bytecount + nread >= conn->maxdownload)) { - nread = conn->maxdownload - k->bytecount; + nread = (ssize_t) (conn->maxdownload - k->bytecount); if(nread < 0 ) /* this should be unusual */ nread = 0; @@ -858,12 +1035,12 @@ CURLcode Curl_readwrite(struct connectdata *conn, k->bytecount += nread; - Curl_pgrsSetDownloadCounter(data, (double)k->bytecount); - + Curl_pgrsSetDownloadCounter(data, k->bytecount); + if(!conn->bits.chunk && (nread || k->badheader)) { /* If this is chunky transfer, it was already written */ - if(k->badheader) { + if(k->badheader && !k->ignorebody) { /* we parsed a piece of data wrongly assuming it was a header and now we output it as body instead */ result = Curl_client_write(data, CLIENTWRITE_BODY, @@ -873,30 +1050,36 @@ CURLcode Curl_readwrite(struct connectdata *conn, if(k->badheader < HEADER_ALLBAD) { /* This switch handles various content encodings. If there's an error here, be sure to check over the almost identical code - in http_chunk.c. 08/29/02 jhrg */ + in http_chunks.c. + Make sure that ALL_CONTENT_ENCODINGS contains all the + encodings handled here. */ #ifdef HAVE_LIBZ switch (k->content_encoding) { case IDENTITY: #endif /* This is the default when the server sends no Content-Encoding header. See Curl_readwrite_init; the - memset() call initializes k->content_encoding to zero. - 08/28/02 jhrg */ - result = Curl_client_write(data, CLIENTWRITE_BODY, k->str, - nread); + memset() call initializes k->content_encoding to zero. */ + if(!k->ignorebody) + result = Curl_client_write(data, CLIENTWRITE_BODY, k->str, + nread); #ifdef HAVE_LIBZ break; - case DEFLATE: + case DEFLATE: /* Assume CLIENTWRITE_BODY; headers are not encoded. */ result = Curl_unencode_deflate_write(data, k, nread); break; - case GZIP: /* FIXME 08/27/02 jhrg */ + case GZIP: + /* Assume CLIENTWRITE_BODY; headers are not encoded. */ + result = Curl_unencode_gzip_write(data, k, nread); + break; + case COMPRESS: default: failf (data, "Unrecognized content encoding type. " - "libcurl understands `identity' and `deflate' " + "libcurl understands `identity', `deflate' and `gzip' " "content encodings."); result = CURLE_BAD_CONTENT_ENCODING; break; @@ -906,7 +1089,7 @@ CURLcode Curl_readwrite(struct connectdata *conn, k->badheader = HEADER_NORMAL; /* taken care of now */ if(result) - return (CURLcode)result; + return result; } } /* if (! header and data to read ) */ @@ -916,16 +1099,16 @@ CURLcode Curl_readwrite(struct connectdata *conn, } /* if( read from socket ) */ /* If we still have writing to do, we check if we have a writable - socket. Sometimes the writefdp is NULL, it no fd_set was done using + socket. Sometimes the writefdp is NULL, if no fd_set was done using the multi interface and then we can do nothing but to attempt a write to be sure. */ if((k->keepon & KEEP_WRITE) && - (FD_ISSET(conn->writesockfd, writefdp)) ) { + (!writefdp || FD_ISSET(conn->writesockfd, writefdp)) ) { /* write */ int i, si; ssize_t bytes_written; - bool writedone=FALSE; + bool writedone=TRUE; if ((k->bytecount == 0) && (k->writebytecount == 0)) Curl_pgrsTime(data, TIMER_STARTTRANSFER); @@ -937,15 +1120,39 @@ CURLcode Curl_readwrite(struct connectdata *conn, * data to send or until we get EWOULDBLOCK back */ do { - + /* only read more data if there's no upload data already present in the upload buffer */ if(0 == conn->upload_present) { /* init the "upload from here" pointer */ conn->upload_fromhere = k->uploadbuf; - if(!k->upload_done) - nread = fillbuffer(conn, BUFSIZE); + if(!k->upload_done) { + /* HTTP pollution, this should be written nicer to become more + protocol agnostic. */ + int fillcount; + + if(k->wait100_after_headers && + (conn->proto.http->sending == HTTPSEND_BODY)) { + /* If this call is to send body data, we must take some action: + We have sent off the full HTTP 1.1 request, and we shall now + go into the Expect: 100 state and await such a header */ + k->wait100_after_headers = FALSE; /* headers sent */ + k->write_after_100_header = TRUE; /* wait for the header */ + FD_ZERO (&k->writefd); /* clear it */ + k->wkeepfd = k->writefd; /* set the keeper variable */ + k->keepon &= ~KEEP_WRITE; /* disable writing */ + k->start100 = Curl_tvnow(); /* timeout count starts now */ + didwhat &= ~KEEP_WRITE; /* we didn't write anything actually */ + break; + } + + result = Curl_fillreadbuffer(conn, BUFSIZE, &fillcount); + if(result) + return result; + + nread = (ssize_t)fillcount; + } else nread = 0; /* we're done uploading/reading */ @@ -964,6 +1171,12 @@ CURLcode Curl_readwrite(struct connectdata *conn, /* convert LF to CRLF if so asked */ if (data->set.crlf) { + if(data->state.scratch == NULL) + data->state.scratch = malloc(2*BUFSIZE); + if(data->state.scratch == NULL) { + failf (data, "Failed to alloc scratch buffer!"); + return CURLE_OUT_OF_MEMORY; + } for(i = 0, si = 0; i < nread; i++, si++) { if (conn->upload_fromhere[i] == 0x0a) { data->state.scratch[si++] = 0x0d; @@ -997,8 +1210,14 @@ CURLcode Curl_readwrite(struct connectdata *conn, conn->upload_present, /* buffer size */ &bytes_written); /* actually send away */ if(result) - return (CURLcode)result; - else if(conn->upload_present != bytes_written) { + return result; + + if(data->set.verbose) + /* show the data before we change the pointer upload_fromhere */ + Curl_debug(data, CURLINFO_DATA_OUT, conn->upload_fromhere, + bytes_written, conn->host.dispname); + + if(conn->upload_present != bytes_written) { /* we only wrote a part of the buffer (if anything), deal with it! */ /* store the amount of bytes left in the buffer to write */ @@ -1023,20 +1242,16 @@ CURLcode Curl_readwrite(struct connectdata *conn, } } - if(data->set.verbose) - Curl_debug(data, CURLINFO_DATA_OUT, conn->upload_fromhere, - bytes_written); - - k->writebytecount += bytes_written; - Curl_pgrsSetUploadCounter(data, (double)k->writebytecount); + Curl_pgrsSetUploadCounter(data, k->writebytecount); } while(!writedone); /* loop until we're done writing! */ - + } } while(0); /* just to break out from! */ + k->now = Curl_tvnow(); if(didwhat) { /* Update read/write counters */ if(conn->bytecountp) @@ -1050,25 +1265,39 @@ CURLcode Curl_readwrite(struct connectdata *conn, /* This should allow some time for the header to arrive, but only a very short time as otherwise it'll be too much wasted times too often. */ - k->write_after_100_header = FALSE; - FD_SET (conn->writesockfd, &k->writefd); /* write socket */ - k->keepon |= KEEP_WRITE; - k->wkeepfd = k->writefd; - } + + /* Quoting RFC2616, section "8.2.3 Use of the 100 (Continue) Status": + + Therefore, when a client sends this header field to an origin server + (possibly via a proxy) from which it has never seen a 100 (Continue) + status, the client SHOULD NOT wait for an indefinite period before + sending the request body. + + */ + + long ms = Curl_tvdiff(k->now, k->start100); + if(ms > CURL_TIMEOUT_EXPECT_100) { + /* we've waited long enough, continue anyway */ + k->write_after_100_header = FALSE; + FD_SET (conn->writesockfd, &k->writefd); /* write socket */ + k->keepon |= KEEP_WRITE; + k->wkeepfd = k->writefd; + } + } } - k->now = Curl_tvnow(); if(Curl_pgrsUpdate(conn)) result = CURLE_ABORTED_BY_CALLBACK; else - result = Curl_speedcheck (data, k->now); + result = Curl_speedcheck(data, k->now); if (result) - return (CURLcode)result; - + return result; + if (data->set.timeout && ((Curl_tvdiff(k->now, k->start)/1000) >= data->set.timeout)) { - failf (data, "Operation timed out with %d out of %d bytes received", - k->bytecount, conn->size); + failf(data, "Operation timed out with %" FORMAT_OFF_T + " out of %" FORMAT_OFF_T " bytes received", + k->bytecount, conn->size); return CURLE_OPERATION_TIMEOUTED; } @@ -1078,11 +1307,12 @@ CURLcode Curl_readwrite(struct connectdata *conn, * returning. */ - if(!(data->set.no_body) && k->contentlength && - (k->bytecount != k->contentlength) && + if(!(conn->bits.no_body) && (conn->size != -1) && + (k->bytecount != conn->size) && !conn->newurl) { - failf(data, "transfer closed with %d bytes remaining to read", - k->contentlength-k->bytecount); + failf(data, "transfer closed with %" FORMAT_OFF_T + " bytes remaining to read", + conn->size - k->bytecount); return CURLE_PARTIAL_FILE; } else if(conn->bits.chunk && conn->proto.http->chunk.datasize) { @@ -1095,18 +1325,23 @@ CURLcode Curl_readwrite(struct connectdata *conn, } /* Now update the "done" boolean we return */ - *done = (bool)!k->keepon; + *done = !k->keepon; return CURLE_OK; } + +/* + * Curl_readwrite_init() inits the readwrite session. + */ + CURLcode Curl_readwrite_init(struct connectdata *conn) { struct SessionHandle *data = conn->data; struct Curl_transfer_keeper *k = &conn->keep; /* NB: the content encoding software depends on this initialization of - Curl_transfer_keeper. 08/28/02 jhrg */ + Curl_transfer_keeper. */ memset(k, 0, sizeof(struct Curl_transfer_keeper)); k->start = Curl_tvnow(); /* start time */ @@ -1120,6 +1355,7 @@ CURLcode Curl_readwrite_init(struct connectdata *conn) k->maxfd = (conn->sockfd>conn->writesockfd? conn->sockfd:conn->writesockfd)+1; k->hbufp = data->state.headerbuff; + k->ignorebody=FALSE; Curl_pgrsTime(data, TIMER_PRETRANSFER); Curl_speedinit(data); @@ -1133,20 +1369,36 @@ CURLcode Curl_readwrite_init(struct connectdata *conn) Curl_pgrsSetDownloadSize(data, conn->size); } /* we want header and/or body, if neither then don't do this! */ - if(conn->bits.getheader || !data->set.no_body) { + if(conn->bits.getheader || !conn->bits.no_body) { FD_ZERO (&k->readfd); /* clear it */ - if(conn->sockfd != -1) { + if(conn->sockfd != CURL_SOCKET_BAD) { FD_SET (conn->sockfd, &k->readfd); /* read socket */ k->keepon |= KEEP_READ; } FD_ZERO (&k->writefd); /* clear it */ - if(conn->writesockfd != -1) { - if (data->set.expect100header) + if(conn->writesockfd != CURL_SOCKET_BAD) { + /* HTTP 1.1 magic: + + Even if we require a 100-return code before uploading data, we might + need to write data before that since the REQUEST may not have been + finished sent off just yet. + + Thus, we must check if the request has been sent before we set the + state info where we wait for the 100-return code + */ + if (data->set.expect100header && + (conn->proto.http->sending == HTTPSEND_BODY)) { /* wait with write until we either got 100-continue or a timeout */ k->write_after_100_header = TRUE; + k->start100 = k->start; + } else { + if(data->set.expect100header) + /* when we've sent off the rest of the headers, we must await a + 100-continue */ + k->wait100_after_headers = TRUE; FD_SET (conn->writesockfd, &k->writefd); /* write socket */ k->keepon |= KEEP_WRITE; } @@ -1162,6 +1414,13 @@ CURLcode Curl_readwrite_init(struct connectdata *conn) return CURLE_OK; } +/* + * Curl_single_fdset() gets called by the multi interface code when the app + * has requested to get the fd_sets for the current connection. This function + * will then be called once for every connection that the multi interface + * keeps track of. This function will only be called for connections that are + * in the proper state to have this information available. + */ void Curl_single_fdset(struct connectdata *conn, fd_set *read_fd_set, fd_set *write_fd_set, @@ -1176,7 +1435,10 @@ void Curl_single_fdset(struct connectdata *conn, } if(conn->keep.keepon & KEEP_WRITE) { FD_SET(conn->writesockfd, write_fd_set); - if(conn->writesockfd > *max_fd) + + /* since sockets are curl_socket_t nowadays, we typecast it to int here + to compare it nicely */ + if((int)conn->writesockfd > *max_fd) *max_fd = conn->writesockfd; conn->keep.writefdp = write_fd_set; /* store the address of the set */ } @@ -1194,7 +1456,7 @@ void Curl_single_fdset(struct connectdata *conn, * The transfer must already have been setup by a call to Curl_Transfer(). * * Note that headers are created in a preallocated buffer of a default size. - * That buffer can be enlarged on demand, but it is never shrinken again. + * That buffer can be enlarged on demand, but it is never shrunken again. * * Parts of this function was once written by the friendly Mark Butler * <butlerm@xmission.com>. @@ -1203,19 +1465,22 @@ void Curl_single_fdset(struct connectdata *conn, static CURLcode Transfer(struct connectdata *conn) { - struct SessionHandle *data = conn->data; CURLcode result; struct Curl_transfer_keeper *k = &conn->keep; bool done=FALSE; - Curl_readwrite_init(conn); + if(!(conn->protocol & PROT_FILE)) + /* Only do this if we are not transferring FILE:, since the file: treatment + is different*/ + Curl_readwrite_init(conn); - if((conn->sockfd == -1) && (conn->writesockfd == -1)) + if((conn->sockfd == CURL_SOCKET_BAD) && + (conn->writesockfd == CURL_SOCKET_BAD)) /* nothing to read, nothing to write, we're already OK! */ return CURLE_OK; /* we want header and/or body, if neither then don't do this! */ - if(!conn->bits.getheader && data->set.no_body) + if(!conn->bits.getheader && conn->bits.no_body) return CURLE_OK; k->writefdp = &k->writefd; /* store the address of the set */ @@ -1240,22 +1505,22 @@ Transfer(struct connectdata *conn) done = TRUE; /* no more read or write */ continue; case 0: /* timeout */ - result = Curl_readwrite(conn, &done); - break; - default: /* readable descriptors */ result = Curl_readwrite(conn, &done); break; } if(result) return result; - + /* "done" signals to us if the transfer(s) are ready */ } return CURLE_OK; } +/* + * Curl_pretransfer() is called immediately before a transfer starts. + */ CURLcode Curl_pretransfer(struct SessionHandle *data) { if(!data->change.url) @@ -1263,30 +1528,42 @@ CURLcode Curl_pretransfer(struct SessionHandle *data) return CURLE_URL_MALFORMAT; #ifdef USE_SSLEAY - /* 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->set.ssl.numsessions); + { + /* 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 of the cache) + but before any transfer takes place. */ + CURLcode res = Curl_SSL_InitSessions(data, data->set.ssl.numsessions); + if(res) + return res; + } #endif data->set.followlocation=0; /* reset the location-follow counter */ data->state.this_is_a_follow = FALSE; /* reset this */ data->state.errorbuf = FALSE; /* no error has occurred */ + data->state.authproblem = FALSE; + data->state.authhost.want = data->set.httpauth; + data->state.authproxy.want = data->set.proxyauth; + +#ifndef CURL_DISABLE_HTTP /* If there was a list of cookie files to read and we haven't done it before, do it now! */ if(data->change.cookielist) { struct curl_slist *list = data->change.cookielist; + Curl_share_lock(data, CURL_LOCK_DATA_COOKIE, CURL_LOCK_ACCESS_SINGLE); while(list) { - data->cookies = Curl_cookie_init(list->data, + data->cookies = Curl_cookie_init(data, + list->data, data->cookies, data->set.cookiesession); list = list->next; } + Curl_share_unlock(data, CURL_LOCK_DATA_COOKIE); curl_slist_free_all(data->change.cookielist); /* clean up list */ data->change.cookielist = NULL; /* don't do this again! */ } - +#endif /* CURL_DISABLE_HTTP */ /* Allow data->set.use_port to set which port to use. This needs to be @@ -1294,13 +1571,13 @@ CURLcode Curl_pretransfer(struct SessionHandle *data) * different ports! */ data->state.allow_port = TRUE; -#if defined(HAVE_SIGNAL) && defined(SIGPIPE) +#if defined(HAVE_SIGNAL) && defined(SIGPIPE) && !defined(HAVE_MSG_NOSIGNAL) /************************************************************* * Tell signal handler to ignore SIGPIPE *************************************************************/ if(!data->set.no_signal) data->state.prev_signal = signal(SIGPIPE, SIG_IGN); -#endif +#endif Curl_initinfo(data); /* reset session-specific information "variables" */ Curl_pgrsStartNow(data); @@ -1308,18 +1585,87 @@ CURLcode Curl_pretransfer(struct SessionHandle *data) return CURLE_OK; } +/* + * Curl_posttransfer() is called immediately after a transfer ends + */ CURLcode Curl_posttransfer(struct SessionHandle *data) { - (void)data; -#if defined(HAVE_SIGNAL) && defined(SIGPIPE) +#if defined(HAVE_SIGNAL) && defined(SIGPIPE) && !defined(HAVE_MSG_NOSIGNAL) /* restore the signal handler for SIGPIPE before we get back */ if(!data->set.no_signal) signal(SIGPIPE, data->state.prev_signal); -#endif +#else + (void)data; /* unused parameter */ +#endif return CURLE_OK; } +/* + * strlen_url() returns the length of the given URL if the spaces within the + * URL were properly URL encoded. + */ +static int strlen_url(char *url) +{ + char *ptr; + int newlen=0; + bool left=TRUE; /* left side of the ? */ + + for(ptr=url; *ptr; ptr++) { + switch(*ptr) { + case '?': + left=FALSE; + default: + newlen++; + break; + case ' ': + if(left) + newlen+=3; + else + newlen++; + break; + } + } + return newlen; +} + +/* strcpy_url() copies a url to a output buffer and URL-encodes the spaces in + * the source URL accordingly. + */ +static void strcpy_url(char *output, char *url) +{ + /* we must add this with whitespace-replacing */ + bool left=TRUE; + char *iptr; + char *optr = output; + for(iptr = url; /* read from here */ + *iptr; /* until zero byte */ + iptr++) { + switch(*iptr) { + case '?': + left=FALSE; + default: + *optr++=*iptr; + break; + case ' ': + if(left) { + *optr++='%'; /* add a '%' */ + *optr++='2'; /* add a '2' */ + *optr++='0'; /* add a '0' */ + } + else + *optr++='+'; /* add a '+' here */ + break; + } + } + *optr=0; /* zero terminate output buffer */ + +} + +/* + * Curl_follow() handles the URL redirect magic. Pass in the 'newurl' string + * as given by the remote server and set up the new URL to request. + */ CURLcode Curl_follow(struct SessionHandle *data, char *newurl) /* this 'newurl' is the Location: string, and it must be malloc()ed before passed @@ -1328,7 +1674,9 @@ CURLcode Curl_follow(struct SessionHandle *data, /* Location: redirect */ char prot[16]; /* URL protocol string storage */ char letter; /* used for a silly sscanf */ - + size_t newlen; + char *newest; + if (data->set.maxredirs && (data->set.followlocation >= data->set.maxredirs)) { failf(data,"Maximum (%d) redirects followed", data->set.maxredirs); @@ -1364,9 +1712,9 @@ CURLcode Curl_follow(struct SessionHandle *data, */ char *protsep; char *pathsep; - char *newest; char *useurl = newurl; + size_t urllen; /* we must make our own copy of the URL to play with, as it may point to read-only data */ @@ -1390,7 +1738,7 @@ CURLcode Curl_follow(struct SessionHandle *data, pathsep = strrchr(protsep, '?'); if(pathsep) *pathsep=0; - + /* we have a relative path to append to the last slash if there's one available */ pathsep = strrchr(protsep, '/'); @@ -1410,11 +1758,11 @@ CURLcode Curl_follow(struct SessionHandle *data, if((useurl[0] == '.') && (useurl[1] == '/')) useurl+=2; /* just skip the "./" */ - + while((useurl[0] == '.') && (useurl[1] == '.') && (useurl[2] == '/')) { - level++; + level++; useurl+=3; /* pass the "../" */ } @@ -1437,65 +1785,114 @@ CURLcode Curl_follow(struct SessionHandle *data, pathsep = strchr(protsep, '/'); if(pathsep) *pathsep=0; + else { + /* There was no slash. Now, since we might be operating on a badly + formatted URL, such as "http://www.url.com?id=2380" which doesn't + use a slash separator as it is supposed to, we need to check for a + ?-letter as well! */ + pathsep = strchr(protsep, '?'); + if(pathsep) + *pathsep=0; + } } - newest=(char *)malloc( strlen(url_clone) + - 1 + /* possible slash */ - strlen(useurl) + 1/* zero byte */); - - if(!newest) + /* If the new part contains a space, this is a mighty stupid redirect + but we still make an effort to do "right". To the left of a '?' + letter we replace each space with %20 while it is replaced with '+' + on the right side of the '?' letter. + */ + newlen = strlen_url(useurl); + + urllen = strlen(url_clone); + + newest=(char *)malloc( urllen + 1 + /* possible slash */ + newlen + 1 /* zero byte */); + + if(!newest) { + free(url_clone); /* don't leak this */ return CURLE_OUT_OF_MEMORY; /* go out from this */ + } + + /* copy over the root url part */ + memcpy(newest, url_clone, urllen); + + /* check if we need to append a slash */ + if(('/' == useurl[0]) || (protsep && !*protsep)) + ; + else + newest[urllen++]='/'; + + /* then append the new piece on the right side */ + strcpy_url(&newest[urllen], useurl); - sprintf(newest, "%s%s%s", url_clone, - (('/' == useurl[0]) || (protsep && !*protsep))?"":"/", - useurl); free(newurl); /* newurl is the allocated pointer */ free(url_clone); newurl = newest; } - else + else { /* This is an absolute URL, don't allow the custom port number */ data->state.allow_port = FALSE; + if(strchr(newurl, ' ')) { + /* This new URL contains at least one space, this is a mighty stupid + redirect but we still make an effort to do "right". */ + newlen = strlen_url(newurl); + + newest = malloc(newlen+1); /* get memory for this */ + if(newest) { + strcpy_url(newest, newurl); /* create a space-free URL */ + + free(newurl); /* that was no good */ + newurl = newest; /* use this instead now */ + } + } + + } + 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->change.url = newurl; newurl = NULL; /* don't free! */ - infof(data, "Follows Location: to new URL: '%s'\n", data->change.url); + infof(data, "Issue another request to this URL: '%s'\n", data->change.url); /* - * We get here when the HTTP code is 300-399. We need to perform + * We get here when the HTTP code is 300-399 (and 401). We need to perform * differently based on exactly what return code there was. - * Discussed on the curl mailing list and posted about on the 26th - * of January 2001. + * + * News from 7.10.6: we can also get here on a 401 or 407, in case we act on + * a HTTP (proxy-) authentication scheme other than Basic. */ switch(data->info.httpcode) { - case 300: /* Multiple Choices */ - case 306: /* Not used */ - case 307: /* Temporary Redirect */ - default: /* for all unknown ones */ - /* These are explicitly mention since I've checked RFC2616 and they + /* 401 - Act on a www-authentication, we keep on moving and do the + Authorization: XXXX header in the HTTP request code snippet */ + /* 407 - Act on a proxy-authentication, we keep on moving and do the + Proxy-Authorization: XXXX header in the HTTP request code snippet */ + /* 300 - Multiple Choices */ + /* 306 - Not used */ + /* 307 - Temporary Redirect */ + default: /* for all above (and the unknown ones) */ + /* Some codes are explicitly mentioned since I've checked RFC2616 and they * seem to be OK to POST to. */ break; case 301: /* Moved Permanently */ /* (quote from RFC2616, section 10.3.2): - * - * Note: When automatically redirecting a POST request after - * receiving a 301 status code, some existing HTTP/1.0 user agents - * will erroneously change it into a GET request. + * + * Note: When automatically redirecting a POST request after receiving a + * 301 status code, some existing HTTP/1.0 user agents will erroneously + * change it into a GET request. * * ---- - * Warning: Because most of importants user agents do this clear - * RFC2616 violation, many webservers expect this misbehavior. So - * these servers often answers to a POST request with an error page. - * To be sure that libcurl gets the page that most user agents - * would get, libcurl has to force GET: + * + * Warning: Because most of importants user agents do this obvious RFC2616 + * violation, many webservers expect this misbehavior. So these servers + * often answers to a POST request with an error page. To be sure that + * libcurl gets the page that most user agents would get, libcurl has to + * force GET: */ if( data->set.httpreq == HTTPREQ_POST || data->set.httpreq == HTTPREQ_POST_FORM) { @@ -1506,7 +1903,7 @@ CURLcode Curl_follow(struct SessionHandle *data, break; case 302: /* Found */ /* (From 10.3.3) - + Note: RFC 1945 and RFC 2068 specify that the client is not allowed to change the method on the redirected request. However, most existing user agent implementations treat 302 as if it were a 303 @@ -1514,13 +1911,13 @@ CURLcode Curl_follow(struct SessionHandle *data, of the original request method. The status codes 303 and 307 have been added for servers that wish to make unambiguously clear which kind of reaction is expected of the client. - + (From 10.3.4) - + Note: Many pre-HTTP/1.1 user agents do not understand the 303 status. When interoperability with such clients is a concern, the 302 status code may be used instead, since most user agents react - to a 302 response as described here for 303. + to a 302 response as described here for 303. */ case 303: /* See Other */ /* Disable both types of POSTs, since doing a second POST when @@ -1528,7 +1925,7 @@ CURLcode Curl_follow(struct SessionHandle *data, if(data->set.httpreq != HTTPREQ_GET) { data->set.httpreq = HTTPREQ_GET; /* enforce GET request */ infof(data, "Disables POST, goes with %s\n", - data->set.no_body?"HEAD":"GET"); + data->set.opt_no_body?"HEAD":"GET"); } break; case 304: /* Not Modified */ @@ -1552,6 +1949,55 @@ CURLcode Curl_follow(struct SessionHandle *data, return CURLE_OK; } +static CURLcode +Curl_connect_host(struct SessionHandle *data, + struct connectdata **conn) +{ + CURLcode res = CURLE_OK; + int urlchanged = FALSE; + + do { + bool async; + Curl_pgrsTime(data, TIMER_STARTSINGLE); + data->change.url_changed = FALSE; + res = Curl_connect(data, conn, &async); + + if((CURLE_OK == res) && async) { + /* Now, if async is TRUE here, we need to wait for the name + to resolve */ + res = Curl_wait_for_resolv(*conn, NULL); + if(CURLE_OK == res) + /* Resolved, continue with the connection */ + res = Curl_async_resolved(*conn); + } + if(res) + break; + + /* If a callback (or something) has altered the URL we should use within + the Curl_connect(), we detect it here and act as if we are redirected + to the new URL */ + urlchanged = data->change.url_changed; + if ((CURLE_OK == res) && urlchanged) { + res = Curl_done(conn, res); + if(CURLE_OK == res) { + char *gotourl = strdup(data->change.url); + res = Curl_follow(data, gotourl); + if(res) + free(gotourl); + } + } + } while (urlchanged && res == CURLE_OK); + + return res; +} + + + +/* + * Curl_perform() is the internal high-level function that gets called by the + * external curl_easy_perform() function. It inits, performs and cleans up a + * single file transfer. + */ CURLcode Curl_perform(struct SessionHandle *data) { CURLcode res; @@ -1573,49 +2019,72 @@ CURLcode Curl_perform(struct SessionHandle *data) */ do { - Curl_pgrsTime(data, TIMER_STARTSINGLE); - res = Curl_connect(data, &conn); + res = Curl_connect_host(data, &conn); /* primary connection */ + + if(res == CURLE_OK) { + if (data->set.source_host) /* 3rd party transfer */ + res = Curl_pretransfersec(conn); + else + conn->sec_conn = NULL; + } + if(res == CURLE_OK) { - res = Curl_do(&conn); - if(res == CURLE_OK) { - CURLcode res2; /* just a local extra result container */ + res = Curl_do(&conn); - if(conn->protocol&PROT_FTPS) - /* FTPS, disable ssl while transfering data */ - conn->ssl.use = FALSE; + /* for non 3rd party transfer only */ + if(res == CURLE_OK && !data->set.source_host) { res = Transfer(conn); /* now fetch that URL please */ - if(conn->protocol&PROT_FTPS) - /* FTPS, enable ssl again after havving transferred data */ - conn->ssl.use = TRUE; - - if(res == CURLE_OK) - /* - * We must duplicate the new URL here as the connection data - * may be free()ed in the Curl_done() function. - */ - newurl = conn->newurl?strdup(conn->newurl):NULL; + if(res == CURLE_OK) { + + if((conn->keep.bytecount+conn->headerbytecount == 0) && + conn->bits.reuse) { + /* We got no data and we attempted to re-use a connection. This + might happen if the connection was left alive when we were done + using it before, but that was closed when we wanted to read + from it again. Bad luck. Retry the same request on a fresh + connect! */ + infof(data, "Connection died, retrying a fresh connect\n"); + newurl = strdup(conn->data->change.url); + + conn->bits.close = TRUE; /* close this connection */ + conn->bits.retry = TRUE; /* mark this as a connection we're about + to retry. Marking it this way should + prevent i.e HTTP transfers to return + error just because nothing has been + transfered! */ + } + else + /* + * We must duplicate the new URL here as the connection data + * may be free()ed in the Curl_done() function. + */ + newurl = conn->newurl?strdup(conn->newurl):NULL; + } else { /* The transfer phase returned error, we mark the connection to get * closed to prevent being re-used. This is becasue we can't * possibly know if the connection is in a good shape or not now. */ conn->bits.close = TRUE; - if(-1 !=conn->secondarysocket) { + if(CURL_SOCKET_BAD != conn->sock[SECONDARYSOCKET]) { /* if we failed anywhere, we must clean up the secondary socket if it was used */ - sclose(conn->secondarysocket); - conn->secondarysocket=-1; + sclose(conn->sock[SECONDARYSOCKET]); + conn->sock[SECONDARYSOCKET] = CURL_SOCKET_BAD; } } /* Always run Curl_done(), even if some of the previous calls failed, but return the previous (original) error code */ - res2 = Curl_done(conn); + res2 = Curl_done(&conn, res); if(CURLE_OK == res) res = res2; } + else + /* Curl_do() failed, clean up left-overs in the done-call */ + res2 = Curl_done(&conn, res); /* * Important: 'conn' cannot be used here, since it may have been closed @@ -1646,15 +2115,20 @@ CURLcode Curl_perform(struct SessionHandle *data) return res; } -CURLcode +/* + * Curl_Transfer() is called to setup some basic properties for the upcoming + * transfer. + */ +CURLcode Curl_Transfer(struct connectdata *c_conn, /* connection data */ - int sockfd, /* socket to read from or -1 */ - int size, /* -1 if unknown at this point */ - bool getheader, /* TRUE if header parsing is wanted */ - long *bytecountp, /* return number of bytes read or NULL */ - int writesockfd, /* socket to write to, it may very well be - the same we read from. -1 disables */ - long *writebytecountp /* return number of bytes written or + int sockindex, /* socket index to read from or -1 */ + curl_off_t size, /* -1 if unknown at this point */ + bool getheader, /* TRUE if header parsing is wanted */ + curl_off_t *bytecountp, /* return number of bytes read or NULL */ + int writesockindex, /* socket index to write to, it may very + well be the same we read from. -1 + disables */ + curl_off_t *writecountp /* return number of bytes written or NULL */ ) { @@ -1662,22 +2136,52 @@ Curl_Transfer(struct connectdata *c_conn, /* connection data */ if(!conn) return CURLE_BAD_FUNCTION_ARGUMENT; + curlassert((sockindex <= 1) && (sockindex >= -1)); + /* now copy all input parameters */ - conn->sockfd = sockfd; + conn->sockfd = sockindex==-1? + CURL_SOCKET_BAD:conn->sock[sockindex]; conn->size = size; conn->bits.getheader = getheader; conn->bytecountp = bytecountp; - conn->writesockfd = writesockfd; - conn->writebytecountp = writebytecountp; + conn->writesockfd = writesockindex==-1? + CURL_SOCKET_BAD:conn->sock[writesockindex]; + conn->writebytecountp = writecountp; return CURLE_OK; } - + /* - * local variables: - * eval: (load-file "../curl-mode.el") - * end: - * vim600: fdm=marker - * vim: et sw=2 ts=2 sts=2 tw=78 + * Curl_pretransfersec() prepares the secondary connection (used for 3rd party + * FTP transfers). */ +CURLcode Curl_pretransfersec(struct connectdata *conn) +{ + CURLcode status = CURLE_OK; + struct SessionHandle *data = conn->data; + struct connectdata *sec_conn = NULL; /* secondary connection */ + + /* update data with source host options */ + char *url = aprintf( "%s://%s/", conn->protostr, data->set.source_host); + + if(!url) + return CURLE_OUT_OF_MEMORY; + + if(data->change.url_alloc) + free(data->change.url); + + data->change.url_alloc = TRUE; + data->change.url = url; + data->set.ftpport = data->set.source_port; + data->set.userpwd = data->set.source_userpwd; + + /* secondary connection */ + status = Curl_connect_host(data, &sec_conn); + if(CURLE_OK == status) { + sec_conn->data = data; + conn->sec_conn = sec_conn; + } + + return status; +} |