1 /***************************************************************************
3 * Project ___| | | | _ \| |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
8 * Copyright (C) 1998 - 2013, Daniel Stenberg, <daniel@haxx.se>, et al.
10 * This software is licensed as described in the file COPYING, which
11 * you should have received as part of this distribution. The terms
12 * are also available at http://curl.haxx.se/docs/copyright.html.
14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15 * copies of the Software, and permit persons to whom the Software is
16 * furnished to do so, under the terms of the COPYING file.
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
21 * 'pingpong' is for generic back-and-forth support functions used by FTP,
22 * IMAP, POP3, SMTP and whatever more that likes them.
24 ***************************************************************************/
26 #include "curl_setup.h"
32 #include "speedcheck.h"
35 #include "non-ascii.h"
36 #include "vtls/vtls.h"
38 #define _MPRINTF_REPLACE /* use our functions only */
39 #include <curl/mprintf.h>
41 #include "curl_memory.h"
42 /* The last #include file should be: */
47 /* Returns timeout in ms. 0 or negative number means the timeout has already
49 long Curl_pp_state_timeout(struct pingpong *pp)
51 struct connectdata *conn = pp->conn;
52 struct SessionHandle *data=conn->data;
53 long timeout_ms; /* in milliseconds */
54 long timeout2_ms; /* in milliseconds */
55 long response_time= (data->set.server_response_timeout)?
56 data->set.server_response_timeout: pp->response_time;
58 /* if CURLOPT_SERVER_RESPONSE_TIMEOUT is set, use that to determine
59 remaining time, or use pp->response because SERVER_RESPONSE_TIMEOUT is
60 supposed to govern the response for any given server response, not for
61 the time from connect to the given server response. */
63 /* Without a requested timeout, we only wait 'response_time' seconds for the
64 full response to arrive before we bail out */
65 timeout_ms = response_time -
66 Curl_tvdiff(Curl_tvnow(), pp->response); /* spent time */
68 if(data->set.timeout) {
69 /* if timeout is requested, find out how much remaining time we have */
70 timeout2_ms = data->set.timeout - /* timeout time */
71 Curl_tvdiff(Curl_tvnow(), conn->now); /* spent time */
73 /* pick the lowest number */
74 timeout_ms = CURLMIN(timeout_ms, timeout2_ms);
83 CURLcode Curl_pp_statemach(struct pingpong *pp, bool block)
85 struct connectdata *conn = pp->conn;
86 curl_socket_t sock = conn->sock[FIRSTSOCKET];
89 long timeout_ms = Curl_pp_state_timeout(pp);
90 struct SessionHandle *data=conn->data;
91 CURLcode result = CURLE_OK;
94 failf(data, "server response timeout");
95 return CURLE_OPERATION_TIMEDOUT; /* already too little time */
99 interval_ms = 1000; /* use 1 second timeout intervals */
100 if(timeout_ms < interval_ms)
101 interval_ms = timeout_ms;
104 interval_ms = 0; /* immediate */
106 if(Curl_pp_moredata(pp))
107 /* We are receiving and there is data in the cache so just read it */
109 else if(!pp->sendleft && Curl_ssl_data_pending(conn, FIRSTSOCKET))
110 /* We are receiving and there is data ready in the SSL library */
113 rc = Curl_socket_ready(pp->sendleft?CURL_SOCKET_BAD:sock, /* reading */
114 pp->sendleft?sock:CURL_SOCKET_BAD, /* writing */
118 /* if we didn't wait, we don't have to spend time on this now */
119 if(Curl_pgrsUpdate(conn))
120 result = CURLE_ABORTED_BY_CALLBACK;
122 result = Curl_speedcheck(data, Curl_tvnow());
129 failf(data, "select/poll error");
130 result = CURLE_OUT_OF_MEMORY;
133 result = pp->statemach_act(conn);
138 /* initialize stuff to prepare for reading a fresh new response */
139 void Curl_pp_init(struct pingpong *pp)
141 struct connectdata *conn = pp->conn;
143 pp->linestart_resp = conn->data->state.buffer;
144 pp->pending_resp = TRUE;
145 pp->response = Curl_tvnow(); /* start response time-out now! */
150 /***********************************************************************
154 * Send the formated string as a command to a pingpong server. Note that
155 * the string should not have any CRLF appended, as this function will
156 * append the necessary things itself.
158 * made to never block
160 CURLcode Curl_pp_vsendf(struct pingpong *pp,
164 ssize_t bytes_written;
169 struct connectdata *conn = pp->conn;
170 struct SessionHandle *data = conn->data;
173 enum protection_level data_sec = conn->data_prot;
176 DEBUGASSERT(pp->sendleft == 0);
177 DEBUGASSERT(pp->sendsize == 0);
178 DEBUGASSERT(pp->sendthis == NULL);
180 fmt_crlf = aprintf("%s\r\n", fmt); /* append a trailing CRLF */
182 return CURLE_OUT_OF_MEMORY;
184 s = vaprintf(fmt_crlf, args); /* trailing CRLF appended */
187 return CURLE_OUT_OF_MEMORY;
190 write_len = strlen(s);
194 error = Curl_convert_to_network(data, s, write_len);
195 /* Curl_convert_to_network calls failf if unsuccessful */
202 conn->data_prot = PROT_CMD;
204 error = Curl_write(conn, conn->sock[FIRSTSOCKET], s, write_len,
207 DEBUGASSERT(data_sec > PROT_NONE && data_sec < PROT_LAST);
208 conn->data_prot = data_sec;
216 if(conn->data->set.verbose)
217 Curl_debug(conn->data, CURLINFO_HEADER_OUT,
218 s, (size_t)bytes_written, conn);
220 if(bytes_written != (ssize_t)write_len) {
221 /* the whole chunk was not sent, keep it around and adjust sizes */
223 pp->sendsize = write_len;
224 pp->sendleft = write_len - bytes_written;
229 pp->sendleft = pp->sendsize = 0;
230 pp->response = Curl_tvnow();
237 /***********************************************************************
241 * Send the formated string as a command to a pingpong server. Note that
242 * the string should not have any CRLF appended, as this function will
243 * append the necessary things itself.
245 * made to never block
247 CURLcode Curl_pp_sendf(struct pingpong *pp,
248 const char *fmt, ...)
254 res = Curl_pp_vsendf(pp, fmt, ap);
264 * Reads a piece of a server response.
266 CURLcode Curl_pp_readresp(curl_socket_t sockfd,
268 int *code, /* return the server code if done */
269 size_t *size) /* size of the response */
271 ssize_t perline; /* count bytes per line */
275 struct connectdata *conn = pp->conn;
276 struct SessionHandle *data = conn->data;
277 char * const buf = data->state.buffer;
278 CURLcode result = CURLE_OK;
280 *code = 0; /* 0 for errors or not done */
283 ptr=buf + pp->nread_resp;
285 /* number of bytes in the current line, so far */
286 perline = (ssize_t)(ptr-pp->linestart_resp);
290 while((pp->nread_resp<BUFSIZE) && (keepon && !result)) {
293 /* we had data in the "cache", copy that instead of doing an actual
296 * pp->cache_size is cast to ssize_t here. This should be safe, because
297 * it would have been populated with something of size int to begin
298 * with, even though its datatype may be larger than an int.
300 DEBUGASSERT((ptr+pp->cache_size) <= (buf+BUFSIZE+1));
301 memcpy(ptr, pp->cache, pp->cache_size);
302 gotbytes = (ssize_t)pp->cache_size;
303 free(pp->cache); /* free the cache */
304 pp->cache = NULL; /* clear the pointer */
305 pp->cache_size = 0; /* zero the size just in case */
310 enum protection_level prot = conn->data_prot;
311 conn->data_prot = PROT_CLEAR;
313 DEBUGASSERT((ptr+BUFSIZE-pp->nread_resp) <= (buf+BUFSIZE+1));
314 res = Curl_read(conn, sockfd, ptr, BUFSIZE-pp->nread_resp,
317 DEBUGASSERT(prot > PROT_NONE && prot < PROT_LAST);
318 conn->data_prot = prot;
320 if(res == CURLE_AGAIN)
321 return CURLE_OK; /* return */
323 if((res == CURLE_OK) && (gotbytes > 0))
324 /* convert from the network encoding */
325 res = Curl_convert_from_network(data, ptr, gotbytes);
326 /* Curl_convert_from_network calls failf if unsuccessful */
328 if(CURLE_OK != res) {
329 result = (CURLcode)res; /* Set outer result variable to this error. */
336 else if(gotbytes <= 0) {
338 result = CURLE_RECV_ERROR;
339 failf(data, "response reading failed");
342 /* we got a whole chunk of data, which can be anything from one
343 * byte to a set of lines and possible just a piece of the last
346 ssize_t clipamount = 0;
347 bool restart = FALSE;
349 data->req.headerbytecount += (long)gotbytes;
351 pp->nread_resp += gotbytes;
352 for(i = 0; i < gotbytes; ptr++, i++) {
355 /* a newline is CRLF in pp-talk, so the CR is ignored as
356 the line isn't really terminated until the LF comes */
358 /* output debug output if that is requested */
360 if(!conn->sec_complete)
362 if(data->set.verbose)
363 Curl_debug(data, CURLINFO_HEADER_IN,
364 pp->linestart_resp, (size_t)perline, conn);
367 * We pass all response-lines to the callback function registered
368 * for "headers". The response lines can be seen as a kind of
371 result = Curl_client_write(conn, CLIENTWRITE_HEADER,
372 pp->linestart_resp, perline);
376 if(pp->endofresp(conn, pp->linestart_resp, perline, code)) {
377 /* This is the end of the last line, copy the last line to the
378 start of the buffer and zero terminate, for old times sake */
379 size_t n = ptr - pp->linestart_resp;
380 memmove(buf, pp->linestart_resp, n);
381 buf[n]=0; /* zero terminate */
383 pp->linestart_resp = ptr+1; /* advance pointer */
384 i++; /* skip this before getting out */
386 *size = pp->nread_resp; /* size of the response */
387 pp->nread_resp = 0; /* restart */
390 perline=0; /* line starts over here */
391 pp->linestart_resp = ptr+1;
395 if(!keepon && (i != gotbytes)) {
396 /* We found the end of the response lines, but we didn't parse the
397 full chunk of data we have read from the server. We therefore need
398 to store the rest of the data to be checked on the next invoke as
399 it may actually contain another end of response already! */
400 clipamount = gotbytes - i;
402 DEBUGF(infof(data, "Curl_pp_readresp_ %d bytes of trailing "
403 "server response left\n",
408 if((perline == gotbytes) && (gotbytes > BUFSIZE/2)) {
409 /* We got an excessive line without newlines and we need to deal
410 with it. We keep the first bytes of the line then we throw
412 infof(data, "Excessive server response line length received, "
413 "%zd bytes. Stripping\n", gotbytes);
416 /* we keep 40 bytes since all our pingpong protocols are only
417 interested in the first piece */
420 else if(pp->nread_resp > BUFSIZE/2) {
421 /* We got a large chunk of data and there's potentially still
422 trailing data to take care of, so we put any such part in the
423 "cache", clear the buffer to make space and restart. */
424 clipamount = perline;
428 else if(i == gotbytes)
432 pp->cache_size = clipamount;
433 pp->cache = malloc(pp->cache_size);
435 memcpy(pp->cache, pp->linestart_resp, pp->cache_size);
437 return CURLE_OUT_OF_MEMORY;
440 /* now reset a few variables to start over nicely from the start of
442 pp->nread_resp = 0; /* start over from scratch in the buffer */
443 ptr = pp->linestart_resp = buf;
447 } /* there was data */
449 } /* while there's buffer left and loop is requested */
451 pp->pending_resp = FALSE;
456 int Curl_pp_getsock(struct pingpong *pp,
457 curl_socket_t *socks,
460 struct connectdata *conn = pp->conn;
463 return GETSOCK_BLANK;
465 socks[0] = conn->sock[FIRSTSOCKET];
469 return GETSOCK_WRITESOCK(0);
473 return GETSOCK_READSOCK(0);
476 CURLcode Curl_pp_flushsend(struct pingpong *pp)
478 /* we have a piece of a command still left to send */
479 struct connectdata *conn = pp->conn;
481 CURLcode result = CURLE_OK;
482 curl_socket_t sock = conn->sock[FIRSTSOCKET];
484 result = Curl_write(conn, sock, pp->sendthis + pp->sendsize -
485 pp->sendleft, pp->sendleft, &written);
489 if(written != (ssize_t)pp->sendleft) {
490 /* only a fraction was sent */
491 pp->sendleft -= written;
496 pp->sendleft = pp->sendsize = 0;
497 pp->response = Curl_tvnow();
502 CURLcode Curl_pp_disconnect(struct pingpong *pp)
511 bool Curl_pp_moredata(struct pingpong *pp)
513 return (!pp->sendleft && pp->cache && pp->nread_resp < pp->cache_size) ?