re-use connections (for pipelining) before the name resolving is done.
Changelog
+Daniel (23 October 2006)
+- Ravi Pratap provided a major update with pipelining fixes. We also no longer
+ re-use connections (for pipelining) before the name resolving is done.
+
Daniel (21 October 2006)
- Nir Soffer made the tests/libtest/Makefile.am use a proper variable for all
the single test applications' link and dependences, so that you easier can
return CURLM_BAD_EASY_HANDLE;
if (easy->easy_handle->state.pipe_broke) {
- infof(easy->easy_handle, "Pipe broke: handle 0x%x\n", easy);
+ infof(easy->easy_handle, "Pipe broke: handle 0x%x, url = %s\n",
+ easy, easy->easy_handle->reqdata.path);
if(easy->easy_handle->state.is_in_pipeline) {
/* Head back to the CONNECT state */
multistate(easy, CURLM_STATE_CONNECT);
return CURLE_OK;
}
+#define MIN(a,b) (a < b ? a : b)
+
void Curl_read_rewind(struct connectdata *conn,
size_t extraBytesRead)
{
+ char buf[512 + 1];
+ size_t bytesToShow;
+
conn->read_pos -= extraBytesRead;
conn->bits.stream_was_rewound = TRUE;
-}
-#define MIN(a,b) (a < b ? a : b)
+ bytesToShow = MIN(conn->buf_len - conn->read_pos, sizeof(buf)-1);
+ memcpy(buf, conn->master_buffer + conn->read_pos, bytesToShow);
+ buf[bytesToShow] = '\0';
+
+ DEBUGF(infof(conn->data,
+ "Buffer after stream rewind (read_pos = %d): [%s]",
+ conn->read_pos, buf));
+}
/*
* Internal read-from-socket function. This is meant to deal with plain
int Curl_read(struct connectdata *conn, /* connection data */
curl_socket_t sockfd, /* read from this socket */
char *buf, /* store read data here */
- size_t buffersize, /* max amount to read */
+ size_t sizerequested, /* max amount to read */
ssize_t *n) /* amount bytes read */
{
ssize_t nread;
- size_t bytestocopy = MIN(conn->buf_len - conn->read_pos, buffersize);
- size_t bytesremaining = buffersize - bytestocopy;
+ size_t bytestocopy = MIN(conn->buf_len - conn->read_pos, sizerequested);
+ size_t bytesfromsocket = 0;
/* Set 'num' to 0 or 1, depending on which socket that has been sent here.
If it is the second socket, we set num to 1. Otherwise to 0. This lets
*n=0; /* reset amount to zero */
- bytesremaining = MIN(bytesremaining, sizeof(conn->master_buffer));
-
- /* Copy from our master buffer first */
- memcpy(buf, conn->master_buffer + conn->read_pos, bytestocopy);
- conn->read_pos += bytestocopy;
+ /* Copy from our master buffer first if we have some unread data there*/
+ if (bytestocopy > 0) {
+ memcpy(buf, conn->master_buffer + conn->read_pos, bytestocopy);
+ conn->read_pos += bytestocopy;
+ conn->bits.stream_was_rewound = FALSE;
- conn->bits.stream_was_rewound = FALSE;
-
- *n = (ssize_t)bytestocopy;
-
- if (bytesremaining == 0) {
- return CURLE_OK;
+ *n = (ssize_t)bytestocopy;
+ return CURLE_OK;
}
+ /* If we come here, it means that there is no data to read from the buffer,
+ * so we read from the socket */
+ bytesfromsocket = MIN(sizerequested, sizeof(conn->master_buffer));
+
if(conn->ssl[num].use) {
- nread = Curl_ssl_recv(conn, num, conn->master_buffer, bytesremaining);
+ nread = Curl_ssl_recv(conn, num, conn->master_buffer, bytesfromsocket);
- if(nread == -1 && bytestocopy == 0) {
+ if(nread == -1)
return -1; /* -1 from Curl_ssl_recv() means EWOULDBLOCK */
- }
-
- } else {
+ }
+ else {
if(conn->sec_complete)
- nread = Curl_sec_read(conn, sockfd, conn->master_buffer, bytesremaining);
+ nread = Curl_sec_read(conn, sockfd, conn->master_buffer,
+ bytesfromsocket);
else
- nread = sread(sockfd, conn->master_buffer, bytesremaining);
+ nread = sread(sockfd, conn->master_buffer, bytesfromsocket);
- if(-1 == nread && bytestocopy == 0) {
+ if(-1 == nread) {
int err = Curl_sockerrno();
#ifdef USE_WINSOCK
if(WSAEWOULDBLOCK == err)
}
}
- if (nread > 0) {
- memcpy(buf, conn->master_buffer, nread);
+ if (nread >= 0) {
+ memcpy(buf, conn->master_buffer, nread);
- conn->buf_len = nread;
- conn->read_pos = nread;
- *n += nread;
+ conn->buf_len = nread;
+ conn->read_pos = nread;
+ *n = nread;
}
return CURLE_OK;
failf(data, "Maximum file size exceeded");
return CURLE_FILESIZE_EXCEEDED;
}
- if(contentlength >= 0)
+ if(contentlength >= 0) {
k->size = contentlength;
+ k->maxdownload = k->size;
+ }
else {
/* Negative Content-Length is really odd, and we know it
happens for example when older Apache servers send large
Curl_debug(data, CURLINFO_DATA_IN, data->state.headerbuff,
(size_t)k->hbuflen, conn);
if(k->badheader == HEADER_PARTHEADER)
- Curl_debug(data, CURLINFO_DATA_IN,
+ Curl_debug(data, CURLINFO_DATA_IN,
k->str, (size_t)nread, conn);
}
else
- Curl_debug(data, CURLINFO_DATA_IN,
+ Curl_debug(data, CURLINFO_DATA_IN,
k->str, (size_t)nread, conn);
}
if((-1 != k->maxdownload) &&
(k->bytecount + nread >= k->maxdownload)) {
- size_t excess = (size_t)(k->bytecount +
- (curl_off_t)nread - k->maxdownload);
-
- if (excess > 0) {
- infof(data, "Rewinding stream by : %d bytes\n", excess);
- Curl_read_rewind(conn, excess);
- conn->bits.stream_was_rewound = TRUE;
+ curl_off_t excess = k->bytecount +
+ ((curl_off_t) nread) - k->maxdownload;
+ if (excess > 0 && !k->ignorebody) {
+ infof(data,
+ "Rewinding stream by : %" FORMAT_OFF_T
+ " bytes on url %s (size = %" FORMAT_OFF_T
+ ", maxdownload = %" FORMAT_OFF_T
+ ", bytecount = %" FORMAT_OFF_T ", nread = %d)\n",
+ excess, conn->data->reqdata.path,
+ k->size, k->maxdownload, k->bytecount, nread);
+ Curl_read_rewind(conn, excess);
}
nread = (ssize_t) (k->maxdownload - k->bytecount);
}
curr = curr->next;
}
+
return 0;
}
}
else
#endif
- data->state.pipe_broke = TRUE;
+ data->state.pipe_broke = TRUE;
Curl_llist_remove(pipe, curr, NULL);
curr = next;
}
/* NULL pointer means not filled-in entry */
continue;
+#ifdef USE_ARES
+ /* ip_addr_str is NULL only if the resolving of the name hasn't completed
+ yet and until then we don't re-use this connection */
+ if (!check->ip_addr_str)
+ continue;
+#endif
+
if(check->inuse && !canPipeline)
/* can only happen within multi handles, and means that another easy
handle is using this connection */
continue;
- if (check->send_pipe->size >= MAX_PIPELINE_LENGTH ||
+ if (check->send_pipe->size +
check->recv_pipe->size >= MAX_PIPELINE_LENGTH)
continue;
}
if(match) {
+
bool dead = SocketIsDead(check->sock[FIRSTSOCKET]);
if(dead) {
- /*
- */
- check->data = data;
- infof(data, "Connection %d seems to be dead!\n", i);
- Curl_disconnect(check); /* disconnect resources */
- data->state.connc->connects[i]=NULL; /* nothing here */
+ if (!check->is_in_pipeline) {
+ check->data = data;
+ infof(data, "Connection %d seems to be dead!\n", i);
+
+ Curl_disconnect(check); /* disconnect resources */
+ data->state.connc->connects[i]=NULL; /* nothing here */
+ }
+ else {
+ /* In the pipelining case, freeing the connection right away
+ * doesn't work. Instead, we mark the connection for close
+ * so that the handles will detect this automatically when
+ * they try to do something and deal with it there.
+ * Prematurely freeing this connection prevents handles that
+ * have already finished with their transfers to shut down
+ * cleanly.
+ */
+ infof(data, "Connection %d seems dead - marking for close\n", i);
+ check->bits.close = TRUE;
+ }
/* There's no need to continue searching, because we only store
one connection for each unique set of identifiers */
handle in a multi stack may nick it */
if (canPipeline) {
- /* Mark the connection as being in a pipeline */
- check->is_in_pipeline = TRUE;
+ /* Mark the connection as being in a pipeline */
+ check->is_in_pipeline = TRUE;
}
+ check->connectindex = i; /* Set this appropriately since it might have
+ been set to -1 when the easy was removed
+ from the multi */
*usethis = check;
return TRUE; /* yes, we found one to use! */
}
conn->readchannel_inuse = FALSE;
conn->writechannel_inuse = FALSE;
+ conn->read_pos = 0;
+ conn->buf_len = 0;
+
/* Initialize the pipeline lists */
conn->send_pipe = Curl_llist_alloc((curl_llist_dtor) llist_dtor);
conn->recv_pipe = Curl_llist_alloc((curl_llist_dtor) llist_dtor);
infof(data, "Re-using existing connection! (#%ld) with host %s\n",
conn->connectindex,
conn->bits.httpproxy?conn->proxy.dispname:conn->host.dispname);
-#ifdef CURLRES_ASYNCH
- if(!conn->ip_addr_str) {
- infof(data, "... but it is not resolved yet!\n");
- *async = TRUE;
- }
-#endif
}
else {
/*
if(Curl_removeHandleFromPipeline(data, conn->recv_pipe) &&
conn->readchannel_inuse)
- conn->readchannel_inuse--;
+ conn->readchannel_inuse = FALSE;
if(Curl_removeHandleFromPipeline(data, conn->send_pipe) &&
conn->writechannel_inuse)
- conn->writechannel_inuse--;
+ conn->writechannel_inuse = FALSE;
/* cleanups done even if the connection is re-used */
if(data->reqdata.rangestringalloc) {
their responses on this pipeline */
char master_buffer[BUFSIZE]; /* The master buffer for this connection. */
- size_t read_pos;
- size_t buf_len;
+ size_t read_pos; /* Current read position in the master buffer */
+ size_t buf_len; /* Length of the buffer?? */
/*************** Request - specific items ************/
projects / thirdparty / curl.git / commitdiff
