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