#define min(a, b) ((a) < (b) ? (a) : (b))
#endif
+enum {
+ KEEP_NONE,
+ KEEP_READ,
+ KEEP_WRITE
+};
+
+
/*
* compareheader()
*
return FALSE; /* no match */
}
-/*
- * Transfer()
- *
- * This function is what performs the actual transfer. It is capable of
- * doing both ways simultaneously.
- * 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.
- *
- * Parts of this function was once written by the friendly Mark Butler
- * <butlerm@xmission.com>.
- */
-
-static CURLcode
-Transfer(struct connectdata *c_conn)
+CURLcode Curl_readwrite(struct connectdata *conn,
+ bool *done)
{
- ssize_t nread; /* number of bytes read */
- int bytecount = 0; /* total number of bytes read */
- int writebytecount = 0; /* number of bytes written */
- long contentlength=0; /* size of incoming data */
- struct timeval start = Curl_tvnow();
- struct timeval now = start; /* current time */
- bool header = TRUE; /* incoming data has HTTP header */
- int headerline = 0; /* counts header lines to better track the
- first one */
- char *hbufp; /* points at *end* of header line */
- int hbuflen = 0;
- char *str; /* within buf */
- char *str_start; /* within buf */
- char *end_ptr; /* within buf */
- char *p; /* within headerbuff */
- bool content_range = FALSE; /* set TRUE if Content-Range: was found */
- int offset = 0; /* possible resume offset read from the
- Content-Range: header */
- int httpcode = 0; /* error code from the 'HTTP/1.? XXX' line */
- int httpversion = -1; /* the HTTP version*10 */
- bool write_after_100_header = FALSE; /* should we enable the write after
- we received a 100-continue/timeout
- or directly */
-
- /* for the low speed checks: */
- CURLcode urg;
- time_t timeofdoc=0;
- long bodywrites=0;
- int writetype;
-
- /* the highest fd we use + 1 */
- struct SessionHandle *data;
- struct connectdata *conn = (struct connectdata *)c_conn;
- char *buf;
- int maxfd;
+ struct Curl_transfer_keeper *k = &conn->keep;
+ struct SessionHandle *data = conn->data;
+ CURLcode result;
+ ssize_t nread; /* number of bytes read */
+ int didwhat=0;
- data = conn->data; /* there's the root struct */
- buf = data->state.buffer;
- maxfd = (conn->sockfd>conn->writesockfd?conn->sockfd:conn->writesockfd)+1;
-
- hbufp = data->state.headerbuff;
+ do {
+ if((k->keepon & KEEP_READ) &&
+ FD_ISSET(conn->sockfd, &k->readfd)) {
- now = Curl_tvnow();
- start = now;
+ if ((k->bytecount == 0) && (k->writebytecount == 0))
+ Curl_pgrsTime(data, TIMER_STARTTRANSFER);
-#define KEEP_READ 1
-#define KEEP_WRITE 2
+ didwhat |= KEEP_READ;
- Curl_pgrsTime(data, TIMER_PRETRANSFER);
- Curl_speedinit(data);
-
- if((conn->sockfd == -1) &&
- (conn->writesockfd == -1)) {
- /* nothing to read, nothing to write, we're already OK! */
- return CURLE_OK;
- }
+ /* read! */
+ result = Curl_read(conn, conn->sockfd, k->buf,
+ BUFSIZE -1, &nread);
- if (!conn->getheader) {
- header = FALSE;
- if(conn->size > 0)
- Curl_pgrsSetDownloadSize(data, conn->size);
- }
- /* we want header and/or body, if neither then don't do this! */
- if(conn->getheader ||
- !data->set.no_body) {
- fd_set readfd;
- fd_set writefd;
- fd_set rkeepfd;
- fd_set wkeepfd;
- struct timeval interval;
- int keepon=0;
-
- /* timeout every X second
- - makes a better progress meter (i.e even when no data is read, the
- meter can be updated and reflect reality)
- - allows removal of the alarm() crap
- - variable timeout is easier
- */
+ if(result)
+ return result;
- FD_ZERO (&readfd); /* clear it */
- if(conn->sockfd != -1) {
- FD_SET (conn->sockfd, &readfd); /* read socket */
- keepon |= KEEP_READ;
- }
+ /* NULL terminate, allowing string ops to be used */
+ if (0 < (signed int) nread)
+ k->buf[nread] = 0;
- FD_ZERO (&writefd); /* clear it */
- if(conn->writesockfd != -1) {
- if (data->set.expect100header)
- /* wait with write until we either got 100-continue or a timeout */
- write_after_100_header = TRUE;
- else {
- FD_SET (conn->writesockfd, &writefd); /* write socket */
- keepon |= KEEP_WRITE;
+ /* if we receive 0 or less here, the server closed the connection and
+ we bail out from this! */
+ else if (0 >= (signed int) nread) {
+ k->keepon &= ~KEEP_READ;
+ FD_ZERO(&k->rkeepfd);
+ break;
}
- }
- /* get these in backup variables to be able to restore them on each lap in
- the select() loop */
- rkeepfd = readfd;
- wkeepfd = writefd;
+ /* Default buffer to use when we write the buffer, it may be changed
+ in the flow below before the actual storing is done. */
+ k->str = k->buf;
- while (keepon) {
- readfd = rkeepfd; /* set those every lap in the loop */
- writefd = wkeepfd;
- interval.tv_sec = 1;
- interval.tv_usec = 0;
+ /* Since this is a two-state thing, we check if we are parsing
+ headers at the moment or not. */
+ if (k->header) {
+ /* we are in parse-the-header-mode */
- switch (select (maxfd, &readfd, &writefd, NULL, &interval)) {
- case -1: /* select() error, stop reading */
-#ifdef EINTR
- /* The EINTR is not serious, and it seems you might get this more
- ofen when using the lib in a multi-threaded environment! */
- if(errno == EINTR)
- ;
- else
-#endif
- keepon = 0; /* no more read or write */
- continue;
- case 0: /* timeout */
- if (write_after_100_header) {
- write_after_100_header = FALSE;
- FD_SET (conn->writesockfd, &writefd); /* write socket */
- keepon |= KEEP_WRITE;
- wkeepfd = writefd;
- }
- break;
- default:
- if ((bytecount == 0) && (writebytecount == 0))
- Curl_pgrsTime(data, TIMER_STARTTRANSFER);
- if((keepon & KEEP_READ) && FD_ISSET(conn->sockfd, &readfd)) {
- /* read! */
- urg = Curl_read(conn, conn->sockfd, buf, BUFSIZE -1, &nread);
-
- /* NULL terminate, allowing string ops to be used */
- if (0 < (signed int) nread)
- buf[nread] = 0;
-
- /* if we receive 0 or less here, the server closed the connection and
- we bail out from this! */
- else if (0 >= (signed int) nread) {
- keepon &= ~KEEP_READ;
- FD_ZERO(&rkeepfd);
- break;
+ /* header line within buffer loop */
+ do {
+ int hbufp_index;
+
+ /* 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) {
+ /* no more complete header lines within buffer */
+ /* copy what is remaining into headerbuff */
+ int str_length = (int)strlen(k->str);
+
+ /*
+ * We enlarge the header buffer if it seems to be too
+ * smallish
+ */
+ if (k->hbuflen + (int)str_length >=
+ data->state.headersize) {
+ char *newbuff;
+ long newsize=MAX((k->hbuflen+str_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!");
+ return CURLE_READ_ERROR;
+ }
+ data->state.headersize=newsize;
+ data->state.headerbuff = newbuff;
+ k->hbufp = data->state.headerbuff + hbufp_index;
+ }
+ strcpy (k->hbufp, k->str);
+ k->hbufp += strlen (k->str);
+ k->hbuflen += strlen (k->str);
+ break; /* read more and try again */
}
- str = buf; /* Default buffer to use when we write the
- buffer, it may be changed in the flow below
- before the actual storing is done. */
+ k->str = k->end_ptr + 1; /* move past new line */
- /* Since this is a two-state thing, we check if we are parsing
- headers at the moment or not. */
-
- if (header) {
- /* we are in parse-the-header-mode */
+ /*
+ * 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
+ * it.
+ */
+ if (k->hbuflen + (k->str - k->str_start) >=
+ data->state.headersize) {
+ char *newbuff;
+ long newsize=MAX((k->hbuflen+
+ (k->str-k->str_start))*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!");
+ return CURLE_READ_ERROR;
+ }
+ data->state.headersize= newsize;
+ data->state.headerbuff = newbuff;
+ k->hbufp = data->state.headerbuff + hbufp_index;
+ }
- /* header line within buffer loop */
- do {
- int hbufp_index;
+ /* 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 += k->str - k->str_start;
+ *k->hbufp = 0;
- str_start = str; /* str_start is start of line within buf */
+ k->p = data->state.headerbuff;
- end_ptr = strchr (str_start, '\n');
-
- if (!end_ptr) {
- /* no more complete header lines within buffer */
- /* copy what is remaining into headerbuff */
- int str_length = (int)strlen(str);
-
- /*
- * We enlarge the header buffer if it seems to be too
- * smallish
- */
- if (hbuflen + (int)str_length >= data->state.headersize) {
- char *newbuff;
- long newsize=MAX((hbuflen+str_length)*3/2,
- 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->state.headersize=newsize;
- data->state.headerbuff = newbuff;
- hbufp = data->state.headerbuff + hbufp_index;
- }
- strcpy (hbufp, str);
- hbufp += strlen (str);
- hbuflen += strlen (str);
- break; /* read more and try again */
- }
+ /****
+ * We now have a FULL header line that p points to
+ *****/
- str = end_ptr + 1; /* move just past new line */
+ if (('\n' == *k->p) || ('\r' == *k->p)) {
+ /* Zero-length header line means end of headers! */
+ if ('\r' == *k->p)
+ k->p++; /* pass the \r byte */
+ if ('\n' == *k->p)
+ k->p++; /* pass the \n byte */
+
+ if(100 == k->httpcode) {
/*
- * 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
- * it.
+ * 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.
+ * However, we'll get more headers now so we must get
+ * back into the header-parsing state!
*/
- if (hbuflen + (str - str_start) >= data->state.headersize) {
- char *newbuff;
- long newsize=MAX((hbuflen+(str-str_start))*3/2,
- 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->state.headersize= newsize;
- data->state.headerbuff = newbuff;
- hbufp = data->state.headerbuff + hbufp_index;
+ k->header = TRUE;
+ k->headerline = 0; /* restart the header line counter */
+ /* if we did wait for this do enable write now! */
+ if (k->write_after_100_header) {
+ k->write_after_100_header = FALSE;
+ FD_SET (conn->writesockfd, &k->writefd); /* write */
+ k->keepon |= KEEP_WRITE;
+ k->wkeepfd = k->writefd;
}
+ }
+ else
+ k->header = FALSE; /* no more header to parse! */
- /* copy to end of line */
- strncpy (hbufp, str_start, str - str_start);
- hbufp += str - str_start;
- hbuflen += str - str_start;
- *hbufp = 0;
-
- p = data->state.headerbuff;
-
- /****
- * We now have a FULL header line that p points to
- *****/
-
- if (('\n' == *p) || ('\r' == *p)) {
- /* Zero-length header line means end of headers! */
-
- if ('\r' == *p)
- p++; /* pass the \r byte */
- if ('\n' == *p)
- p++; /* pass the \n byte */
-
- if(100 == httpcode) {
- /*
- * 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.
- * However, we'll get more headers now so we must get
- * back into the header-parsing state!
- */
- header = TRUE;
- headerline = 0; /* we restart the header line counter */
- /* if we did wait for this do enable write now! */
- if (write_after_100_header) {
- write_after_100_header = FALSE;
- FD_SET (conn->writesockfd, &writefd); /* write socket */
- keepon |= KEEP_WRITE;
- wkeepfd = writefd;
- }
- }
- else
- header = FALSE; /* no more header to parse! */
-
- if (417 == httpcode) {
- /*
- * we got: "417 Expectation Failed" this means:
- * we have made a HTTP call and our Expect Header
- * seems to cause a problem => abort the write operations
- * (or prevent them from starting
- */
- write_after_100_header = FALSE;
- keepon &= ~KEEP_WRITE;
- FD_ZERO(&wkeepfd);
- }
-
- /* now, only output this if the header AND body are requested:
- */
- writetype = CLIENTWRITE_HEADER;
- if (data->set.http_include_header)
- writetype |= CLIENTWRITE_BODY;
-
- urg = Curl_client_write(data, writetype,
- data->state.headerbuff,
- p - data->state.headerbuff);
- if(urg)
- return urg;
-
- data->info.header_size += p - data->state.headerbuff;
- conn->headerbytecount += p - data->state.headerbuff;
-
- if(!header) {
- /*
- * really end-of-headers.
- *
- * If we requested a "no body", this is a good time to get
- * out and return home.
- */
- if(data->set.no_body)
- return CURLE_OK;
+ if (417 == k->httpcode) {
+ /*
+ * we got: "417 Expectation Failed" this means:
+ * we have made a HTTP call and our Expect Header
+ * seems to cause a problem => abort the write operations
+ * (or prevent them from starting
+ */
+ k->write_after_100_header = FALSE;
+ k->keepon &= ~KEEP_WRITE;
+ FD_ZERO(&k->wkeepfd);
+ }
- 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;
-
- /* If max download size is *zero* (nothing) we already
- have nothing and can safely return ok now! */
- if(0 == conn->maxdownload)
- return CURLE_OK;
-
- /* What to do if the size is *not* known? */
- }
- break; /* exit header line loop */
- }
-
- /* We continue reading headers, so reset the line-based
- header parsing variables hbufp && hbuflen */
- hbufp = data->state.headerbuff;
- hbuflen = 0;
- continue;
- }
+ /* 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;
+
+ result = Curl_client_write(data, k->writetype,
+ data->state.headerbuff,
+ k->p - data->state.headerbuff);
+ if(result)
+ return result;
+
+ data->info.header_size += k->p - data->state.headerbuff;
+ conn->headerbytecount += k->p - data->state.headerbuff;
+ if(!k->header) {
/*
- * Checks for special headers coming up.
+ * really end-of-headers.
+ *
+ * If we requested a "no body", this is a good time to get
+ * out and return home.
*/
+ if(data->set.no_body)
+ return CURLE_OK;
+
+ 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;
+
+ /* If max download size is *zero* (nothing) we already
+ have nothing and can safely return ok now! */
+ if(0 == conn->maxdownload)
+ return CURLE_OK;
+
+ /* What to do if the size is *not* known? */
+ }
+ break; /* exit header line loop */
+ }
+
+ /* We continue reading headers, so reset the line-based
+ header parsing variables hbufp && hbuflen */
+ k->hbufp = data->state.headerbuff;
+ k->hbuflen = 0;
+ continue;
+ }
+
+ /*
+ * Checks for special headers coming up.
+ */
- if (!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 (p, " HTTP/%d.%d %3d",
- &httpversion_major ,&httpversion, &httpcode);
- if (nc==3) {
- httpversion+=10*httpversion_major;
- }
- else {
- /* this is the real world, not a Nirvana
- NCSA 1.5.x returns this crap when asked for HTTP/1.1
- */
- nc=sscanf (p, " HTTP %3d", &httpcode);
- httpversion = 10;
- }
-
- if (nc) {
- data->info.httpcode = httpcode;
- data->info.httpversion = httpversion;
-
- /* 404 -> URL not found! */
- if (data->set.http_fail_on_error &&
- (httpcode >= 400)) {
- /* If we have been told to fail hard on HTTP-errors,
- here is the check for that: */
- /* serious error, go home! */
- failf (data, "The requested file was not found");
- return CURLE_HTTP_NOT_FOUND;
- }
+ 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);
+ if (nc==3) {
+ k->httpversion += 10 * httpversion_major;
+ }
+ else {
+ /* 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);
+ k->httpversion = 10;
+ }
- if(httpversion == 10)
- /* Default action for HTTP/1.0 must be to close, unless
- we get one of those fancy headers that tell us the
- server keeps it open for us! */
- conn->bits.close = TRUE;
-
- if (httpcode == 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.
- */
- conn->size=0;
- }
- else {
- header = FALSE; /* this is not a header line */
- break;
- }
- }
- /* check for Content-Length: header lines to get size */
- if (strnequal("Content-Length:", p, 15) &&
- sscanf (p+15, " %ld", &contentlength)) {
- conn->size = contentlength;
- Curl_pgrsSetDownloadSize(data, contentlength);
+ if (nc) {
+ data->info.httpcode = k->httpcode;
+ data->info.httpversion = k->httpversion;
+
+ /* 404 -> URL not found! */
+ 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: */
+ /* serious error, go home! */
+ failf (data, "The requested file was not found");
+ return CURLE_HTTP_NOT_FOUND;
}
- else if((httpversion == 10) &&
- conn->bits.httpproxy &&
- compareheader(p, "Proxy-Connection:", "keep-alive")) {
- /*
- * When a HTTP/1.0 reply comes when using a proxy, the
- * 'Proxy-Connection: keep-alive' line tells us the
- * connection will be kept alive for our pleasure.
- * Default action for 1.0 is to close.
- */
- conn->bits.close = FALSE; /* don't close when done */
- infof(data, "HTTP/1.0 proxy connection set to keep alive!\n");
- }
- else if((httpversion == 10) &&
- compareheader(p, "Connection:", "keep-alive")) {
- /*
- * A HTTP/1.0 reply with the 'Connection: keep-alive' line
- * tells us the connection will be kept alive for our
- * pleasure. Default action for 1.0 is to close.
- *
- * [RFC2068, section 19.7.1] */
- conn->bits.close = FALSE; /* don't close when done */
- infof(data, "HTTP/1.0 connection set to keep alive!\n");
- }
- else if (compareheader(p, "Connection:", "close")) {
- /*
- * [RFC 2616, section 8.1.2.1]
- * "Connection: close" is HTTP/1.1 language and means that
- * the connection will close when this request has been
- * served.
+
+ if(k->httpversion == 10)
+ /* Default action for HTTP/1.0 must be to close, unless
+ we get one of those fancy headers that tell us the
+ server keeps it open for us! */
+ conn->bits.close = TRUE;
+
+ if (k->httpcode == 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.
*/
- conn->bits.close = TRUE; /* close when done */
- }
- else if (compareheader(p, "Transfer-Encoding:", "chunked")) {
- /*
- * [RFC 2616, section 3.6.1] A 'chunked' transfer encoding
- * means that the server will send a series of "chunks". Each
- * chunk starts with line with info (including size of the
- * coming block) (terminated with CRLF), then a block of data
- * with the previously mentioned size. There can be any amount
- * of chunks, and a chunk-data set to zero signals the
- * end-of-chunks. */
- conn->bits.chunk = TRUE; /* chunks coming our way */
-
- /* init our chunky engine */
- Curl_httpchunk_init(conn);
- }
- else if (strnequal("Content-Range:", p, 14)) {
- if (sscanf (p+14, " bytes %d-", &offset) ||
- sscanf (p+14, " bytes: %d-", &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 == offset) {
- /* we asked for a resume and we got it */
- content_range = TRUE;
- }
- }
- }
- else if(data->cookies &&
- strnequal("Set-Cookie:", p, 11)) {
- Curl_cookie_add(data->cookies, TRUE, &p[12], conn->name);
- }
- else if(strnequal("Last-Modified:", p,
- strlen("Last-Modified:")) &&
- (data->set.timecondition || data->set.get_filetime) ) {
- time_t secs=time(NULL);
- timeofdoc = curl_getdate(p+strlen("Last-Modified:"), &secs);
- if(data->set.get_filetime>=0)
- data->info.filetime = timeofdoc;
- }
- else if ((httpcode >= 300 && httpcode < 400) &&
- (data->set.http_follow_location) &&
- strnequal("Location:", p, 9)) {
- /* this is the URL that the server advices us to get instead */
- char *ptr;
- char *start=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))
- ptr++;
- backup = *ptr; /* store the ending letter */
- *ptr = '\0'; /* zero terminate */
- conn->newurl = strdup(start); /* clone string */
- *ptr = backup; /* restore ending letter */
+ conn->size=0;
+ }
+ else {
+ k->header = FALSE; /* this is not a header line */
+ break;
+ }
+ }
+ /* check for Content-Length: header lines to get size */
+ if (strnequal("Content-Length:", k->p, 15) &&
+ sscanf (k->p+15, " %ld", &k->contentlength)) {
+ conn->size = k->contentlength;
+ Curl_pgrsSetDownloadSize(data, k->contentlength);
+ }
+ else if((k->httpversion == 10) &&
+ conn->bits.httpproxy &&
+ compareheader(k->p, "Proxy-Connection:", "keep-alive")) {
+ /*
+ * When a HTTP/1.0 reply comes when using a proxy, the
+ * 'Proxy-Connection: keep-alive' line tells us the
+ * connection will be kept alive for our pleasure.
+ * Default action for 1.0 is to close.
+ */
+ conn->bits.close = FALSE; /* don't close when done */
+ infof(data, "HTTP/1.0 proxy connection set to keep alive!\n");
+ }
+ else if((k->httpversion == 10) &&
+ compareheader(k->p, "Connection:", "keep-alive")) {
+ /*
+ * A HTTP/1.0 reply with the 'Connection: keep-alive' line
+ * tells us the connection will be kept alive for our
+ * pleasure. Default action for 1.0 is to close.
+ *
+ * [RFC2068, section 19.7.1] */
+ conn->bits.close = FALSE; /* don't close when done */
+ infof(data, "HTTP/1.0 connection set to keep alive!\n");
+ }
+ else if (compareheader(k->p, "Connection:", "close")) {
+ /*
+ * [RFC 2616, section 8.1.2.1]
+ * "Connection: close" is HTTP/1.1 language and means that
+ * the connection will close when this request has been
+ * served.
+ */
+ conn->bits.close = TRUE; /* close when done */
+ }
+ else if (compareheader(k->p, "Transfer-Encoding:", "chunked")) {
+ /*
+ * [RFC 2616, section 3.6.1] A 'chunked' transfer encoding
+ * means that the server will send a series of "chunks". Each
+ * chunk starts with line with info (including size of the
+ * coming block) (terminated with CRLF), then a block of data
+ * with the previously mentioned size. There can be any amount
+ * of chunks, and a chunk-data set to zero signals the
+ * end-of-chunks. */
+ conn->bits.chunk = TRUE; /* chunks coming our way */
+
+ /* init our chunky engine */
+ Curl_httpchunk_init(conn);
+ }
+ else if (strnequal("Content-Range:", k->p, 14)) {
+ 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(data->cookies &&
+ strnequal("Set-Cookie:", k->p, 11)) {
+ Curl_cookie_add(data->cookies, TRUE, k->p+12, conn->name);
+ }
+ else if(strnequal("Last-Modified:", k->p,
+ strlen("Last-Modified:")) &&
+ (data->set.timecondition || data->set.get_filetime) ) {
+ time_t secs=time(NULL);
+ k->timeofdoc = curl_getdate(k->p+strlen("Last-Modified:"),
+ &secs);
+ if(data->set.get_filetime>=0)
+ data->info.filetime = k->timeofdoc;
+ }
+ else if ((k->httpcode >= 300 && k->httpcode < 400) &&
+ (data->set.http_follow_location) &&
+ strnequal("Location:", k->p, 9)) {
+ /* 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))
+ ptr++;
+ backup = *ptr; /* store the ending letter */
+ *ptr = '\0'; /* zero terminate */
+ conn->newurl = strdup(start); /* clone string */
+ *ptr = backup; /* restore ending letter */
+ }
- /*
- * End of header-checks. Write them to the client.
- */
+ /*
+ * End of header-checks. Write them to the client.
+ */
- writetype = CLIENTWRITE_HEADER;
- if (data->set.http_include_header)
- writetype |= CLIENTWRITE_BODY;
+ k->writetype = CLIENTWRITE_HEADER;
+ if (data->set.http_include_header)
+ k->writetype |= CLIENTWRITE_BODY;
- urg = Curl_client_write(data, writetype, p, hbuflen);
- if(urg)
- return urg;
+ result = Curl_client_write(data, k->writetype, k->p,
+ k->hbuflen);
+ if(result)
+ return result;
- data->info.header_size += hbuflen;
+ data->info.header_size += k->hbuflen;
- /* reset hbufp pointer && hbuflen */
- hbufp = data->state.headerbuff;
- hbuflen = 0;
- }
- while (*str); /* header line within buffer */
+ /* reset hbufp pointer && hbuflen */
+ k->hbufp = data->state.headerbuff;
+ k->hbuflen = 0;
+ }
+ while (*k->str); /* header line within buffer */
- /* We might have reached the end of the header part here, but
- there might be a non-header part left in the end of the read
- buffer. */
+ /* We might have reached the end of the header part here, but
+ there might be a non-header part left in the end of the read
+ buffer. */
- if (!header) {
- /* the next token and forward is not part of
- the header! */
+ if (!k->header) {
+ /* the next token and forward is not part of
+ the header! */
- /* we subtract the remaining header size from the buffer */
- nread -= (str - buf);
- }
+ /* we subtract the remaining header size from the buffer */
+ nread -= (k->str - k->buf);
+ }
- } /* end if header mode */
+ } /* end if header mode */
- /* This is not an 'else if' since it may be a rest from the header
- parsing, where the beginning of the buffer is headers and the end
- is non-headers. */
- if (str && !header && ((signed int)nread > 0)) {
+ /* This is not an 'else if' since it may be a rest from the header
+ parsing, where the beginning of the buffer is headers and the end
+ is non-headers. */
+ if (k->str && !k->header && ((signed int)nread > 0)) {
- if(0 == 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);
- return CURLE_OK;
- }
- else if (conn->resume_from &&
- !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;
- }
- 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->set.timevalue > 0)) {
- switch(data->set.timecondition) {
- case TIMECOND_IFMODSINCE:
- default:
- 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->set.timevalue) {
- infof(data,
- "The requested document is not old enough\n");
- return CURLE_OK;
- }
- break;
- } /* switch */
- } /* two valid time strings */
- } /* we have a time condition */
-
- } /* this is HTTP */
- } /* this is the first time we write a body part */
- bodywrites++;
-
- if(conn->bits.chunk) {
- /*
- * Bless me father for I have sinned. Here comes a chunked
- * transfer flying and we need to decode this properly. While
- * the name says read, this function both reads and writes away
- * the data. The returned 'nread' holds the number of actual
- * data it wrote to the client. */
- CHUNKcode res =
- Curl_httpchunk_read(conn, str, nread, &nread);
-
- if(CHUNKE_OK < res) {
- failf(data, "Receeived problem in the chunky parser");
- return CURLE_READ_ERROR;
- }
- else if(CHUNKE_STOP == res) {
- /* we're done reading chunks! */
- keepon &= ~KEEP_READ; /* read no more */
- FD_ZERO(&rkeepfd);
-
- /* There are now possibly N number of bytes at the end of the
- str buffer that weren't written to the client, but we don't
- care about them right now. */
- }
- /* If it returned OK, we just keep going */
+ 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);
+ 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;
+ }
+ 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((k->timeofdoc > 0) && (data->set.timevalue > 0)) {
+ switch(data->set.timecondition) {
+ case TIMECOND_IFMODSINCE:
+ default:
+ if(k->timeofdoc < data->set.timevalue) {
+ infof(data,
+ "The requested document is not new enough\n");
+ return CURLE_OK;
+ }
+ break;
+ case TIMECOND_IFUNMODSINCE:
+ if(k->timeofdoc > data->set.timevalue) {
+ infof(data,
+ "The requested document is not old enough\n");
+ return CURLE_OK;
+ }
+ break;
+ } /* switch */
+ } /* two valid time strings */
+ } /* we have a time condition */
- if((-1 != conn->maxdownload) &&
- (bytecount + nread >= conn->maxdownload)) {
- nread = conn->maxdownload - bytecount;
- if((signed int)nread < 0 ) /* this should be unusual */
- nread = 0;
+ } /* this is HTTP */
+ } /* this is the first time we write a body part */
+ k->bodywrites++;
- keepon &= ~KEEP_READ; /* we're done reading */
- FD_ZERO(&rkeepfd);
- }
+ if(conn->bits.chunk) {
+ /*
+ * Bless me father for I have sinned. Here comes a chunked
+ * transfer flying and we need to decode this properly. While
+ * the name says read, this function both reads and writes away
+ * the data. The returned 'nread' holds the number of actual
+ * data it wrote to the client. */
+ CHUNKcode res =
+ Curl_httpchunk_read(conn, k->str, nread, &nread);
+
+ if(CHUNKE_OK < res) {
+ failf(data, "Receeived problem in the chunky parser");
+ return CURLE_READ_ERROR;
+ }
+ else if(CHUNKE_STOP == res) {
+ /* we're done reading chunks! */
+ k->keepon &= ~KEEP_READ; /* read no more */
+ FD_ZERO(&k->rkeepfd);
+
+ /* There are now possibly N number of bytes at the end of the
+ str buffer that weren't written to the client, but we don't
+ care about them right now. */
+ }
+ /* If it returned OK, we just keep going */
+ }
+
+ if((-1 != conn->maxdownload) &&
+ (k->bytecount + nread >= conn->maxdownload)) {
+ nread = conn->maxdownload - k->bytecount;
+ if((signed int)nread < 0 ) /* this should be unusual */
+ nread = 0;
+
+ k->keepon &= ~KEEP_READ; /* we're done reading */
+ FD_ZERO(&k->rkeepfd);
+ }
- bytecount += nread;
+ k->bytecount += nread;
- Curl_pgrsSetDownloadCounter(data, (double)bytecount);
+ Curl_pgrsSetDownloadCounter(data, (double)k->bytecount);
- if(!conn->bits.chunk && nread) {
- /* If this is chunky transfer, it was already written */
- urg = Curl_client_write(data, CLIENTWRITE_BODY, str, nread);
- if(urg)
- return urg;
- }
+ if(!conn->bits.chunk && nread) {
+ /* If this is chunky transfer, it was already written */
+ result = Curl_client_write(data, CLIENTWRITE_BODY, k->str,
+ nread);
+ if(result)
+ return result;
+ }
- } /* if (! header and data to read ) */
- } /* if( read from socket ) */
+ } /* if (! header and data to read ) */
+ } /* if( read from socket ) */
- if((keepon & KEEP_WRITE) && FD_ISSET(conn->writesockfd, &writefd)) {
- /* write */
+ if((k->keepon & KEEP_WRITE) &&
+ FD_ISSET(conn->writesockfd, &k->writefd)) {
+ /* write */
- int i, si;
- size_t bytes_written;
+ int i, si;
+ size_t bytes_written;
- nread = data->set.fread(buf, 1, conn->upload_bufsize, data->set.in);
+ if ((k->bytecount == 0) && (k->writebytecount == 0))
+ Curl_pgrsTime(data, TIMER_STARTTRANSFER);
- /* the signed int typecase of nread of for systems that has
- unsigned size_t */
- if ((signed int)nread<=0) {
- /* done */
- keepon &= ~KEEP_WRITE; /* we're done writing */
- FD_ZERO(&wkeepfd);
- break;
- }
- writebytecount += nread;
- Curl_pgrsSetUploadCounter(data, (double)writebytecount);
-
- /* convert LF to CRLF if so asked */
- if (data->set.crlf) {
- for(i = 0, si = 0; i < (int)nread; i++, si++) {
- if (buf[i] == 0x0a) {
- data->state.scratch[si++] = 0x0d;
- data->state.scratch[si] = 0x0a;
- }
- else {
- data->state.scratch[si] = buf[i];
- }
- }
- nread = si;
- buf = data->state.scratch; /* point to the new buffer */
- }
+ didwhat |= KEEP_WRITE;
- /* write to socket */
- urg = Curl_write(conn, conn->writesockfd, buf, nread,
- &bytes_written);
+ nread = data->set.fread(k->buf, 1, conn->upload_bufsize,
+ data->set.in);
- if(nread != (int)bytes_written) {
- failf(data, "Failed uploading data");
- return CURLE_WRITE_ERROR;
+ /* the signed int typecase of nread of for systems that has
+ unsigned size_t */
+ if ((signed int)nread<=0) {
+ /* done */
+ k->keepon &= ~KEEP_WRITE; /* we're done writing */
+ FD_ZERO(&k->wkeepfd);
+ break;
+ }
+ k->writebytecount += nread;
+ Curl_pgrsSetUploadCounter(data, (double)k->writebytecount);
+
+ /* convert LF to CRLF if so asked */
+ if (data->set.crlf) {
+ for(i = 0, si = 0; i < (int)nread; i++, si++) {
+ if (k->buf[i] == 0x0a) {
+ data->state.scratch[si++] = 0x0d;
+ data->state.scratch[si] = 0x0a;
+ }
+ else {
+ data->state.scratch[si] = k->buf[i];
}
- if(data->set.crlf)
- buf = data->state.buffer; /* put it back on the buffer */
-
}
+ nread = si;
+ k->buf = data->state.scratch; /* point to the new buffer */
+ }
- break;
+ /* write to socket */
+ result = Curl_write(conn, conn->writesockfd, k->buf, nread,
+ &bytes_written);
+ if(result)
+ return result;
+ else if(nread != (int)bytes_written) {
+ failf(data, "Failed uploading data");
+ return CURLE_WRITE_ERROR;
}
+ else if(data->set.crlf)
+ k->buf = data->state.buffer; /* put it back on the buffer */
- /* Update read/write counters */
- if(conn->bytecountp)
- *conn->bytecountp = bytecount; /* read count */
- if(conn->writebytecountp)
- *conn->writebytecountp = writebytecount; /* write count */
+ }
- now = Curl_tvnow();
- if(Curl_pgrsUpdate(conn))
- urg = CURLE_ABORTED_BY_CALLBACK;
- else
- urg = Curl_speedcheck (data, now);
- if (urg)
- return urg;
-
- if(data->progress.ulspeed > conn->upload_bufsize) {
- /* If we're transfering more data per second than fits in our buffer,
- we increase the buffer size to adjust to the current
- speed. However, we must not set it larger than BUFSIZE. We don't
- adjust it downwards again since we don't see any point in that!
- */
- conn->upload_bufsize=(long)min(data->progress.ulspeed, BUFSIZE);
- }
+ } while(0); /* just to break out from! */
- if (data->set.timeout &&
- ((Curl_tvdiff(now, start)/1000) >= data->set.timeout)) {
- failf (data, "Operation timed out with %d out of %d bytes received",
- bytecount, conn->size);
- return CURLE_OPERATION_TIMEOUTED;
- }
+ if(didwhat) {
+ /* Update read/write counters */
+ if(conn->bytecountp)
+ *conn->bytecountp = k->bytecount; /* read count */
+ if(conn->writebytecountp)
+ *conn->writebytecountp = k->writebytecount; /* write count */
+ }
+ else {
+ /* no read no write, this is a timeout? */
+ if (k->write_after_100_header) {
+ /* 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;
+ }
+ }
+ k->now = Curl_tvnow();
+ if(Curl_pgrsUpdate(conn))
+ result = CURLE_ABORTED_BY_CALLBACK;
+ else
+ result = Curl_speedcheck (data, k->now);
+ if (result)
+ return result;
+
+ if(data->progress.ulspeed > conn->upload_bufsize) {
+ /* If we're transfering more data per second than fits in our buffer,
+ we increase the buffer size to adjust to the current
+ speed. However, we must not set it larger than BUFSIZE. We don't
+ adjust it downwards again since we don't see any point in that!
+ */
+ conn->upload_bufsize=(long)min(data->progress.ulspeed, BUFSIZE);
+ }
+
+ 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);
+ return CURLE_OPERATION_TIMEOUTED;
+ }
+
+ if(!k->keepon) {
+ /*
+ * The transfer has been performed. Just make some general checks before
+ * returning.
+ */
+
+ if(!(data->set.no_body) && k->contentlength &&
+ (k->bytecount != k->contentlength) &&
+ !conn->newurl) {
+ failf(data, "transfer closed with %d bytes remaining to read",
+ k->contentlength-k->bytecount);
+ return CURLE_PARTIAL_FILE;
}
+ else if(conn->bits.chunk && conn->proto.http->chunk.datasize) {
+ failf(data, "transfer closed with at least %d bytes remaining",
+ conn->proto.http->chunk.datasize);
+ return CURLE_PARTIAL_FILE;
+ }
+ if(Curl_pgrsUpdate(conn))
+ return CURLE_ABORTED_BY_CALLBACK;
}
- /*
- * The tranfer has been performed. Just make some general checks before
- * returning.
- */
+ /* Now update the "done" boolean we return */
+ *done = !k->keepon;
+
+ return CURLE_OK;
+}
+
+CURLcode Curl_readwrite_init(struct connectdata *conn)
+{
+ struct SessionHandle *data = conn->data;
+ struct Curl_transfer_keeper *k = &conn->keep;
+
+ memset(k, 0, sizeof(struct Curl_transfer_keeper));
+
+ k->start = Curl_tvnow(); /* start time */
+ k->now = k->start; /* current time is now */
+ k->header = TRUE; /* assume header */
+ k->httpversion = -1; /* unknown at this point */
+ k->conn = (struct connectdata *)conn; /* store the connection */
+
+ data = conn->data; /* there's the root struct */
+ k->buf = data->state.buffer;
+ k->maxfd = (conn->sockfd>conn->writesockfd?
+ conn->sockfd:conn->writesockfd)+1;
+ k->hbufp = data->state.headerbuff;
- if(!(data->set.no_body) && contentlength &&
- (bytecount != contentlength)) {
- failf(data, "transfer closed with %d bytes remaining to read",
- contentlength-bytecount);
- return CURLE_PARTIAL_FILE;
+ Curl_pgrsTime(data, TIMER_PRETRANSFER);
+ Curl_speedinit(data);
+
+ if (!conn->getheader) {
+ k->header = FALSE;
+ if(conn->size > 0)
+ Curl_pgrsSetDownloadSize(data, conn->size);
}
- else if(conn->bits.chunk && conn->proto.http->chunk.datasize) {
- failf(data, "transfer closed with at least %d bytes remaining",
- conn->proto.http->chunk.datasize);
- return CURLE_PARTIAL_FILE;
+ /* we want header and/or body, if neither then don't do this! */
+ if(conn->getheader || !data->set.no_body) {
+
+ FD_ZERO (&k->readfd); /* clear it */
+ if(conn->sockfd != -1) {
+ 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)
+ /* wait with write until we either got 100-continue or a timeout */
+ k->write_after_100_header = TRUE;
+ else {
+ FD_SET (conn->writesockfd, &k->writefd); /* write socket */
+ k->keepon |= KEEP_WRITE;
+ }
+ }
+
+ /* get these in backup variables to be able to restore them on each lap in
+ the select() loop */
+ k->rkeepfd = k->readfd;
+ k->wkeepfd = k->writefd;
+
}
- if(Curl_pgrsUpdate(conn))
- return CURLE_ABORTED_BY_CALLBACK;
return CURLE_OK;
}
-CURLcode Curl_perform(struct SessionHandle *data)
+void Curl_single_fdset(struct connectdata *conn,
+ fd_set *read_fd_set,
+ fd_set *write_fd_set,
+ fd_set *exc_fd_set,
+ int *max_fd)
{
- CURLcode res;
- struct connectdata *conn=NULL;
- bool port=TRUE; /* allow data->set.use_port to set port to use */
- char *newurl = NULL; /* possibly a new URL to follow to! */
-#ifdef HAVE_SIGNAL
- /* storage for the previous bag^H^H^HSIGPIPE signal handler :-) */
- void (*prev_signal)(int sig);
+ *max_fd = -1; /* init */
+ if(conn->keep.keepon & KEEP_READ) {
+ FD_SET(conn->sockfd, read_fd_set);
+ *max_fd = conn->sockfd;
+ }
+ if(conn->keep.keepon & KEEP_WRITE) {
+ FD_SET(conn->writesockfd, write_fd_set);
+ if(conn->writesockfd > *max_fd)
+ *max_fd = conn->writesockfd;
+ }
+ /* we don't use exceptions, only touch that one to prevent compiler
+ warnings! */
+ *exc_fd_set = *exc_fd_set;
+}
+
+
+/*
+ * Transfer()
+ *
+ * This function is what performs the actual transfer. It is capable of
+ * doing both ways simultaneously.
+ * 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.
+ *
+ * Parts of this function was once written by the friendly Mark Butler
+ * <butlerm@xmission.com>.
+ */
+
+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->sockfd == -1) && (conn->writesockfd == -1))
+ /* 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->getheader && data->set.no_body)
+ return CURLE_OK;
+
+ while (!done) {
+ struct timeval interval;
+ k->readfd = k->rkeepfd; /* set these every lap in the loop */
+ k->writefd = k->wkeepfd;
+ interval.tv_sec = 1;
+ interval.tv_usec = 0;
+
+ switch (select (k->maxfd, &k->readfd, &k->writefd, NULL,
+ &interval)) {
+ case -1: /* select() error, stop reading */
+#ifdef EINTR
+ /* The EINTR is not serious, and it seems you might get this more
+ ofen when using the lib in a multi-threaded environment! */
+ if(errno == EINTR)
+ ;
+ else
#endif
+ 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;
+}
+
+CURLcode Curl_pretransfer(struct SessionHandle *data)
+{
if(!data->change.url)
/* we can't do anything wihout URL */
return CURLE_URL_MALFORMAT;
data->state.this_is_a_follow = FALSE; /* reset this */
data->state.errorbuf = FALSE; /* no error has occurred */
+ /* Allow data->set.use_port to set which port to use. This needs to be
+ * disabled for example when we follow Location: headers to URLs using
+ * different ports! */
+ data->state.allow_port = TRUE;
+
#if defined(HAVE_SIGNAL) && defined(SIGPIPE)
/*************************************************************
* Tell signal handler to ignore SIGPIPE
*************************************************************/
- prev_signal = signal(SIGPIPE, SIG_IGN);
+ data->state.prev_signal = signal(SIGPIPE, SIG_IGN);
#endif
Curl_initinfo(data); /* reset session-specific information "variables" */
Curl_pgrsStartNow(data);
+ return CURLE_OK;
+}
+
+CURLcode Curl_posttransfer(struct SessionHandle *data)
+{
+#if defined(HAVE_SIGNAL) && defined(SIGPIPE)
+ /* restore the signal handler for SIGPIPE before we get back */
+ signal(SIGPIPE, data->state.prev_signal);
+#endif
+
+ return CURLE_OK;
+}
+
+CURLcode Curl_perform(struct SessionHandle *data)
+{
+ CURLcode res;
+ CURLcode res2;
+ struct connectdata *conn=NULL;
+ char *newurl = NULL; /* possibly a new URL to follow to! */
+
+ res = Curl_pretransfer(data);
+ if(res)
+ return res;
+
/*
* It is important that there is NO 'return' from this function any any
* other place than falling down the bottom! This is because we have cleanup
do {
Curl_pgrsTime(data, TIMER_STARTSINGLE);
- res = Curl_connect(data, &conn, port);
+ res = Curl_connect(data, &conn);
if(res == CURLE_OK) {
- res = Curl_do(conn);
-
- if((CURLE_WRITE_ERROR == res) && conn->bits.reuse) {
- /* This was a re-use of a connection and we got a write error in the
- * DO-phase. Then we DISCONNECT this connection and have another
- * attempt to CONNECT and then DO again! The retry cannot possibly
- * find another connection to re-use, since we only keep one possible
- * connection for each.
- */
-
- infof(data, "The re-used connection seems dead, get a new one\n");
-
- conn->bits.close = TRUE; /* enforce close of this connetion */
- res = Curl_done(conn); /* we are so done with this */
- if(CURLE_OK == res) {
- /* Now, redo the connect */
- res = Curl_connect(data, &conn, port);
- if(CURLE_OK == res)
- /* ... finally back to actually retry the DO phase */
- res = Curl_do(conn);
- }
- }
+ res = Curl_do(&conn);
if(res == CURLE_OK) {
CURLcode res2; /* just a local extra result container */
char prot[16]; /* URL protocol string storage */
char letter; /* used for a silly sscanf */
- port=TRUE; /* by default we use the user set port number even after
- a Location: */
-
if (data->set.maxredirs && (data->set.followlocation >= data->set.maxredirs)) {
failf(data,"Maximum (%d) redirects followed", data->set.maxredirs);
res=CURLE_TOO_MANY_REDIRECTS;
free(url_clone);
newurl = newest;
}
- else {
- /* This is an absolute URL, don't use the custom port number */
- port = FALSE;
- }
+ else
+ /* This is an absolute URL, don't allow the custom port number */
+ data->state.allow_port = FALSE;
if(data->change.url_alloc)
free(data->change.url);
if(newurl)
free(newurl);
-#if defined(HAVE_SIGNAL) && defined(SIGPIPE)
- /* restore the signal handler for SIGPIPE before we get back */
- signal(SIGPIPE, prev_signal);
-#endif
+ /* run post-transfer uncondionally, but don't clobber the return code if
+ we already have an error code recorder */
+ res2 = Curl_posttransfer(data);
+ if(!res && res2)
+ res = res2;
return res;
}
projects / platform / upstream / curl.git / commitdiff