Home | History | Annotate | Download | only in lib 
      1 /***************************************************************************
      2  *                                  _   _ ____  _
      3  *  Project                     ___| | | |  _ \| |
      4  *                             / __| | | | |_) | |
      5  *                            | (__| |_| |  _ <| |___
      6  *                             \___|\___/|_| \_\_____|
      7  *
      8  * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel (at) 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
    511