1: /***************************************************************************
2: * _ _ ____ _
3: * Project ___| | | | _ \| |
4: * / __| | | | |_) | |
5: * | (__| |_| | _ <| |___
6: * \___|\___/|_| \_\_____|
7: *
8: * Copyright (C) 1998 - 2019, Daniel Stenberg, <daniel@haxx.se>, et al.
9: *
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 https://curl.haxx.se/docs/copyright.html.
13: *
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.
17: *
18: * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19: * KIND, either express or implied.
20: *
21: * 'pingpong' is for generic back-and-forth support functions used by FTP,
22: * IMAP, POP3, SMTP and whatever more that likes them.
23: *
24: ***************************************************************************/
25:
26: #include "curl_setup.h"
27:
28: #include "urldata.h"
29: #include "sendf.h"
30: #include "select.h"
31: #include "progress.h"
32: #include "speedcheck.h"
33: #include "pingpong.h"
34: #include "multiif.h"
35: #include "non-ascii.h"
36: #include "vtls/vtls.h"
37:
38: /* The last 3 #include files should be in this order */
39: #include "curl_printf.h"
40: #include "curl_memory.h"
41: #include "memdebug.h"
42:
43: #ifdef USE_PINGPONG
44:
45: /* Returns timeout in ms. 0 or negative number means the timeout has already
46: triggered */
47: time_t Curl_pp_state_timeout(struct pingpong *pp, bool disconnecting)
48: {
49: struct connectdata *conn = pp->conn;
50: struct Curl_easy *data = conn->data;
51: time_t timeout_ms; /* in milliseconds */
52: long response_time = (data->set.server_response_timeout)?
53: data->set.server_response_timeout: pp->response_time;
54:
55: /* if CURLOPT_SERVER_RESPONSE_TIMEOUT is set, use that to determine
56: remaining time, or use pp->response because SERVER_RESPONSE_TIMEOUT is
57: supposed to govern the response for any given server response, not for
58: the time from connect to the given server response. */
59:
60: /* Without a requested timeout, we only wait 'response_time' seconds for the
61: full response to arrive before we bail out */
62: timeout_ms = response_time -
63: (time_t)Curl_timediff(Curl_now(), pp->response); /* spent time */
64:
65: if(data->set.timeout && !disconnecting) {
66: /* if timeout is requested, find out how much remaining time we have */
67: time_t timeout2_ms = data->set.timeout - /* timeout time */
68: (time_t)Curl_timediff(Curl_now(), conn->now); /* spent time */
69:
70: /* pick the lowest number */
71: timeout_ms = CURLMIN(timeout_ms, timeout2_ms);
72: }
73:
74: return timeout_ms;
75: }
76:
77: /*
78: * Curl_pp_statemach()
79: */
80: CURLcode Curl_pp_statemach(struct pingpong *pp, bool block,
81: bool disconnecting)
82: {
83: struct connectdata *conn = pp->conn;
84: curl_socket_t sock = conn->sock[FIRSTSOCKET];
85: int rc;
86: time_t interval_ms;
87: time_t timeout_ms = Curl_pp_state_timeout(pp, disconnecting);
88: struct Curl_easy *data = conn->data;
89: CURLcode result = CURLE_OK;
90:
91: if(timeout_ms <= 0) {
92: failf(data, "server response timeout");
93: return CURLE_OPERATION_TIMEDOUT; /* already too little time */
94: }
95:
96: if(block) {
97: interval_ms = 1000; /* use 1 second timeout intervals */
98: if(timeout_ms < interval_ms)
99: interval_ms = timeout_ms;
100: }
101: else
102: interval_ms = 0; /* immediate */
103:
104: if(Curl_ssl_data_pending(conn, FIRSTSOCKET))
105: rc = 1;
106: else if(Curl_pp_moredata(pp))
107: /* We are receiving and there is data in the cache so just read it */
108: rc = 1;
109: else if(!pp->sendleft && Curl_ssl_data_pending(conn, FIRSTSOCKET))
110: /* We are receiving and there is data ready in the SSL library */
111: rc = 1;
112: else
113: rc = Curl_socket_check(pp->sendleft?CURL_SOCKET_BAD:sock, /* reading */
114: CURL_SOCKET_BAD,
115: pp->sendleft?sock:CURL_SOCKET_BAD, /* writing */
116: interval_ms);
117:
118: if(block) {
119: /* if we didn't wait, we don't have to spend time on this now */
120: if(Curl_pgrsUpdate(conn))
121: result = CURLE_ABORTED_BY_CALLBACK;
122: else
123: result = Curl_speedcheck(data, Curl_now());
124:
125: if(result)
126: return result;
127: }
128:
129: if(rc == -1) {
130: failf(data, "select/poll error");
131: result = CURLE_OUT_OF_MEMORY;
132: }
133: else if(rc)
134: result = pp->statemach_act(conn);
135:
136: return result;
137: }
138:
139: /* initialize stuff to prepare for reading a fresh new response */
140: void Curl_pp_init(struct pingpong *pp)
141: {
142: struct connectdata *conn = pp->conn;
143: pp->nread_resp = 0;
144: pp->linestart_resp = conn->data->state.buffer;
145: pp->pending_resp = TRUE;
146: pp->response = Curl_now(); /* start response time-out now! */
147: }
148:
149:
150:
151: /***********************************************************************
152: *
153: * Curl_pp_vsendf()
154: *
155: * Send the formatted string as a command to a pingpong server. Note that
156: * the string should not have any CRLF appended, as this function will
157: * append the necessary things itself.
158: *
159: * made to never block
160: */
161: CURLcode Curl_pp_vsendf(struct pingpong *pp,
162: const char *fmt,
163: va_list args)
164: {
165: ssize_t bytes_written;
166: size_t write_len;
167: char *fmt_crlf;
168: char *s;
169: CURLcode result;
170: struct connectdata *conn = pp->conn;
171: struct Curl_easy *data;
172:
173: #ifdef HAVE_GSSAPI
174: enum protection_level data_sec;
175: #endif
176:
177: DEBUGASSERT(pp->sendleft == 0);
178: DEBUGASSERT(pp->sendsize == 0);
179: DEBUGASSERT(pp->sendthis == NULL);
180:
181: if(!conn)
182: /* can't send without a connection! */
183: return CURLE_SEND_ERROR;
184:
185: data = conn->data;
186:
187: fmt_crlf = aprintf("%s\r\n", fmt); /* append a trailing CRLF */
188: if(!fmt_crlf)
189: return CURLE_OUT_OF_MEMORY;
190:
191: s = vaprintf(fmt_crlf, args); /* trailing CRLF appended */
192: free(fmt_crlf);
193: if(!s)
194: return CURLE_OUT_OF_MEMORY;
195:
196: bytes_written = 0;
197: write_len = strlen(s);
198:
199: Curl_pp_init(pp);
200:
201: result = Curl_convert_to_network(data, s, write_len);
202: /* Curl_convert_to_network calls failf if unsuccessful */
203: if(result) {
204: free(s);
205: return result;
206: }
207:
208: #ifdef HAVE_GSSAPI
209: conn->data_prot = PROT_CMD;
210: #endif
211: result = Curl_write(conn, conn->sock[FIRSTSOCKET], s, write_len,
212: &bytes_written);
213: #ifdef HAVE_GSSAPI
214: data_sec = conn->data_prot;
215: DEBUGASSERT(data_sec > PROT_NONE && data_sec < PROT_LAST);
216: conn->data_prot = data_sec;
217: #endif
218:
219: if(result) {
220: free(s);
221: return result;
222: }
223:
224: if(conn->data->set.verbose)
225: Curl_debug(conn->data, CURLINFO_HEADER_OUT, s, (size_t)bytes_written);
226:
227: if(bytes_written != (ssize_t)write_len) {
228: /* the whole chunk was not sent, keep it around and adjust sizes */
229: pp->sendthis = s;
230: pp->sendsize = write_len;
231: pp->sendleft = write_len - bytes_written;
232: }
233: else {
234: free(s);
235: pp->sendthis = NULL;
236: pp->sendleft = pp->sendsize = 0;
237: pp->response = Curl_now();
238: }
239:
240: return CURLE_OK;
241: }
242:
243:
244: /***********************************************************************
245: *
246: * Curl_pp_sendf()
247: *
248: * Send the formatted string as a command to a pingpong server. Note that
249: * the string should not have any CRLF appended, as this function will
250: * append the necessary things itself.
251: *
252: * made to never block
253: */
254: CURLcode Curl_pp_sendf(struct pingpong *pp,
255: const char *fmt, ...)
256: {
257: CURLcode result;
258: va_list ap;
259: va_start(ap, fmt);
260:
261: result = Curl_pp_vsendf(pp, fmt, ap);
262:
263: va_end(ap);
264:
265: return result;
266: }
267:
268: /*
269: * Curl_pp_readresp()
270: *
271: * Reads a piece of a server response.
272: */
273: CURLcode Curl_pp_readresp(curl_socket_t sockfd,
274: struct pingpong *pp,
275: int *code, /* return the server code if done */
276: size_t *size) /* size of the response */
277: {
278: ssize_t perline; /* count bytes per line */
279: bool keepon = TRUE;
280: ssize_t gotbytes;
281: char *ptr;
282: struct connectdata *conn = pp->conn;
283: struct Curl_easy *data = conn->data;
284: char * const buf = data->state.buffer;
285: CURLcode result = CURLE_OK;
286:
287: *code = 0; /* 0 for errors or not done */
288: *size = 0;
289:
290: ptr = buf + pp->nread_resp;
291:
292: /* number of bytes in the current line, so far */
293: perline = (ssize_t)(ptr-pp->linestart_resp);
294:
295: while((pp->nread_resp < (size_t)data->set.buffer_size) &&
296: (keepon && !result)) {
297:
298: if(pp->cache) {
299: /* we had data in the "cache", copy that instead of doing an actual
300: * read
301: *
302: * pp->cache_size is cast to ssize_t here. This should be safe, because
303: * it would have been populated with something of size int to begin
304: * with, even though its datatype may be larger than an int.
305: */
306: if((ptr + pp->cache_size) > (buf + data->set.buffer_size + 1)) {
307: failf(data, "cached response data too big to handle");
308: return CURLE_RECV_ERROR;
309: }
310: memcpy(ptr, pp->cache, pp->cache_size);
311: gotbytes = (ssize_t)pp->cache_size;
312: free(pp->cache); /* free the cache */
313: pp->cache = NULL; /* clear the pointer */
314: pp->cache_size = 0; /* zero the size just in case */
315: }
316: else {
317: #ifdef HAVE_GSSAPI
318: enum protection_level prot = conn->data_prot;
319: conn->data_prot = PROT_CLEAR;
320: #endif
321: DEBUGASSERT((ptr + data->set.buffer_size - pp->nread_resp) <=
322: (buf + data->set.buffer_size + 1));
323: result = Curl_read(conn, sockfd, ptr,
324: data->set.buffer_size - pp->nread_resp,
325: &gotbytes);
326: #ifdef HAVE_GSSAPI
327: DEBUGASSERT(prot > PROT_NONE && prot < PROT_LAST);
328: conn->data_prot = prot;
329: #endif
330: if(result == CURLE_AGAIN)
331: return CURLE_OK; /* return */
332:
333: if(!result && (gotbytes > 0))
334: /* convert from the network encoding */
335: result = Curl_convert_from_network(data, ptr, gotbytes);
336: /* Curl_convert_from_network calls failf if unsuccessful */
337:
338: if(result)
339: /* Set outer result variable to this error. */
340: keepon = FALSE;
341: }
342:
343: if(!keepon)
344: ;
345: else if(gotbytes <= 0) {
346: keepon = FALSE;
347: result = CURLE_RECV_ERROR;
348: failf(data, "response reading failed");
349: }
350: else {
351: /* we got a whole chunk of data, which can be anything from one
352: * byte to a set of lines and possible just a piece of the last
353: * line */
354: ssize_t i;
355: ssize_t clipamount = 0;
356: bool restart = FALSE;
357:
358: data->req.headerbytecount += (long)gotbytes;
359:
360: pp->nread_resp += gotbytes;
361: for(i = 0; i < gotbytes; ptr++, i++) {
362: perline++;
363: if(*ptr == '\n') {
364: /* a newline is CRLF in pp-talk, so the CR is ignored as
365: the line isn't really terminated until the LF comes */
366:
367: /* output debug output if that is requested */
368: #ifdef HAVE_GSSAPI
369: if(!conn->sec_complete)
370: #endif
371: if(data->set.verbose)
372: Curl_debug(data, CURLINFO_HEADER_IN,
373: pp->linestart_resp, (size_t)perline);
374:
375: /*
376: * We pass all response-lines to the callback function registered
377: * for "headers". The response lines can be seen as a kind of
378: * headers.
379: */
380: result = Curl_client_write(conn, CLIENTWRITE_HEADER,
381: pp->linestart_resp, perline);
382: if(result)
383: return result;
384:
385: if(pp->endofresp(conn, pp->linestart_resp, perline, code)) {
386: /* This is the end of the last line, copy the last line to the
387: start of the buffer and zero terminate, for old times sake */
388: size_t n = ptr - pp->linestart_resp;
389: memmove(buf, pp->linestart_resp, n);
390: buf[n] = 0; /* zero terminate */
391: keepon = FALSE;
392: pp->linestart_resp = ptr + 1; /* advance pointer */
393: i++; /* skip this before getting out */
394:
395: *size = pp->nread_resp; /* size of the response */
396: pp->nread_resp = 0; /* restart */
397: break;
398: }
399: perline = 0; /* line starts over here */
400: pp->linestart_resp = ptr + 1;
401: }
402: }
403:
404: if(!keepon && (i != gotbytes)) {
405: /* We found the end of the response lines, but we didn't parse the
406: full chunk of data we have read from the server. We therefore need
407: to store the rest of the data to be checked on the next invoke as
408: it may actually contain another end of response already! */
409: clipamount = gotbytes - i;
410: restart = TRUE;
411: DEBUGF(infof(data, "Curl_pp_readresp_ %d bytes of trailing "
412: "server response left\n",
413: (int)clipamount));
414: }
415: else if(keepon) {
416:
417: if((perline == gotbytes) && (gotbytes > data->set.buffer_size/2)) {
418: /* We got an excessive line without newlines and we need to deal
419: with it. We keep the first bytes of the line then we throw
420: away the rest. */
421: infof(data, "Excessive server response line length received, "
422: "%zd bytes. Stripping\n", gotbytes);
423: restart = TRUE;
424:
425: /* we keep 40 bytes since all our pingpong protocols are only
426: interested in the first piece */
427: clipamount = 40;
428: }
429: else if(pp->nread_resp > (size_t)data->set.buffer_size/2) {
430: /* We got a large chunk of data and there's potentially still
431: trailing data to take care of, so we put any such part in the
432: "cache", clear the buffer to make space and restart. */
433: clipamount = perline;
434: restart = TRUE;
435: }
436: }
437: else if(i == gotbytes)
438: restart = TRUE;
439:
440: if(clipamount) {
441: pp->cache_size = clipamount;
442: pp->cache = malloc(pp->cache_size);
443: if(pp->cache)
444: memcpy(pp->cache, pp->linestart_resp, pp->cache_size);
445: else
446: return CURLE_OUT_OF_MEMORY;
447: }
448: if(restart) {
449: /* now reset a few variables to start over nicely from the start of
450: the big buffer */
451: pp->nread_resp = 0; /* start over from scratch in the buffer */
452: ptr = pp->linestart_resp = buf;
453: perline = 0;
454: }
455:
456: } /* there was data */
457:
458: } /* while there's buffer left and loop is requested */
459:
460: pp->pending_resp = FALSE;
461:
462: return result;
463: }
464:
465: int Curl_pp_getsock(struct pingpong *pp,
466: curl_socket_t *socks)
467: {
468: struct connectdata *conn = pp->conn;
469: socks[0] = conn->sock[FIRSTSOCKET];
470:
471: if(pp->sendleft) {
472: /* write mode */
473: return GETSOCK_WRITESOCK(0);
474: }
475:
476: /* read mode */
477: return GETSOCK_READSOCK(0);
478: }
479:
480: CURLcode Curl_pp_flushsend(struct pingpong *pp)
481: {
482: /* we have a piece of a command still left to send */
483: struct connectdata *conn = pp->conn;
484: ssize_t written;
485: curl_socket_t sock = conn->sock[FIRSTSOCKET];
486: CURLcode result = Curl_write(conn, sock, pp->sendthis + pp->sendsize -
487: pp->sendleft, pp->sendleft, &written);
488: if(result)
489: return result;
490:
491: if(written != (ssize_t)pp->sendleft) {
492: /* only a fraction was sent */
493: pp->sendleft -= written;
494: }
495: else {
496: free(pp->sendthis);
497: pp->sendthis = NULL;
498: pp->sendleft = pp->sendsize = 0;
499: pp->response = Curl_now();
500: }
501: return CURLE_OK;
502: }
503:
504: CURLcode Curl_pp_disconnect(struct pingpong *pp)
505: {
506: free(pp->cache);
507: pp->cache = NULL;
508: return CURLE_OK;
509: }
510:
511: bool Curl_pp_moredata(struct pingpong *pp)
512: {
513: return (!pp->sendleft && pp->cache && pp->nread_resp < pp->cache_size) ?
514: TRUE : FALSE;
515: }
516:
517: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pingpong.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib