lib/pingpong.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2016, 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)
  48 {
  49   struct connectdata *conn = pp->conn;
  50   struct Curl_easy *data=conn->data;
  51   time_t timeout_ms; /* in milliseconds */
  52   time_t timeout2_ms; /* in milliseconds */
  53   long response_time= (data->set.server_response_timeout)?
  54     data->set.server_response_timeout: pp->response_time;
  55
  56   /* if CURLOPT_SERVER_RESPONSE_TIMEOUT is set, use that to determine
  57      remaining time, or use pp->response because SERVER_RESPONSE_TIMEOUT is
  58      supposed to govern the response for any given server response, not for
  59      the time from connect to the given server response. */
  60
  61   /* Without a requested timeout, we only wait 'response_time' seconds for the
  62      full response to arrive before we bail out */
  63   timeout_ms = response_time -
  64     Curl_tvdiff(Curl_tvnow(), pp->response); /* spent time */
  65
  66   if(data->set.timeout) {
  67     /* if timeout is requested, find out how much remaining time we have */
  68     timeout2_ms = data->set.timeout - /* timeout time */
  69       Curl_tvdiff(Curl_tvnow(), conn->now); /* spent time */
  70
  71     /* pick the lowest number */
  72     timeout_ms = CURLMIN(timeout_ms, timeout2_ms);
  73   }
  74
  75   return timeout_ms;
  76 }
  77
  78 /*
  79  * Curl_pp_statemach()
  80  */
  81 CURLcode Curl_pp_statemach(struct pingpong *pp, bool block)
  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);
  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_tvnow());
 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_tvnow(); /* start response time-out now! */
 147 }
 148
 149
 150
 151 /***********************************************************************
 152  *
 153  * Curl_pp_vsendf()
 154  *
 155  * Send the formated 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 = conn->data;
 172
 173 #ifdef HAVE_GSSAPI
 174   enum protection_level data_sec = conn->data_prot;
 175 #endif
 176
 177   DEBUGASSERT(pp->sendleft == 0);
 178   DEBUGASSERT(pp->sendsize == 0);
 179   DEBUGASSERT(pp->sendthis == NULL);
 180
 181   fmt_crlf = aprintf("%s\r\n", fmt); /* append a trailing CRLF */
 182   if(!fmt_crlf)
 183     return CURLE_OUT_OF_MEMORY;
 184
 185   s = vaprintf(fmt_crlf, args); /* trailing CRLF appended */
 186   free(fmt_crlf);
 187   if(!s)
 188     return CURLE_OUT_OF_MEMORY;
 189
 190   bytes_written = 0;
 191   write_len = strlen(s);
 192
 193   Curl_pp_init(pp);
 194
 195   result = Curl_convert_to_network(data, s, write_len);
 196   /* Curl_convert_to_network calls failf if unsuccessful */
 197   if(result) {
 198     free(s);
 199     return result;
 200   }
 201
 202 #ifdef HAVE_GSSAPI
 203   conn->data_prot = PROT_CMD;
 204 #endif
 205   result = Curl_write(conn, conn->sock[FIRSTSOCKET], s, write_len,
 206                      &bytes_written);
 207 #ifdef HAVE_GSSAPI
 208   DEBUGASSERT(data_sec > PROT_NONE && data_sec < PROT_LAST);
 209   conn->data_prot = data_sec;
 210 #endif
 211
 212   if(result) {
 213     free(s);
 214     return result;
 215   }
 216
 217   if(conn->data->set.verbose)
 218     Curl_debug(conn->data, CURLINFO_HEADER_OUT,
 219                s, (size_t)bytes_written, conn);
 220
 221   if(bytes_written != (ssize_t)write_len) {
 222     /* the whole chunk was not sent, keep it around and adjust sizes */
 223     pp->sendthis = s;
 224     pp->sendsize = write_len;
 225     pp->sendleft = write_len - bytes_written;
 226   }
 227   else {
 228     free(s);
 229     pp->sendthis = NULL;
 230     pp->sendleft = pp->sendsize = 0;
 231     pp->response = Curl_tvnow();
 232   }
 233
 234   return CURLE_OK;
 235 }
 236
 237
 238 /***********************************************************************
 239  *
 240  * Curl_pp_sendf()
 241  *
 242  * Send the formated string as a command to a pingpong server. Note that
 243  * the string should not have any CRLF appended, as this function will
 244  * append the necessary things itself.
 245  *
 246  * made to never block
 247  */
 248 CURLcode Curl_pp_sendf(struct pingpong *pp,
 249                        const char *fmt, ...)
 250 {
 251   CURLcode result;
 252   va_list ap;
 253   va_start(ap, fmt);
 254
 255   result = Curl_pp_vsendf(pp, fmt, ap);
 256
 257   va_end(ap);
 258
 259   return result;
 260 }
 261
 262 /*
 263  * Curl_pp_readresp()
 264  *
 265  * Reads a piece of a server response.
 266  */
 267 CURLcode Curl_pp_readresp(curl_socket_t sockfd,
 268                           struct pingpong *pp,
 269                           int *code, /* return the server code if done */
 270                           size_t *size) /* size of the response */
 271 {
 272   ssize_t perline; /* count bytes per line */
 273   bool keepon=TRUE;
 274   ssize_t gotbytes;
 275   char *ptr;
 276   struct connectdata *conn = pp->conn;
 277   struct Curl_easy *data = conn->data;
 278   char * const buf = data->state.buffer;
 279   CURLcode result = CURLE_OK;
 280
 281   *code = 0; /* 0 for errors or not done */
 282   *size = 0;
 283
 284   ptr=buf + pp->nread_resp;
 285
 286   /* number of bytes in the current line, so far */
 287   perline = (ssize_t)(ptr-pp->linestart_resp);
 288
 289   while((pp->nread_resp<BUFSIZE) && (keepon && !result)) {
 290
 291     if(pp->cache) {
 292       /* we had data in the "cache", copy that instead of doing an actual
 293        * read
 294        *
 295        * pp->cache_size is cast to ssize_t here.  This should be safe, because
 296        * it would have been populated with something of size int to begin
 297        * with, even though its datatype may be larger than an int.
 298        */
 299       DEBUGASSERT((ptr+pp->cache_size) <= (buf+BUFSIZE+1));
 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+BUFSIZE-pp->nread_resp) <= (buf+BUFSIZE+1));
 312       result = Curl_read(conn, sockfd, ptr, BUFSIZE-pp->nread_resp,
 313                          &gotbytes);
 314 #ifdef HAVE_GSSAPI
 315       DEBUGASSERT(prot  > PROT_NONE && prot < PROT_LAST);
 316       conn->data_prot = prot;
 317 #endif
 318       if(result == CURLE_AGAIN)
 319         return CURLE_OK; /* return */
 320
 321       if(!result && (gotbytes > 0))
 322         /* convert from the network encoding */
 323         result = Curl_convert_from_network(data, ptr, gotbytes);
 324       /* Curl_convert_from_network calls failf if unsuccessful */
 325
 326       if(result)
 327         /* Set outer result variable to this error. */
 328         keepon = FALSE;
 329     }
 330
 331     if(!keepon)
 332       ;
 333     else if(gotbytes <= 0) {
 334       keepon = FALSE;
 335       result = CURLE_RECV_ERROR;
 336       failf(data, "response reading failed");
 337     }
 338     else {
 339       /* we got a whole chunk of data, which can be anything from one
 340        * byte to a set of lines and possible just a piece of the last
 341        * line */
 342       ssize_t i;
 343       ssize_t clipamount = 0;
 344       bool restart = FALSE;
 345
 346       data->req.headerbytecount += (long)gotbytes;
 347
 348       pp->nread_resp += gotbytes;
 349       for(i = 0; i < gotbytes; ptr++, i++) {
 350         perline++;
 351         if(*ptr=='\n') {
 352           /* a newline is CRLF in pp-talk, so the CR is ignored as
 353              the line isn't really terminated until the LF comes */
 354
 355           /* output debug output if that is requested */
 356 #ifdef HAVE_GSSAPI
 357           if(!conn->sec_complete)
 358 #endif
 359             if(data->set.verbose)
 360               Curl_debug(data, CURLINFO_HEADER_IN,
 361                          pp->linestart_resp, (size_t)perline, conn);
 362
 363           /*
 364            * We pass all response-lines to the callback function registered
 365            * for "headers". The response lines can be seen as a kind of
 366            * headers.
 367            */
 368           result = Curl_client_write(conn, CLIENTWRITE_HEADER,
 369                                      pp->linestart_resp, perline);
 370           if(result)
 371             return result;
 372
 373           if(pp->endofresp(conn, pp->linestart_resp, perline, code)) {
 374             /* This is the end of the last line, copy the last line to the
 375                start of the buffer and zero terminate, for old times sake */
 376             size_t n = ptr - pp->linestart_resp;
 377             memmove(buf, pp->linestart_resp, n);
 378             buf[n]=0; /* zero terminate */
 379             keepon=FALSE;
 380             pp->linestart_resp = ptr+1; /* advance pointer */
 381             i++; /* skip this before getting out */
 382
 383             *size = pp->nread_resp; /* size of the response */
 384             pp->nread_resp = 0; /* restart */
 385             break;
 386           }
 387           perline=0; /* line starts over here */
 388           pp->linestart_resp = ptr+1;
 389         }
 390       }
 391
 392       if(!keepon && (i != gotbytes)) {
 393         /* We found the end of the response lines, but we didn't parse the
 394            full chunk of data we have read from the server. We therefore need
 395            to store the rest of the data to be checked on the next invoke as
 396            it may actually contain another end of response already! */
 397         clipamount = gotbytes - i;
 398         restart = TRUE;
 399         DEBUGF(infof(data, "Curl_pp_readresp_ %d bytes of trailing "
 400                      "server response left\n",
 401                      (int)clipamount));
 402       }
 403       else if(keepon) {
 404
 405         if((perline == gotbytes) && (gotbytes > BUFSIZE/2)) {
 406           /* We got an excessive line without newlines and we need to deal
 407              with it. We keep the first bytes of the line then we throw
 408              away the rest. */
 409           infof(data, "Excessive server response line length received, "
 410                 "%zd bytes. Stripping\n", gotbytes);
 411           restart = TRUE;
 412
 413           /* we keep 40 bytes since all our pingpong protocols are only
 414              interested in the first piece */
 415           clipamount = 40;
 416         }
 417         else if(pp->nread_resp > BUFSIZE/2) {
 418           /* We got a large chunk of data and there's potentially still
 419              trailing data to take care of, so we put any such part in the
 420              "cache", clear the buffer to make space and restart. */
 421           clipamount = perline;
 422           restart = TRUE;
 423         }
 424       }
 425       else if(i == gotbytes)
 426         restart = TRUE;
 427
 428       if(clipamount) {
 429         pp->cache_size = clipamount;
 430         pp->cache = malloc(pp->cache_size);
 431         if(pp->cache)
 432           memcpy(pp->cache, pp->linestart_resp, pp->cache_size);
 433         else
 434           return CURLE_OUT_OF_MEMORY;
 435       }
 436       if(restart) {
 437         /* now reset a few variables to start over nicely from the start of
 438            the big buffer */
 439         pp->nread_resp = 0; /* start over from scratch in the buffer */
 440         ptr = pp->linestart_resp = buf;
 441         perline = 0;
 442       }
 443
 444     } /* there was data */
 445
 446   } /* while there's buffer left and loop is requested */
 447
 448   pp->pending_resp = FALSE;
 449
 450   return result;
 451 }
 452
 453 int Curl_pp_getsock(struct pingpong *pp,
 454                     curl_socket_t *socks,
 455                     int numsocks)
 456 {
 457   struct connectdata *conn = pp->conn;
 458
 459   if(!numsocks)
 460     return GETSOCK_BLANK;
 461
 462   socks[0] = conn->sock[FIRSTSOCKET];
 463
 464   if(pp->sendleft) {
 465     /* write mode */
 466     return GETSOCK_WRITESOCK(0);
 467   }
 468
 469   /* read mode */
 470   return GETSOCK_READSOCK(0);
 471 }
 472
 473 CURLcode Curl_pp_flushsend(struct pingpong *pp)
 474 {
 475   /* we have a piece of a command still left to send */
 476   struct connectdata *conn = pp->conn;
 477   ssize_t written;
 478   curl_socket_t sock = conn->sock[FIRSTSOCKET];
 479   CURLcode result = Curl_write(conn, sock, pp->sendthis + pp->sendsize -
 480                                pp->sendleft, pp->sendleft, &written);
 481   if(result)
 482     return result;
 483
 484   if(written != (ssize_t)pp->sendleft) {
 485     /* only a fraction was sent */
 486     pp->sendleft -= written;
 487   }
 488   else {
 489     free(pp->sendthis);
 490     pp->sendthis=NULL;
 491     pp->sendleft = pp->sendsize = 0;
 492     pp->response = Curl_tvnow();
 493   }
 494   return CURLE_OK;
 495 }
 496
 497 CURLcode Curl_pp_disconnect(struct pingpong *pp)
 498 {
 499   free(pp->cache);
 500   pp->cache = NULL;
 501   return CURLE_OK;
 502 }
 503
 504 bool Curl_pp_moredata(struct pingpong *pp)
 505 {
 506   return (!pp->sendleft && pp->cache && pp->nread_resp < pp->cache_size) ?
 507          TRUE : FALSE;
 508 }
 509
 510 #endif