lib/transfer.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2011, 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 http://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  ***************************************************************************/
  22
  23 #include "setup.h"
  24
  25 /* -- WIN32 approved -- */
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <stdarg.h>
  29 #include <stdlib.h>
  30 #include <ctype.h>
  31 #include <errno.h>
  32
  33 #include "strtoofft.h"
  34 #include "strequal.h"
  35 #include "rawstr.h"
  36
  37 #ifdef WIN32
  38 #include <time.h>
  39 #include <io.h>
  40 #else
  41 #ifdef HAVE_SYS_SOCKET_H
  42 #include <sys/socket.h>
  43 #endif
  44 #ifdef HAVE_NETINET_IN_H
  45 #include <netinet/in.h>
  46 #endif
  47 #ifdef HAVE_SYS_TIME_H
  48 #include <sys/time.h>
  49 #endif
  50 #ifdef HAVE_UNISTD_H
  51 #include <unistd.h>
  52 #endif
  53 #ifdef HAVE_NETDB_H
  54 #include <netdb.h>
  55 #endif
  56 #ifdef HAVE_ARPA_INET_H
  57 #include <arpa/inet.h>
  58 #endif
  59 #ifdef HAVE_NET_IF_H
  60 #include <net/if.h>
  61 #endif
  62 #ifdef HAVE_SYS_IOCTL_H
  63 #include <sys/ioctl.h>
  64 #endif
  65 #ifdef HAVE_SIGNAL_H
  66 #include <signal.h>
  67 #endif
  68
  69 #ifdef HAVE_SYS_PARAM_H
  70 #include <sys/param.h>
  71 #endif
  72
  73 #ifdef HAVE_SYS_SELECT_H
  74 #include <sys/select.h>
  75 #endif
  76
  77 #ifndef HAVE_SOCKET
  78 #error "We can't compile without socket() support!"
  79 #endif
  80
  81 #endif  /* WIN32 */
  82
  83 #include "urldata.h"
  84 #include <curl/curl.h>
  85 #include "netrc.h"
  86
  87 #include "content_encoding.h"
  88 #include "hostip.h"
  89 #include "transfer.h"
  90 #include "sendf.h"
  91 #include "speedcheck.h"
  92 #include "progress.h"
  93 #include "http.h"
  94 #include "url.h"
  95 #include "getinfo.h"
  96 #include "sslgen.h"
  97 #include "http_digest.h"
  98 #include "http_ntlm.h"
  99 #include "http_negotiate.h"
 100 #include "share.h"
 101 #include "curl_memory.h"
 102 #include "select.h"
 103 #include "multiif.h"
 104 #include "easyif.h" /* for Curl_convert_to_network prototype */
 105 #include "rtsp.h"
 106 #include "connect.h"
 107
 108 #define _MPRINTF_REPLACE /* use our functions only */
 109 #include <curl/mprintf.h>
 110
 111 /* The last #include file should be: */
 112 #include "memdebug.h"
 113
 114 #define CURL_TIMEOUT_EXPECT_100 1000 /* counting ms here */
 115
 116 /*
 117  * This function will call the read callback to fill our buffer with data
 118  * to upload.
 119  */
 120 CURLcode Curl_fillreadbuffer(struct connectdata *conn, int bytes, int *nreadp)
 121 {
 122   struct SessionHandle *data = conn->data;
 123   size_t buffersize = (size_t)bytes;
 124   int nread;
 125 #ifdef CURL_DOES_CONVERSIONS
 126   bool sending_http_headers = FALSE;
 127
 128   if((conn->protocol&(PROT_HTTP|PROT_RTSP)) &&
 129      (data->state.proto.http->sending == HTTPSEND_REQUEST)) {
 130     /* We're sending the HTTP request headers, not the data.
 131        Remember that so we don't re-translate them into garbage. */
 132     sending_http_headers = TRUE;
 133   }
 134 #endif
 135
 136   if(data->req.upload_chunky) {
 137     /* if chunked Transfer-Encoding */
 138     buffersize -= (8 + 2 + 2);   /* 32bit hex + CRLF + CRLF */
 139     data->req.upload_fromhere += (8 + 2); /* 32bit hex + CRLF */
 140   }
 141
 142   /* this function returns a size_t, so we typecast to int to prevent warnings
 143      with picky compilers */
 144   nread = (int)conn->fread_func(data->req.upload_fromhere, 1,
 145                                 buffersize, conn->fread_in);
 146
 147   if(nread == CURL_READFUNC_ABORT) {
 148     failf(data, "operation aborted by callback");
 149     *nreadp = 0;
 150     return CURLE_ABORTED_BY_CALLBACK;
 151   }
 152   else if(nread == CURL_READFUNC_PAUSE) {
 153     struct SingleRequest *k = &data->req;
 154     /* CURL_READFUNC_PAUSE pauses read callbacks that feed socket writes */
 155     k->keepon |= KEEP_SEND_PAUSE; /* mark socket send as paused */
 156     if(data->req.upload_chunky) {
 157       /* Back out the preallocation done above */
 158       data->req.upload_fromhere -= (8 + 2);
 159     }
 160     *nreadp = 0;
 161     return CURLE_OK; /* nothing was read */
 162   }
 163   else if((size_t)nread > buffersize) {
 164     /* the read function returned a too large value */
 165     *nreadp = 0;
 166     failf(data, "read function returned funny value");
 167     return CURLE_READ_ERROR;
 168   }
 169
 170   if(!data->req.forbidchunk && data->req.upload_chunky) {
 171     /* if chunked Transfer-Encoding
 172      *    build chunk:
 173      *
 174      *        <HEX SIZE> CRLF
 175      *        <DATA> CRLF
 176      */
 177     /* On non-ASCII platforms the <DATA> may or may not be
 178        translated based on set.prefer_ascii while the protocol
 179        portion must always be translated to the network encoding.
 180        To further complicate matters, line end conversion might be
 181        done later on, so we need to prevent CRLFs from becoming
 182        CRCRLFs if that's the case.  To do this we use bare LFs
 183        here, knowing they'll become CRLFs later on.
 184      */
 185
 186     char hexbuffer[11];
 187     const char *endofline_native;
 188     const char *endofline_network;
 189     int hexlen;
 190 #ifdef CURL_DO_LINEEND_CONV
 191     if((data->set.crlf) || (data->set.prefer_ascii)) {
 192 #else
 193     if(data->set.crlf) {
 194 #endif /* CURL_DO_LINEEND_CONV */
 195       /* \n will become \r\n later on */
 196       endofline_native  = "\n";
 197       endofline_network = "\x0a";
 198     }
 199     else {
 200       endofline_native  = "\r\n";
 201       endofline_network = "\x0d\x0a";
 202     }
 203     hexlen = snprintf(hexbuffer, sizeof(hexbuffer),
 204                       "%x%s", nread, endofline_native);
 205
 206     /* move buffer pointer */
 207     data->req.upload_fromhere -= hexlen;
 208     nread += hexlen;
 209
 210     /* copy the prefix to the buffer, leaving out the NUL */
 211     memcpy(data->req.upload_fromhere, hexbuffer, hexlen);
 212
 213     /* always append ASCII CRLF to the data */
 214     memcpy(data->req.upload_fromhere + nread,
 215            endofline_network,
 216            strlen(endofline_network));
 217
 218 #ifdef CURL_DOES_CONVERSIONS
 219     CURLcode res;
 220     int length;
 221     if(data->set.prefer_ascii) {
 222       /* translate the protocol and data */
 223       length = nread;
 224     }
 225     else {
 226       /* just translate the protocol portion */
 227       length = strlen(hexbuffer);
 228     }
 229     res = Curl_convert_to_network(data, data->req.upload_fromhere, length);
 230     /* Curl_convert_to_network calls failf if unsuccessful */
 231     if(res)
 232       return(res);
 233 #endif /* CURL_DOES_CONVERSIONS */
 234
 235     if((nread - hexlen) == 0)
 236       /* mark this as done once this chunk is transfered */
 237       data->req.upload_done = TRUE;
 238
 239     nread+=(int)strlen(endofline_native); /* for the added end of line */
 240   }
 241 #ifdef CURL_DOES_CONVERSIONS
 242   else if((data->set.prefer_ascii) && (!sending_http_headers)) {
 243     CURLcode res;
 244     res = Curl_convert_to_network(data, data->req.upload_fromhere, nread);
 245     /* Curl_convert_to_network calls failf if unsuccessful */
 246     if(res != CURLE_OK)
 247       return(res);
 248   }
 249 #endif /* CURL_DOES_CONVERSIONS */
 250
 251   *nreadp = nread;
 252
 253   return CURLE_OK;
 254 }
 255
 256
 257 /*
 258  * Curl_readrewind() rewinds the read stream. This is typically used for HTTP
 259  * POST/PUT with multi-pass authentication when a sending was denied and a
 260  * resend is necessary.
 261  */
 262 CURLcode Curl_readrewind(struct connectdata *conn)
 263 {
 264   struct SessionHandle *data = conn->data;
 265
 266   conn->bits.rewindaftersend = FALSE; /* we rewind now */
 267
 268   /* explicitly switch off sending data on this connection now since we are
 269      about to restart a new transfer and thus we want to avoid inadvertently
 270      sending more data on the existing connection until the next transfer
 271      starts */
 272   data->req.keepon &= ~KEEP_SEND;
 273
 274   /* We have sent away data. If not using CURLOPT_POSTFIELDS or
 275      CURLOPT_HTTPPOST, call app to rewind
 276   */
 277   if(data->set.postfields ||
 278      (data->set.httpreq == HTTPREQ_POST_FORM))
 279     ; /* do nothing */
 280   else {
 281     if(data->set.seek_func) {
 282       int err;
 283
 284       err = (data->set.seek_func)(data->set.seek_client, 0, SEEK_SET);
 285       if(err) {
 286         failf(data, "seek callback returned error %d", (int)err);
 287         return CURLE_SEND_FAIL_REWIND;
 288       }
 289     }
 290     else if(data->set.ioctl_func) {
 291       curlioerr err;
 292
 293       err = (data->set.ioctl_func)(data, CURLIOCMD_RESTARTREAD,
 294                                    data->set.ioctl_client);
 295       infof(data, "the ioctl callback returned %d\n", (int)err);
 296
 297       if(err) {
 298         /* FIXME: convert to a human readable error message */
 299         failf(data, "ioctl callback returned error %d", (int)err);
 300         return CURLE_SEND_FAIL_REWIND;
 301       }
 302     }
 303     else {
 304       /* If no CURLOPT_READFUNCTION is used, we know that we operate on a
 305          given FILE * stream and we can actually attempt to rewind that
 306          ourself with fseek() */
 307       if(data->set.fread_func == (curl_read_callback)fread) {
 308         if(-1 != fseek(data->set.in, 0, SEEK_SET))
 309           /* successful rewind */
 310           return CURLE_OK;
 311       }
 312
 313       /* no callback set or failure above, makes us fail at once */
 314       failf(data, "necessary data rewind wasn't possible");
 315       return CURLE_SEND_FAIL_REWIND;
 316     }
 317   }
 318   return CURLE_OK;
 319 }
 320
 321 static int data_pending(const struct connectdata *conn)
 322 {
 323   /* in the case of libssh2, we can never be really sure that we have emptied
 324      its internal buffers so we MUST always try until we get EAGAIN back */
 325   return conn->protocol&(PROT_SCP|PROT_SFTP) ||
 326     Curl_ssl_data_pending(conn, FIRSTSOCKET);
 327 }
 328
 329 static void read_rewind(struct connectdata *conn,
 330                         size_t thismuch)
 331 {
 332   DEBUGASSERT(conn->read_pos >= thismuch);
 333
 334   conn->read_pos -= thismuch;
 335   conn->bits.stream_was_rewound = TRUE;
 336
 337 #ifdef DEBUGBUILD
 338   {
 339     char buf[512 + 1];
 340     size_t show;
 341
 342     show = CURLMIN(conn->buf_len - conn->read_pos, sizeof(buf)-1);
 343     if(conn->master_buffer) {
 344       memcpy(buf, conn->master_buffer + conn->read_pos, show);
 345       buf[show] = '\0';
 346     }
 347     else {
 348       buf[0] = '\0';
 349     }
 350
 351     DEBUGF(infof(conn->data,
 352                  "Buffer after stream rewind (read_pos = %zu): [%s]",
 353                  conn->read_pos, buf));
 354   }
 355 #endif
 356 }
 357
 358 /*
 359  * Check to see if CURLOPT_TIMECONDITION was met by comparing the time of the
 360  * remote document with the time provided by CURLOPT_TIMEVAL
 361  */
 362 bool Curl_meets_timecondition(struct SessionHandle *data, time_t timeofdoc)
 363 {
 364   if((timeofdoc == 0) || (data->set.timevalue == 0))
 365     return TRUE;
 366
 367   switch(data->set.timecondition) {
 368   case CURL_TIMECOND_IFMODSINCE:
 369   default:
 370     if(timeofdoc <= data->set.timevalue) {
 371       infof(data,
 372             "The requested document is not new enough\n");
 373       data->info.timecond = TRUE;
 374       return FALSE;
 375     }
 376     break;
 377   case CURL_TIMECOND_IFUNMODSINCE:
 378     if(timeofdoc >= data->set.timevalue) {
 379       infof(data,
 380             "The requested document is not old enough\n");
 381       data->info.timecond = TRUE;
 382       return FALSE;
 383     }
 384     break;
 385   }
 386
 387   return TRUE;
 388 }
 389
 390 /*
 391  * Go ahead and do a read if we have a readable socket or if
 392  * the stream was rewound (in which case we have data in a
 393  * buffer)
 394  */
 395 static CURLcode readwrite_data(struct SessionHandle *data,
 396                                struct connectdata *conn,
 397                                struct SingleRequest *k,
 398                                int *didwhat, bool *done)
 399 {
 400   CURLcode result = CURLE_OK;
 401   ssize_t nread; /* number of bytes read */
 402   size_t excess = 0; /* excess bytes read */
 403   bool is_empty_data = FALSE;
 404 #ifndef CURL_DISABLE_RTSP
 405   bool readmore = FALSE; /* used by RTP to signal for more data */
 406 #endif
 407
 408   *done = FALSE;
 409
 410   /* This is where we loop until we have read everything there is to
 411      read or we get a CURLE_AGAIN */
 412   do {
 413     size_t buffersize = data->set.buffer_size?
 414       data->set.buffer_size : BUFSIZE;
 415     size_t bytestoread = buffersize;
 416
 417     if(k->size != -1 && !k->header) {
 418       /* make sure we don't read "too much" if we can help it since we
 419          might be pipelining and then someone else might want to read what
 420          follows! */
 421       curl_off_t totalleft = k->size - k->bytecount;
 422       if(totalleft < (curl_off_t)bytestoread)
 423         bytestoread = (size_t)totalleft;
 424     }
 425
 426     if(bytestoread) {
 427       /* receive data from the network! */
 428       result = Curl_read(conn, conn->sockfd, k->buf, bytestoread, &nread);
 429
 430       /* read would've blocked */
 431       if(CURLE_AGAIN == result)
 432         break; /* get out of loop */
 433
 434       if(result>0)
 435         return result;
 436     }
 437     else {
 438       /* read nothing but since we wanted nothing we consider this an OK
 439          situation to proceed from */
 440       nread = 0;
 441     }
 442
 443     if((k->bytecount == 0) && (k->writebytecount == 0)) {
 444       Curl_pgrsTime(data, TIMER_STARTTRANSFER);
 445       if(k->exp100 > EXP100_SEND_DATA)
 446         /* set time stamp to compare with when waiting for the 100 */
 447         k->start100 = Curl_tvnow();
 448     }
 449
 450     *didwhat |= KEEP_RECV;
 451     /* indicates data of zero size, i.e. empty file */
 452     is_empty_data = (bool)((nread == 0) && (k->bodywrites == 0));
 453
 454     /* NUL terminate, allowing string ops to be used */
 455     if(0 < nread || is_empty_data) {
 456       k->buf[nread] = 0;
 457     }
 458     else if(0 >= nread) {
 459       /* if we receive 0 or less here, the server closed the connection
 460          and we bail out from this! */
 461       DEBUGF(infof(data, "nread <= 0, server closed connection, bailing\n"));
 462       k->keepon &= ~KEEP_RECV;
 463       break;
 464     }
 465
 466     /* Default buffer to use when we write the buffer, it may be changed
 467        in the flow below before the actual storing is done. */
 468     k->str = k->buf;
 469
 470 #ifndef CURL_DISABLE_RTSP
 471     /* Check for RTP at the beginning of the data */
 472     if(conn->protocol & PROT_RTSP) {
 473       result = Curl_rtsp_rtp_readwrite(data, conn, &nread, &readmore);
 474       if(result)
 475         return result;
 476       if(readmore)
 477         break;
 478     }
 479 #endif
 480
 481 #ifndef CURL_DISABLE_HTTP
 482     /* Since this is a two-state thing, we check if we are parsing
 483        headers at the moment or not. */
 484     if(k->header) {
 485       /* we are in parse-the-header-mode */
 486       bool stop_reading = FALSE;
 487       result = Curl_http_readwrite_headers(data, conn, &nread, &stop_reading);
 488       if(result)
 489         return result;
 490
 491 #ifndef CURL_DISABLE_RTSP
 492       /* Check for RTP after the headers if there is no Content */
 493       if(k->maxdownload <= 0 && nread > 0 && (conn->protocol & PROT_RTSP)) {
 494         result = Curl_rtsp_rtp_readwrite(data, conn, &nread, &readmore);
 495         if(result)
 496           return result;
 497         if(readmore)
 498           break;
 499       }
 500 #endif
 501
 502       if(stop_reading)
 503         /* We've stopped dealing with input, get out of the do-while loop */
 504         break;
 505     }
 506 #endif /* CURL_DISABLE_HTTP */
 507
 508
 509     /* This is not an 'else if' since it may be a rest from the header
 510        parsing, where the beginning of the buffer is headers and the end
 511        is non-headers. */
 512     if(k->str && !k->header && (nread > 0 || is_empty_data)) {
 513
 514
 515 #ifndef CURL_DISABLE_HTTP
 516       if(0 == k->bodywrites && !is_empty_data) {
 517         /* These checks are only made the first time we are about to
 518            write a piece of the body */
 519         if(conn->protocol&(PROT_HTTP|PROT_RTSP)) {
 520           /* HTTP-only checks */
 521
 522           if(data->req.newurl) {
 523             if(conn->bits.close) {
 524               /* Abort after the headers if "follow Location" is set
 525                  and we're set to close anyway. */
 526               k->keepon &= ~KEEP_RECV;
 527               *done = TRUE;
 528               return CURLE_OK;
 529             }
 530             /* We have a new url to load, but since we want to be able
 531                to re-use this connection properly, we read the full
 532                response in "ignore more" */
 533             k->ignorebody = TRUE;
 534             infof(data, "Ignoring the response-body\n");
 535           }
 536           if(data->state.resume_from && !k->content_range &&
 537              (data->set.httpreq==HTTPREQ_GET) &&
 538              !k->ignorebody) {
 539             /* we wanted to resume a download, although the server doesn't
 540              * seem to support this and we did this with a GET (if it
 541              * wasn't a GET we did a POST or PUT resume) */
 542             failf(data, "HTTP server doesn't seem to support "
 543                   "byte ranges. Cannot resume.");
 544             return CURLE_RANGE_ERROR;
 545           }
 546
 547           if(data->set.timecondition && !data->state.range) {
 548             /* A time condition has been set AND no ranges have been
 549                requested. This seems to be what chapter 13.3.4 of
 550                RFC 2616 defines to be the correct action for a
 551                HTTP/1.1 client */
 552
 553             if(!Curl_meets_timecondition(data, k->timeofdoc)) {
 554               *done = TRUE;
 555               return CURLE_OK;
 556             }
 557           } /* we have a time condition */
 558
 559         } /* this is HTTP */
 560       } /* this is the first time we write a body part */
 561 #endif /* CURL_DISABLE_HTTP */
 562       k->bodywrites++;
 563
 564       /* pass data to the debug function before it gets "dechunked" */
 565       if(data->set.verbose) {
 566         if(k->badheader) {
 567           Curl_debug(data, CURLINFO_DATA_IN, data->state.headerbuff,
 568                      (size_t)k->hbuflen, conn);
 569           if(k->badheader == HEADER_PARTHEADER)
 570             Curl_debug(data, CURLINFO_DATA_IN,
 571                        k->str, (size_t)nread, conn);
 572         }
 573         else
 574           Curl_debug(data, CURLINFO_DATA_IN,
 575                      k->str, (size_t)nread, conn);
 576       }
 577
 578 #ifndef CURL_DISABLE_HTTP
 579       if(k->chunk) {
 580         /*
 581          * Here comes a chunked transfer flying and we need to decode this
 582          * properly.  While the name says read, this function both reads
 583          * and writes away the data. The returned 'nread' holds the number
 584          * of actual data it wrote to the client.
 585          */
 586
 587         CHUNKcode res =
 588           Curl_httpchunk_read(conn, k->str, nread, &nread);
 589
 590         if(CHUNKE_OK < res) {
 591           if(CHUNKE_WRITE_ERROR == res) {
 592             failf(data, "Failed writing data");
 593             return CURLE_WRITE_ERROR;
 594           }
 595           failf(data, "Received problem %d in the chunky parser", (int)res);
 596           return CURLE_RECV_ERROR;
 597         }
 598         else if(CHUNKE_STOP == res) {
 599           size_t dataleft;
 600           /* we're done reading chunks! */
 601           k->keepon &= ~KEEP_RECV; /* read no more */
 602
 603           /* There are now possibly N number of bytes at the end of the
 604              str buffer that weren't written to the client.
 605
 606              We DO care about this data if we are pipelining.
 607              Push it back to be read on the next pass. */
 608
 609           dataleft = conn->chunk.dataleft;
 610           if(dataleft != 0) {
 611             infof(conn->data, "Leftovers after chunking: %zu bytes", dataleft);
 612             if(conn->data->multi && Curl_multi_canPipeline(conn->data->multi)) {
 613               /* only attempt the rewind if we truly are pipelining */
 614               infof(conn->data, "Rewinding %zu bytes\n",dataleft);
 615               read_rewind(conn, dataleft);
 616             }
 617           }
 618         }
 619         /* If it returned OK, we just keep going */
 620       }
 621 #endif   /* CURL_DISABLE_HTTP */
 622
 623       /* Account for body content stored in the header buffer */
 624       if(k->badheader && !k->ignorebody) {
 625         DEBUGF(infof(data, "Increasing bytecount by %zu from hbuflen\n",
 626                      k->hbuflen));
 627         k->bytecount += k->hbuflen;
 628       }
 629
 630       if((-1 != k->maxdownload) &&
 631          (k->bytecount + nread >= k->maxdownload)) {
 632
 633         excess = (size_t)(k->bytecount + nread - k->maxdownload);
 634         if(excess > 0 && !k->ignorebody) {
 635           if(conn->data->multi && Curl_multi_canPipeline(conn->data->multi)) {
 636             /* The 'excess' amount below can't be more than BUFSIZE which
 637                always will fit in a size_t */
 638             infof(data,
 639                   "Rewinding stream by : %zu"
 640                   " bytes on url %s (size = %" FORMAT_OFF_T
 641                   ", maxdownload = %" FORMAT_OFF_T
 642                   ", bytecount = %" FORMAT_OFF_T ", nread = %zd)\n",
 643                   excess, data->state.path,
 644                   k->size, k->maxdownload, k->bytecount, nread);
 645             read_rewind(conn, excess);
 646           }
 647           else {
 648             infof(data,
 649                   "Excess found in a non pipelined read:"
 650                   " excess = %zu"
 651                   ", size = %" FORMAT_OFF_T
 652                   ", maxdownload = %" FORMAT_OFF_T
 653                   ", bytecount = %" FORMAT_OFF_T "\n",
 654                   excess, k->size, k->maxdownload, k->bytecount);
 655           }
 656         }
 657
 658         nread = (ssize_t) (k->maxdownload - k->bytecount);
 659         if(nread < 0 ) /* this should be unusual */
 660           nread = 0;
 661
 662         k->keepon &= ~KEEP_RECV; /* we're done reading */
 663       }
 664
 665       k->bytecount += nread;
 666
 667       Curl_pgrsSetDownloadCounter(data, k->bytecount);
 668
 669       if(!k->chunk && (nread || k->badheader || is_empty_data)) {
 670         /* If this is chunky transfer, it was already written */
 671
 672         if(k->badheader && !k->ignorebody) {
 673           /* we parsed a piece of data wrongly assuming it was a header
 674              and now we output it as body instead */
 675
 676           /* Don't let excess data pollute body writes */
 677           if(k->maxdownload == -1 || (curl_off_t)k->hbuflen <= k->maxdownload)
 678             result = Curl_client_write(conn, CLIENTWRITE_BODY,
 679                 data->state.headerbuff,
 680                 k->hbuflen);
 681           else
 682             result = Curl_client_write(conn, CLIENTWRITE_BODY,
 683                 data->state.headerbuff,
 684                 (size_t)k->maxdownload);
 685
 686           if(result)
 687             return result;
 688         }
 689         if(k->badheader < HEADER_ALLBAD) {
 690           /* This switch handles various content encodings. If there's an
 691              error here, be sure to check over the almost identical code
 692              in http_chunks.c.
 693              Make sure that ALL_CONTENT_ENCODINGS contains all the
 694              encodings handled here. */
 695 #ifdef HAVE_LIBZ
 696           switch (conn->data->set.http_ce_skip ?
 697                   IDENTITY : k->content_encoding) {
 698           case IDENTITY:
 699 #endif
 700             /* This is the default when the server sends no
 701                Content-Encoding header. See Curl_readwrite_init; the
 702                memset() call initializes k->content_encoding to zero. */
 703             if(!k->ignorebody) {
 704
 705 #ifndef CURL_DISABLE_POP3
 706               if(conn->protocol&PROT_POP3)
 707                 result = Curl_pop3_write(conn, k->str, nread);
 708               else
 709 #endif /* CURL_DISABLE_POP3 */
 710
 711               result = Curl_client_write(conn, CLIENTWRITE_BODY, k->str,
 712                                          nread);
 713             }
 714 #ifdef HAVE_LIBZ
 715             break;
 716
 717           case DEFLATE:
 718             /* Assume CLIENTWRITE_BODY; headers are not encoded. */
 719             if(!k->ignorebody)
 720               result = Curl_unencode_deflate_write(conn, k, nread);
 721             break;
 722
 723           case GZIP:
 724             /* Assume CLIENTWRITE_BODY; headers are not encoded. */
 725             if(!k->ignorebody)
 726               result = Curl_unencode_gzip_write(conn, k, nread);
 727             break;
 728
 729           case COMPRESS:
 730           default:
 731             failf (data, "Unrecognized content encoding type. "
 732                    "libcurl understands `identity', `deflate' and `gzip' "
 733                    "content encodings.");
 734             result = CURLE_BAD_CONTENT_ENCODING;
 735             break;
 736           }
 737 #endif
 738         }
 739         k->badheader = HEADER_NORMAL; /* taken care of now */
 740
 741         if(result)
 742           return result;
 743       }
 744
 745     } /* if(! header and data to read ) */
 746
 747 #ifndef CURL_DISABLE_RTSP
 748     if(excess > 0 && !conn->bits.stream_was_rewound &&
 749         (conn->protocol & PROT_RTSP)) {
 750       /* Check for RTP after the content if there is unrewound excess */
 751
 752       /* Parse the excess data */
 753       k->str += nread;
 754       nread = (ssize_t)excess;
 755
 756       result = Curl_rtsp_rtp_readwrite(data, conn, &nread, &readmore);
 757       if(result)
 758         return result;
 759
 760       if(readmore)
 761         k->keepon |= KEEP_RECV; /* we're not done reading */
 762         break;
 763     }
 764 #endif
 765
 766     if(is_empty_data) {
 767       /* if we received nothing, the server closed the connection and we
 768          are done */
 769       k->keepon &= ~KEEP_RECV;
 770     }
 771
 772   } while(data_pending(conn));
 773
 774   if(((k->keepon & (KEEP_RECV|KEEP_SEND)) == KEEP_SEND) &&
 775      conn->bits.close ) {
 776     /* When we've read the entire thing and the close bit is set, the server
 777        may now close the connection. If there's now any kind of sending going
 778        on from our side, we need to stop that immediately. */
 779     infof(data, "we are done reading and this is set to close, stop send\n");
 780     k->keepon &= ~KEEP_SEND; /* no writing anymore either */
 781   }
 782
 783   return CURLE_OK;
 784 }
 785
 786 /*
 787  * Send data to upload to the server, when the socket is writable.
 788  */
 789 static CURLcode readwrite_upload(struct SessionHandle *data,
 790                                  struct connectdata *conn,
 791                                  struct SingleRequest *k,
 792                                  int *didwhat)
 793 {
 794   ssize_t i, si;
 795   ssize_t bytes_written;
 796   CURLcode result;
 797   ssize_t nread; /* number of bytes read */
 798   bool sending_http_headers = FALSE;
 799
 800   if((k->bytecount == 0) && (k->writebytecount == 0))
 801     Curl_pgrsTime(data, TIMER_STARTTRANSFER);
 802
 803   *didwhat |= KEEP_SEND;
 804
 805   /*
 806    * We loop here to do the READ and SEND loop until we run out of
 807    * data to send or until we get EWOULDBLOCK back
 808    */
 809   do {
 810
 811     /* only read more data if there's no upload data already
 812        present in the upload buffer */
 813     if(0 == data->req.upload_present) {
 814       /* init the "upload from here" pointer */
 815       data->req.upload_fromhere = k->uploadbuf;
 816
 817       if(!k->upload_done) {
 818         /* HTTP pollution, this should be written nicer to become more
 819            protocol agnostic. */
 820         int fillcount;
 821
 822         if((k->exp100 == EXP100_SENDING_REQUEST) &&
 823            (data->state.proto.http->sending == HTTPSEND_BODY)) {
 824           /* If this call is to send body data, we must take some action:
 825              We have sent off the full HTTP 1.1 request, and we shall now
 826              go into the Expect: 100 state and await such a header */
 827           k->exp100 = EXP100_AWAITING_CONTINUE; /* wait for the header */
 828           k->keepon &= ~KEEP_SEND;         /* disable writing */
 829           k->start100 = Curl_tvnow();       /* timeout count starts now */
 830           *didwhat &= ~KEEP_SEND;  /* we didn't write anything actually */
 831
 832           /* set a timeout for the multi interface */
 833           Curl_expire(data, CURL_TIMEOUT_EXPECT_100);
 834           break;
 835         }
 836
 837         if(conn->protocol&(PROT_HTTP|PROT_RTSP)) {
 838           if(data->state.proto.http->sending == HTTPSEND_REQUEST)
 839             /* We're sending the HTTP request headers, not the data.
 840                Remember that so we don't change the line endings. */
 841             sending_http_headers = TRUE;
 842           else
 843             sending_http_headers = FALSE;
 844         }
 845
 846         result = Curl_fillreadbuffer(conn, BUFSIZE, &fillcount);
 847         if(result)
 848           return result;
 849
 850         nread = (ssize_t)fillcount;
 851       }
 852       else
 853         nread = 0; /* we're done uploading/reading */
 854
 855       if(!nread && (k->keepon & KEEP_SEND_PAUSE)) {
 856         /* this is a paused transfer */
 857         break;
 858       }
 859       else if(nread<=0) {
 860         /* done */
 861         k->keepon &= ~KEEP_SEND; /* we're done writing */
 862
 863         if(conn->bits.rewindaftersend) {
 864           result = Curl_readrewind(conn);
 865           if(result)
 866             return result;
 867         }
 868         break;
 869       }
 870
 871       /* store number of bytes available for upload */
 872       data->req.upload_present = nread;
 873
 874 #ifndef CURL_DISABLE_SMTP
 875       if(conn->protocol & PROT_SMTP) {
 876         result = Curl_smtp_escape_eob(conn, nread);
 877         if(result)
 878           return result;
 879       }
 880       else
 881 #endif /* CURL_DISABLE_SMTP */
 882
 883       /* convert LF to CRLF if so asked */
 884       if((!sending_http_headers) &&
 885 #ifdef CURL_DO_LINEEND_CONV
 886         /* always convert if we're FTPing in ASCII mode */
 887          ((data->set.crlf) || (data->set.prefer_ascii))) {
 888 #else
 889          (data->set.crlf)) {
 890 #endif
 891         if(data->state.scratch == NULL)
 892           data->state.scratch = malloc(2*BUFSIZE);
 893         if(data->state.scratch == NULL) {
 894           failf (data, "Failed to alloc scratch buffer!");
 895           return CURLE_OUT_OF_MEMORY;
 896         }
 897         /*
 898          * ASCII/EBCDIC Note: This is presumably a text (not binary)
 899          * transfer so the data should already be in ASCII.
 900          * That means the hex values for ASCII CR (0x0d) & LF (0x0a)
 901          * must be used instead of the escape sequences \r & \n.
 902          */
 903         for(i = 0, si = 0; i < nread; i++, si++) {
 904           if(data->req.upload_fromhere[i] == 0x0a) {
 905             data->state.scratch[si++] = 0x0d;
 906             data->state.scratch[si] = 0x0a;
 907             if(!data->set.crlf) {
 908               /* we're here only because FTP is in ASCII mode...
 909                  bump infilesize for the LF we just added */
 910               data->set.infilesize++;
 911             }
 912           }
 913           else
 914             data->state.scratch[si] = data->req.upload_fromhere[i];
 915         }
 916         if(si != nread) {
 917           /* only perform the special operation if we really did replace
 918              anything */
 919           nread = si;
 920
 921           /* upload from the new (replaced) buffer instead */
 922           data->req.upload_fromhere = data->state.scratch;
 923
 924           /* set the new amount too */
 925           data->req.upload_present = nread;
 926         }
 927       }
 928     } /* if 0 == data->req.upload_present */
 929     else {
 930       /* We have a partial buffer left from a previous "round". Use
 931          that instead of reading more data */
 932     }
 933
 934     /* write to socket (send away data) */
 935     result = Curl_write(conn,
 936                         conn->writesockfd,     /* socket to send to */
 937                         data->req.upload_fromhere, /* buffer pointer */
 938                         data->req.upload_present,  /* buffer size */
 939                         &bytes_written);           /* actually sent */
 940
 941     if(result)
 942       return result;
 943
 944     if(data->set.verbose)
 945       /* show the data before we change the pointer upload_fromhere */
 946       Curl_debug(data, CURLINFO_DATA_OUT, data->req.upload_fromhere,
 947                  (size_t)bytes_written, conn);
 948
 949     k->writebytecount += bytes_written;
 950
 951     if(k->writebytecount == data->set.infilesize) {
 952       /* we have sent all data we were supposed to */
 953       k->upload_done = TRUE;
 954       infof(data, "We are completely uploaded and fine\n");
 955     }
 956
 957     if(data->req.upload_present != bytes_written) {
 958       /* we only wrote a part of the buffer (if anything), deal with it! */
 959
 960       /* store the amount of bytes left in the buffer to write */
 961       data->req.upload_present -= bytes_written;
 962
 963       /* advance the pointer where to find the buffer when the next send
 964          is to happen */
 965       data->req.upload_fromhere += bytes_written;
 966     }
 967     else {
 968       /* we've uploaded that buffer now */
 969       data->req.upload_fromhere = k->uploadbuf;
 970       data->req.upload_present = 0; /* no more bytes left */
 971
 972       if(k->upload_done) {
 973         /* switch off writing, we're done! */
 974         k->keepon &= ~KEEP_SEND; /* we're done writing */
 975       }
 976     }
 977
 978     Curl_pgrsSetUploadCounter(data, k->writebytecount);
 979
 980   } while(0); /* just to break out from! */
 981
 982   return CURLE_OK;
 983 }
 984
 985 /*
 986  * Curl_readwrite() is the low-level function to be called when data is to
 987  * be read and written to/from the connection.
 988  */
 989 CURLcode Curl_readwrite(struct connectdata *conn,
 990                         bool *done)
 991 {
 992   struct SessionHandle *data = conn->data;
 993   struct SingleRequest *k = &data->req;
 994   CURLcode result;
 995   int didwhat=0;
 996
 997   curl_socket_t fd_read;
 998   curl_socket_t fd_write;
 999   int select_res = conn->cselect_bits;
1000
1001   conn->cselect_bits = 0;
1002
1003   /* only use the proper socket if the *_HOLD bit is not set simultaneously as
1004      then we are in rate limiting state in that transfer direction */
1005
1006   if((k->keepon & KEEP_RECVBITS) == KEEP_RECV)
1007     fd_read = conn->sockfd;
1008   else
1009     fd_read = CURL_SOCKET_BAD;
1010
1011   if((k->keepon & KEEP_SENDBITS) == KEEP_SEND)
1012     fd_write = conn->writesockfd;
1013   else
1014     fd_write = CURL_SOCKET_BAD;
1015
1016   if(!select_res) /* Call for select()/poll() only, if read/write/error
1017                      status is not known. */
1018     select_res = Curl_socket_ready(fd_read, fd_write, 0);
1019
1020   if(select_res == CURL_CSELECT_ERR) {
1021     failf(data, "select/poll returned error");
1022     return CURLE_SEND_ERROR;
1023   }
1024
1025   /* We go ahead and do a read if we have a readable socket or if
1026      the stream was rewound (in which case we have data in a
1027      buffer) */
1028   if((k->keepon & KEEP_RECV) &&
1029      ((select_res & CURL_CSELECT_IN) || conn->bits.stream_was_rewound)) {
1030
1031     result = readwrite_data(data, conn, k, &didwhat, done);
1032     if(result || *done)
1033       return result;
1034   }
1035
1036   /* If we still have writing to do, we check if we have a writable socket. */
1037   if((k->keepon & KEEP_SEND) && (select_res & CURL_CSELECT_OUT)) {
1038     /* write */
1039
1040     result = readwrite_upload(data, conn, k, &didwhat);
1041     if(result)
1042       return result;
1043   }
1044
1045   k->now = Curl_tvnow();
1046   if(didwhat) {
1047     /* Update read/write counters */
1048     if(k->bytecountp)
1049       *k->bytecountp = k->bytecount; /* read count */
1050     if(k->writebytecountp)
1051       *k->writebytecountp = k->writebytecount; /* write count */
1052   }
1053   else {
1054     /* no read no write, this is a timeout? */
1055     if(k->exp100 == EXP100_AWAITING_CONTINUE) {
1056       /* This should allow some time for the header to arrive, but only a
1057          very short time as otherwise it'll be too much wasted time too
1058          often. */
1059
1060       /* Quoting RFC2616, section "8.2.3 Use of the 100 (Continue) Status":
1061
1062          Therefore, when a client sends this header field to an origin server
1063          (possibly via a proxy) from which it has never seen a 100 (Continue)
1064          status, the client SHOULD NOT wait for an indefinite period before
1065          sending the request body.
1066
1067       */
1068
1069       long ms = Curl_tvdiff(k->now, k->start100);
1070       if(ms > CURL_TIMEOUT_EXPECT_100) {
1071         /* we've waited long enough, continue anyway */
1072         k->exp100 = EXP100_SEND_DATA;
1073         k->keepon |= KEEP_SEND;
1074         infof(data, "Done waiting for 100-continue\n");
1075       }
1076     }
1077   }
1078
1079   if(Curl_pgrsUpdate(conn))
1080     result = CURLE_ABORTED_BY_CALLBACK;
1081   else
1082     result = Curl_speedcheck(data, k->now);
1083   if(result)
1084     return result;
1085
1086   if(k->keepon) {
1087     if(0 > Curl_timeleft(data, &k->now, FALSE)) {
1088       if(k->size != -1) {
1089         failf(data, "Operation timed out after %ld milliseconds with %"
1090               FORMAT_OFF_T " out of %" FORMAT_OFF_T " bytes received",
1091               Curl_tvdiff(k->now, data->progress.t_startsingle), k->bytecount,
1092               k->size);
1093       }
1094       else {
1095         failf(data, "Operation timed out after %ld milliseconds with %"
1096               FORMAT_OFF_T " bytes received",
1097               Curl_tvdiff(k->now, data->progress.t_startsingle), k->bytecount);
1098       }
1099       return CURLE_OPERATION_TIMEDOUT;
1100     }
1101   }
1102   else {
1103     /*
1104      * The transfer has been performed. Just make some general checks before
1105      * returning.
1106      */
1107
1108     if(!(data->set.opt_no_body) && (k->size != -1) &&
1109        (k->bytecount != k->size) &&
1110 #ifdef CURL_DO_LINEEND_CONV
1111        /* Most FTP servers don't adjust their file SIZE response for CRLFs,
1112           so we'll check to see if the discrepancy can be explained
1113           by the number of CRLFs we've changed to LFs.
1114        */
1115        (k->bytecount != (k->size + data->state.crlf_conversions)) &&
1116 #endif /* CURL_DO_LINEEND_CONV */
1117        !data->req.newurl) {
1118       failf(data, "transfer closed with %" FORMAT_OFF_T
1119             " bytes remaining to read",
1120             k->size - k->bytecount);
1121       return CURLE_PARTIAL_FILE;
1122     }
1123     else if(!(data->set.opt_no_body) &&
1124             k->chunk &&
1125             (conn->chunk.state != CHUNK_STOP)) {
1126       /*
1127        * In chunked mode, return an error if the connection is closed prior to
1128        * the empty (terminiating) chunk is read.
1129        *
1130        * The condition above used to check for
1131        * conn->proto.http->chunk.datasize != 0 which is true after reading
1132        * *any* chunk, not just the empty chunk.
1133        *
1134        */
1135       failf(data, "transfer closed with outstanding read data remaining");
1136       return CURLE_PARTIAL_FILE;
1137     }
1138     if(Curl_pgrsUpdate(conn))
1139       return CURLE_ABORTED_BY_CALLBACK;
1140   }
1141
1142   /* Now update the "done" boolean we return */
1143   *done = (bool)(0 == (k->keepon&(KEEP_RECV|KEEP_SEND|
1144                                   KEEP_RECV_PAUSE|KEEP_SEND_PAUSE)));
1145
1146   return CURLE_OK;
1147 }
1148
1149 /*
1150  * Curl_single_getsock() gets called by the multi interface code when the app
1151  * has requested to get the sockets for the current connection. This function
1152  * will then be called once for every connection that the multi interface
1153  * keeps track of. This function will only be called for connections that are
1154  * in the proper state to have this information available.
1155  */
1156 int Curl_single_getsock(const struct connectdata *conn,
1157                         curl_socket_t *sock, /* points to numsocks number
1158                                                 of sockets */
1159                         int numsocks)
1160 {
1161   const struct SessionHandle *data = conn->data;
1162   int bitmap = GETSOCK_BLANK;
1163   unsigned sockindex = 0;
1164
1165   if(conn->handler->perform_getsock)
1166     return conn->handler->perform_getsock(conn, sock, numsocks);
1167
1168   if(numsocks < 2)
1169     /* simple check but we might need two slots */
1170     return GETSOCK_BLANK;
1171
1172   /* don't include HOLD and PAUSE connections */
1173   if((data->req.keepon & KEEP_RECVBITS) == KEEP_RECV) {
1174
1175     DEBUGASSERT(conn->sockfd != CURL_SOCKET_BAD);
1176
1177     bitmap |= GETSOCK_READSOCK(sockindex);
1178     sock[sockindex] = conn->sockfd;
1179   }
1180
1181   /* don't include HOLD and PAUSE connections */
1182   if((data->req.keepon & KEEP_SENDBITS) == KEEP_SEND) {
1183
1184     if((conn->sockfd != conn->writesockfd) ||
1185        !(data->req.keepon & KEEP_RECV)) {
1186       /* only if they are not the same socket or we didn't have a readable
1187          one, we increase index */
1188       if(data->req.keepon & KEEP_RECV)
1189         sockindex++; /* increase index if we need two entries */
1190
1191       DEBUGASSERT(conn->writesockfd != CURL_SOCKET_BAD);
1192
1193       sock[sockindex] = conn->writesockfd;
1194     }
1195
1196     bitmap |= GETSOCK_WRITESOCK(sockindex);
1197   }
1198
1199   return bitmap;
1200 }
1201
1202 /*
1203  * Determine optimum sleep time based on configured rate, current rate,
1204  * and packet size.
1205  * Returns value in mili-seconds.
1206  *
1207  * The basic idea is to adjust the desired rate up/down in this method
1208  * based on whether we are running too slow or too fast.  Then, calculate
1209  * how many miliseconds to wait for the next packet to achieve this new
1210  * rate.
1211  */
1212 long Curl_sleep_time(curl_off_t rate_bps, curl_off_t cur_rate_bps,
1213                              int pkt_size)
1214 {
1215   curl_off_t min_sleep = 0;
1216   curl_off_t rv = 0;
1217
1218   if (rate_bps == 0)
1219     return 0;
1220
1221   /* If running faster than about .1% of the desired speed, slow
1222    * us down a bit.  Use shift instead of division as the 0.1%
1223    * cutoff is arbitrary anyway.
1224    */
1225   if (cur_rate_bps > (rate_bps + (rate_bps >> 10))) {
1226     /* running too fast, decrease target rate by 1/64th of rate */
1227     rate_bps -= rate_bps >> 6;
1228     min_sleep = 1;
1229   }
1230   else if (cur_rate_bps < (rate_bps - (rate_bps >> 10))) {
1231     /* running too slow, increase target rate by 1/64th of rate */
1232     rate_bps += rate_bps >> 6;
1233   }
1234
1235   /* Determine number of miliseconds to wait until we do
1236    * the next packet at the adjusted rate.  We should wait
1237    * longer when using larger packets, for instance.
1238    */
1239   rv = ((curl_off_t)((pkt_size * 8) * 1000) / rate_bps);
1240
1241   /* Catch rounding errors and always slow down at least 1ms if
1242    * we are running too fast.
1243    */
1244   if (rv < min_sleep)
1245     rv = min_sleep;
1246
1247   /* Bound value to fit in 'long' on 32-bit platform.  That's
1248    * plenty long enough anyway!
1249    */
1250   if(rv > 0x7fffffff)
1251     rv = 0x7fffffff;
1252
1253   return (long)rv;
1254 }
1255
1256
1257 /*
1258  * Transfer()
1259  *
1260  * This function is what performs the actual transfer. It is capable of doing
1261  * both ways simultaneously.  The transfer must already have been setup by a
1262  * call to Curl_setup_transfer().
1263  *
1264  * Note that headers are created in a preallocated buffer of a default size.
1265  * That buffer can be enlarged on demand, but it is never shrunken again.
1266  *
1267  */
1268
1269 static CURLcode
1270 Transfer(struct connectdata *conn)
1271 {
1272   CURLcode result;
1273   struct SessionHandle *data = conn->data;
1274   struct SingleRequest *k = &data->req;
1275   bool done=FALSE;
1276   bool first=TRUE;
1277   int timeout_ms;
1278   int buffersize;
1279   int totmp;
1280
1281   if((conn->sockfd == CURL_SOCKET_BAD) &&
1282      (conn->writesockfd == CURL_SOCKET_BAD))
1283     /* nothing to read, nothing to write, we're already OK! */
1284     return CURLE_OK;
1285
1286   /* we want header and/or body, if neither then don't do this! */
1287   if(!k->getheader && data->set.opt_no_body)
1288     return CURLE_OK;
1289
1290   while(!done) {
1291     curl_socket_t fd_read = conn->sockfd;
1292     curl_socket_t fd_write = conn->writesockfd;
1293     int keepon = k->keepon;
1294     timeout_ms = 1000;
1295
1296     if(conn->waitfor) {
1297       /* if waitfor is set, get the RECV and SEND bits from that but keep the
1298          other bits */
1299       keepon &= ~ (KEEP_RECV|KEEP_SEND);
1300       keepon |= conn->waitfor & (KEEP_RECV|KEEP_SEND);
1301     }
1302
1303     /* limit-rate logic: if speed exceeds threshold, then do not include fd in
1304        select set. The current speed is recalculated in each Curl_readwrite()
1305        call */
1306     if((keepon & KEEP_SEND) &&
1307         (!data->set.max_send_speed ||
1308          (data->progress.ulspeed < data->set.max_send_speed) )) {
1309       k->keepon &= ~KEEP_SEND_HOLD;
1310     }
1311     else {
1312       if (data->set.upload && data->set.max_send_speed &&
1313           (data->progress.ulspeed > data->set.max_send_speed) ) {
1314         /* calculate upload rate-limitation timeout. */
1315         buffersize = (int)(data->set.buffer_size ?
1316                            data->set.buffer_size : BUFSIZE);
1317         totmp = (int)Curl_sleep_time(data->set.max_send_speed,
1318                                      data->progress.ulspeed, buffersize);
1319         if (totmp < timeout_ms)
1320           timeout_ms = totmp;
1321       }
1322       fd_write = CURL_SOCKET_BAD;
1323       if(keepon & KEEP_SEND)
1324         k->keepon |= KEEP_SEND_HOLD; /* hold it */
1325     }
1326
1327     if((keepon & KEEP_RECV) &&
1328         (!data->set.max_recv_speed ||
1329          (data->progress.dlspeed < data->set.max_recv_speed)) ) {
1330       k->keepon &= ~KEEP_RECV_HOLD;
1331     }
1332     else {
1333       if ((!data->set.upload) && data->set.max_recv_speed &&
1334           (data->progress.dlspeed > data->set.max_recv_speed)) {
1335         /* Calculate download rate-limitation timeout. */
1336         buffersize = (int)(data->set.buffer_size ?
1337                            data->set.buffer_size : BUFSIZE);
1338         totmp = (int)Curl_sleep_time(data->set.max_recv_speed,
1339                                      data->progress.dlspeed, buffersize);
1340         if (totmp < timeout_ms)
1341           timeout_ms = totmp;
1342       }
1343       fd_read = CURL_SOCKET_BAD;
1344       if(keepon & KEEP_RECV)
1345         k->keepon |= KEEP_RECV_HOLD; /* hold it */
1346     }
1347
1348     /* pause logic. Don't check descriptors for paused connections */
1349     if(k->keepon & KEEP_RECV_PAUSE)
1350       fd_read = CURL_SOCKET_BAD;
1351     if(k->keepon & KEEP_SEND_PAUSE)
1352       fd_write = CURL_SOCKET_BAD;
1353
1354     /* The *_HOLD and *_PAUSE logic is necessary since even though there might
1355        be no traffic during the select interval, we still call
1356        Curl_readwrite() for the timeout case and if we limit transfer speed we
1357        must make sure that this function doesn't transfer anything while in
1358        HOLD status.
1359
1360        The no timeout for the first round is for the protocols for which data
1361        has already been slurped off the socket and thus waiting for action
1362        won't work since it'll wait even though there is already data present
1363        to work with. */
1364     if(first &&
1365        ((fd_read != CURL_SOCKET_BAD) || (fd_write != CURL_SOCKET_BAD)))
1366       /* if this is the first lap and one of the file descriptors is fine
1367          to work with, skip the timeout */
1368       timeout_ms = 0;
1369     else {
1370       totmp = Curl_timeleft(data, &k->now, FALSE);
1371       if(totmp < 0)
1372         return CURLE_OPERATION_TIMEDOUT;
1373       else if(!totmp)
1374         totmp = 1000;
1375
1376       if (totmp < timeout_ms)
1377         timeout_ms = totmp;
1378     }
1379
1380     switch (Curl_socket_ready(fd_read, fd_write, timeout_ms)) {
1381     case -1: /* select() error, stop reading */
1382 #ifdef EINTR
1383       /* The EINTR is not serious, and it seems you might get this more
1384          often when using the lib in a multi-threaded environment! */
1385       if(SOCKERRNO == EINTR)
1386         continue;
1387 #endif
1388       return CURLE_RECV_ERROR;  /* indicate a network problem */
1389     case 0:  /* timeout */
1390     default: /* readable descriptors */
1391
1392       result = Curl_readwrite(conn, &done);
1393       /* "done" signals to us if the transfer(s) are ready */
1394       break;
1395     }
1396     if(result)
1397       return result;
1398
1399     first = FALSE; /* not the first lap anymore */
1400   }
1401
1402   return CURLE_OK;
1403 }
1404
1405 static CURLcode loadhostpairs(struct SessionHandle *data)
1406 {
1407   struct curl_slist *hostp;
1408   char hostname[256];
1409   char address[256];
1410   int port;
1411
1412   for(hostp = data->change.resolve; hostp; hostp = hostp->next ) {
1413     if(!hostp->data)
1414       continue;
1415     if(hostp->data[0] == '-') {
1416       /* TODO: mark an entry for removal */
1417     }
1418     else if(3 == sscanf(hostp->data, "%255[^:]:%d:%255s", hostname, &port,
1419                         address)) {
1420       struct Curl_dns_entry *dns;
1421       Curl_addrinfo *addr;
1422
1423       addr = Curl_str2addr(address, port);
1424       if(!addr) {
1425         infof(data, "Resolve %s found illegal!\n", hostp->data);
1426         continue;
1427       }
1428       infof(data, "Added %s:%d:%s to DNS cache\n",
1429             hostname, port, address);
1430
1431       if(data->share)
1432         Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);
1433
1434       /* put this host in the cache */
1435       dns = Curl_cache_addr(data, addr, hostname, port);
1436
1437       if(data->share)
1438         Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
1439
1440       if(!dns)
1441         return CURLE_OUT_OF_MEMORY;
1442     }
1443   }
1444   data->change.resolve = NULL; /* dealt with now */
1445
1446   return CURLE_OK;
1447 }
1448
1449
1450 /*
1451  * Curl_pretransfer() is called immediately before a transfer starts.
1452  */
1453 CURLcode Curl_pretransfer(struct SessionHandle *data)
1454 {
1455   CURLcode res;
1456   if(!data->change.url) {
1457     /* we can't do anything without URL */
1458     failf(data, "No URL set!");
1459     return CURLE_URL_MALFORMAT;
1460   }
1461
1462   /* Init the SSL session ID cache here. We do it here since we want to do it
1463      after the *_setopt() calls (that could change the size of the cache) but
1464      before any transfer takes place. */
1465   res = Curl_ssl_initsessions(data, data->set.ssl.numsessions);
1466   if(res)
1467     return res;
1468
1469   data->set.followlocation=0; /* reset the location-follow counter */
1470   data->state.this_is_a_follow = FALSE; /* reset this */
1471   data->state.errorbuf = FALSE; /* no error has occurred */
1472   data->state.httpversion = 0; /* don't assume any particular server version */
1473
1474   data->state.ssl_connect_retry = FALSE;
1475
1476   data->state.authproblem = FALSE;
1477   data->state.authhost.want = data->set.httpauth;
1478   data->state.authproxy.want = data->set.proxyauth;
1479   Curl_safefree(data->info.wouldredirect);
1480   data->info.wouldredirect = NULL;
1481
1482   /* If there is a list of cookie files to read, do it now! */
1483   if(data->change.cookielist)
1484     Curl_cookie_loadfiles(data);
1485
1486   /* If there is a list of host pairs to deal with */
1487   if(data->change.resolve)
1488     res = loadhostpairs(data);
1489
1490   if(!res) {
1491     /* Allow data->set.use_port to set which port to use. This needs to be
1492      * disabled for example when we follow Location: headers to URLs using
1493      * different ports! */
1494     data->state.allow_port = TRUE;
1495
1496 #if defined(HAVE_SIGNAL) && defined(SIGPIPE) && !defined(HAVE_MSG_NOSIGNAL)
1497     /*************************************************************
1498      * Tell signal handler to ignore SIGPIPE
1499      *************************************************************/
1500     if(!data->set.no_signal)
1501       data->state.prev_signal = signal(SIGPIPE, SIG_IGN);
1502 #endif
1503
1504     Curl_initinfo(data); /* reset session-specific information "variables" */
1505     Curl_pgrsStartNow(data);
1506
1507     if(data->set.timeout)
1508       Curl_expire(data, data->set.timeout);
1509
1510     if(data->set.connecttimeout)
1511       Curl_expire(data, data->set.connecttimeout);
1512   }
1513
1514   return res;
1515 }
1516
1517 /*
1518  * Curl_posttransfer() is called immediately after a transfer ends
1519  */
1520 CURLcode Curl_posttransfer(struct SessionHandle *data)
1521 {
1522 #if defined(HAVE_SIGNAL) && defined(SIGPIPE) && !defined(HAVE_MSG_NOSIGNAL)
1523   /* restore the signal handler for SIGPIPE before we get back */
1524   if(!data->set.no_signal)
1525     signal(SIGPIPE, data->state.prev_signal);
1526 #else
1527   (void)data; /* unused parameter */
1528 #endif
1529
1530   if(!(data->progress.flags & PGRS_HIDE) &&
1531      !data->progress.callback)
1532     /* only output if we don't use a progress callback and we're not hidden */
1533     fprintf(data->set.err, "\n");
1534
1535   return CURLE_OK;
1536 }
1537
1538 #ifndef CURL_DISABLE_HTTP
1539 /*
1540  * strlen_url() returns the length of the given URL if the spaces within the
1541  * URL were properly URL encoded.
1542  */
1543 static size_t strlen_url(const char *url)
1544 {
1545   const char *ptr;
1546   size_t newlen=0;
1547   bool left=TRUE; /* left side of the ? */
1548
1549   for(ptr=url; *ptr; ptr++) {
1550     switch(*ptr) {
1551     case '?':
1552       left=FALSE;
1553       /* fall through */
1554     default:
1555       newlen++;
1556       break;
1557     case ' ':
1558       if(left)
1559         newlen+=3;
1560       else
1561         newlen++;
1562       break;
1563     }
1564   }
1565   return newlen;
1566 }
1567
1568 /* strcpy_url() copies a url to a output buffer and URL-encodes the spaces in
1569  * the source URL accordingly.
1570  */
1571 static void strcpy_url(char *output, const char *url)
1572 {
1573   /* we must add this with whitespace-replacing */
1574   bool left=TRUE;
1575   const char *iptr;
1576   char *optr = output;
1577   for(iptr = url;    /* read from here */
1578       *iptr;         /* until zero byte */
1579       iptr++) {
1580     switch(*iptr) {
1581     case '?':
1582       left=FALSE;
1583       /* fall through */
1584     default:
1585       *optr++=*iptr;
1586       break;
1587     case ' ':
1588       if(left) {
1589         *optr++='%'; /* add a '%' */
1590         *optr++='2'; /* add a '2' */
1591         *optr++='0'; /* add a '0' */
1592       }
1593       else
1594         *optr++='+'; /* add a '+' here */
1595       break;
1596     }
1597   }
1598   *optr=0; /* zero terminate output buffer */
1599
1600 }
1601
1602 /*
1603  * Returns true if the given URL is absolute (as opposed to relative)
1604  */
1605 static bool is_absolute_url(const char *url)
1606 {
1607   char prot[16]; /* URL protocol string storage */
1608   char letter;   /* used for a silly sscanf */
1609
1610   return (bool)(2 == sscanf(url, "%15[^?&/:]://%c", prot, &letter));
1611 }
1612
1613 /*
1614  * Concatenate a relative URL to a base URL making it absolute.
1615  * URL-encodes any spaces.
1616  * The returned pointer must be freed by the caller unless NULL
1617  * (returns NULL on out of memory).
1618  */
1619 static char *concat_url(const char *base, const char *relurl)
1620 {
1621   /***
1622    TRY to append this new path to the old URL
1623    to the right of the host part. Oh crap, this is doomed to cause
1624    problems in the future...
1625   */
1626   char *newest;
1627   char *protsep;
1628   char *pathsep;
1629   size_t newlen;
1630
1631   const char *useurl = relurl;
1632   size_t urllen;
1633
1634   /* we must make our own copy of the URL to play with, as it may
1635      point to read-only data */
1636   char *url_clone=strdup(base);
1637
1638   if(!url_clone)
1639     return NULL; /* skip out of this NOW */
1640
1641   /* protsep points to the start of the host name */
1642   protsep=strstr(url_clone, "//");
1643   if(!protsep)
1644     protsep=url_clone;
1645   else
1646     protsep+=2; /* pass the slashes */
1647
1648   if('/' != relurl[0]) {
1649     int level=0;
1650
1651     /* First we need to find out if there's a ?-letter in the URL,
1652        and cut it and the right-side of that off */
1653     pathsep = strchr(protsep, '?');
1654     if(pathsep)
1655       *pathsep=0;
1656
1657     /* we have a relative path to append to the last slash if there's one
1658        available, or if the new URL is just a query string (starts with a
1659        '?')  we append the new one at the end of the entire currently worked
1660        out URL */
1661     if(useurl[0] != '?') {
1662       pathsep = strrchr(protsep, '/');
1663       if(pathsep)
1664         *pathsep=0;
1665     }
1666
1667     /* Check if there's any slash after the host name, and if so, remember
1668        that position instead */
1669     pathsep = strchr(protsep, '/');
1670     if(pathsep)
1671       protsep = pathsep+1;
1672     else
1673       protsep = NULL;
1674
1675     /* now deal with one "./" or any amount of "../" in the newurl
1676        and act accordingly */
1677
1678     if((useurl[0] == '.') && (useurl[1] == '/'))
1679       useurl+=2; /* just skip the "./" */
1680
1681     while((useurl[0] == '.') &&
1682           (useurl[1] == '.') &&
1683           (useurl[2] == '/')) {
1684       level++;
1685       useurl+=3; /* pass the "../" */
1686     }
1687
1688     if(protsep) {
1689       while(level--) {
1690         /* cut off one more level from the right of the original URL */
1691         pathsep = strrchr(protsep, '/');
1692         if(pathsep)
1693           *pathsep=0;
1694         else {
1695           *protsep=0;
1696           break;
1697         }
1698       }
1699     }
1700   }
1701   else {
1702     /* We got a new absolute path for this server, cut off from the
1703        first slash */
1704     pathsep = strchr(protsep, '/');
1705     if(pathsep) {
1706       /* When people use badly formatted URLs, such as
1707          "http://www.url.com?dir=/home/daniel" we must not use the first
1708          slash, if there's a ?-letter before it! */
1709       char *sep = strchr(protsep, '?');
1710       if(sep && (sep < pathsep))
1711         pathsep = sep;
1712       *pathsep=0;
1713     }
1714     else {
1715       /* There was no slash. Now, since we might be operating on a badly
1716          formatted URL, such as "http://www.url.com?id=2380" which doesn't
1717          use a slash separator as it is supposed to, we need to check for a
1718          ?-letter as well! */
1719       pathsep = strchr(protsep, '?');
1720       if(pathsep)
1721         *pathsep=0;
1722     }
1723   }
1724
1725   /* If the new part contains a space, this is a mighty stupid redirect
1726      but we still make an effort to do "right". To the left of a '?'
1727      letter we replace each space with %20 while it is replaced with '+'
1728      on the right side of the '?' letter.
1729   */
1730   newlen = strlen_url(useurl);
1731
1732   urllen = strlen(url_clone);
1733
1734   newest = malloc( urllen + 1 + /* possible slash */
1735                          newlen + 1 /* zero byte */);
1736
1737   if(!newest) {
1738     free(url_clone); /* don't leak this */
1739     return NULL;
1740   }
1741
1742   /* copy over the root url part */
1743   memcpy(newest, url_clone, urllen);
1744
1745   /* check if we need to append a slash */
1746   if(('/' == useurl[0]) || (protsep && !*protsep) || ('?' == useurl[0]))
1747     ;
1748   else
1749     newest[urllen++]='/';
1750
1751   /* then append the new piece on the right side */
1752   strcpy_url(&newest[urllen], useurl);
1753
1754   free(url_clone);
1755
1756   return newest;
1757 }
1758 #endif /* CURL_DISABLE_HTTP */
1759
1760 /*
1761  * Curl_follow() handles the URL redirect magic. Pass in the 'newurl' string
1762  * as given by the remote server and set up the new URL to request.
1763  */
1764 CURLcode Curl_follow(struct SessionHandle *data,
1765                      char *newurl, /* this 'newurl' is the Location: string,
1766                                       and it must be malloc()ed before passed
1767                                       here */
1768                      followtype type) /* see transfer.h */
1769 {
1770 #ifdef CURL_DISABLE_HTTP
1771   (void)data;
1772   (void)newurl;
1773   (void)type;
1774   /* Location: following will not happen when HTTP is disabled */
1775   return CURLE_TOO_MANY_REDIRECTS;
1776 #else
1777
1778   /* Location: redirect */
1779   bool disallowport = FALSE;
1780
1781   if(type == FOLLOW_REDIR) {
1782     if((data->set.maxredirs != -1) &&
1783         (data->set.followlocation >= data->set.maxredirs)) {
1784       failf(data,"Maximum (%ld) redirects followed", data->set.maxredirs);
1785       return CURLE_TOO_MANY_REDIRECTS;
1786     }
1787
1788     /* mark the next request as a followed location: */
1789     data->state.this_is_a_follow = TRUE;
1790
1791     data->set.followlocation++; /* count location-followers */
1792
1793     if(data->set.http_auto_referer) {
1794       /* We are asked to automatically set the previous URL as the referer
1795          when we get the next URL. We pick the ->url field, which may or may
1796          not be 100% correct */
1797
1798       if(data->change.referer_alloc)
1799         /* If we already have an allocated referer, free this first */
1800         free(data->change.referer);
1801
1802       data->change.referer = strdup(data->change.url);
1803       if (!data->change.referer) {
1804         data->change.referer_alloc = FALSE;
1805         return CURLE_OUT_OF_MEMORY;
1806       }
1807       data->change.referer_alloc = TRUE; /* yes, free this later */
1808     }
1809   }
1810
1811   if(!is_absolute_url(newurl))  {
1812     /***
1813      *DANG* this is an RFC 2068 violation. The URL is supposed
1814      to be absolute and this doesn't seem to be that!
1815      */
1816     char *absolute = concat_url(data->change.url, newurl);
1817     if (!absolute)
1818       return CURLE_OUT_OF_MEMORY;
1819     free(newurl);
1820     newurl = absolute;
1821   }
1822   else {
1823     /* This is an absolute URL, don't allow the custom port number */
1824     disallowport = TRUE;
1825
1826     if(strchr(newurl, ' ')) {
1827       /* This new URL contains at least one space, this is a mighty stupid
1828          redirect but we still make an effort to do "right". */
1829       char *newest;
1830       size_t newlen = strlen_url(newurl);
1831
1832       newest = malloc(newlen+1); /* get memory for this */
1833       if (!newest)
1834         return CURLE_OUT_OF_MEMORY;
1835       strcpy_url(newest, newurl); /* create a space-free URL */
1836
1837       free(newurl); /* that was no good */
1838       newurl = newest; /* use this instead now */
1839     }
1840
1841   }
1842
1843   if(type == FOLLOW_FAKE) {
1844     /* we're only figuring out the new url if we would've followed locations
1845        but now we're done so we can get out! */
1846     data->info.wouldredirect = newurl;
1847     return CURLE_OK;
1848   }
1849
1850   if(disallowport)
1851     data->state.allow_port = FALSE;
1852
1853   if(data->change.url_alloc)
1854     free(data->change.url);
1855   else
1856     data->change.url_alloc = TRUE; /* the URL is allocated */
1857
1858   data->change.url = newurl;
1859   newurl = NULL; /* don't free! */
1860
1861   infof(data, "Issue another request to this URL: '%s'\n", data->change.url);
1862
1863   /*
1864    * We get here when the HTTP code is 300-399 (and 401). We need to perform
1865    * differently based on exactly what return code there was.
1866    *
1867    * News from 7.10.6: we can also get here on a 401 or 407, in case we act on
1868    * a HTTP (proxy-) authentication scheme other than Basic.
1869    */
1870   switch(data->info.httpcode) {
1871     /* 401 - Act on a WWW-Authenticate, we keep on moving and do the
1872        Authorization: XXXX header in the HTTP request code snippet */
1873     /* 407 - Act on a Proxy-Authenticate, we keep on moving and do the
1874        Proxy-Authorization: XXXX header in the HTTP request code snippet */
1875     /* 300 - Multiple Choices */
1876     /* 306 - Not used */
1877     /* 307 - Temporary Redirect */
1878   default:  /* for all above (and the unknown ones) */
1879     /* Some codes are explicitly mentioned since I've checked RFC2616 and they
1880      * seem to be OK to POST to.
1881      */
1882     break;
1883   case 301: /* Moved Permanently */
1884     /* (quote from RFC2616, section 10.3.2):
1885      *
1886      * Note: When automatically redirecting a POST request after receiving a
1887      * 301 status code, some existing HTTP/1.0 user agents will erroneously
1888      * change it into a GET request.
1889      *
1890      * ----
1891      *
1892      * Warning: Because most of importants user agents do this obvious RFC2616
1893      * violation, many webservers expect this misbehavior. So these servers
1894      * often answers to a POST request with an error page.  To be sure that
1895      * libcurl gets the page that most user agents would get, libcurl has to
1896      * force GET.
1897      *
1898      * This behaviour can be overridden with CURLOPT_POSTREDIR.
1899      */
1900     if( (data->set.httpreq == HTTPREQ_POST
1901          || data->set.httpreq == HTTPREQ_POST_FORM)
1902         && !data->set.post301) {
1903       infof(data,
1904             "Violate RFC 2616/10.3.2 and switch from POST to GET\n");
1905       data->set.httpreq = HTTPREQ_GET;
1906     }
1907     break;
1908   case 302: /* Found */
1909     /* (From 10.3.3)
1910
1911     Note: RFC 1945 and RFC 2068 specify that the client is not allowed
1912     to change the method on the redirected request.  However, most
1913     existing user agent implementations treat 302 as if it were a 303
1914     response, performing a GET on the Location field-value regardless
1915     of the original request method. The status codes 303 and 307 have
1916     been added for servers that wish to make unambiguously clear which
1917     kind of reaction is expected of the client.
1918
1919     (From 10.3.4)
1920
1921     Note: Many pre-HTTP/1.1 user agents do not understand the 303
1922     status. When interoperability with such clients is a concern, the
1923     302 status code may be used instead, since most user agents react
1924     to a 302 response as described here for 303.
1925
1926     This behaviour can be overriden with CURLOPT_POSTREDIR
1927     */
1928     if( (data->set.httpreq == HTTPREQ_POST
1929          || data->set.httpreq == HTTPREQ_POST_FORM)
1930         && !data->set.post302) {
1931       infof(data,
1932             "Violate RFC 2616/10.3.3 and switch from POST to GET\n");
1933       data->set.httpreq = HTTPREQ_GET;
1934     }
1935     break;
1936
1937   case 303: /* See Other */
1938     /* Disable both types of POSTs, since doing a second POST when
1939      * following isn't what anyone would want! */
1940     if(data->set.httpreq != HTTPREQ_GET) {
1941       data->set.httpreq = HTTPREQ_GET; /* enforce GET request */
1942       infof(data, "Disables POST, goes with %s\n",
1943             data->set.opt_no_body?"HEAD":"GET");
1944     }
1945     break;
1946   case 304: /* Not Modified */
1947     /* 304 means we did a conditional request and it was "Not modified".
1948      * We shouldn't get any Location: header in this response!
1949      */
1950     break;
1951   case 305: /* Use Proxy */
1952     /* (quote from RFC2616, section 10.3.6):
1953      * "The requested resource MUST be accessed through the proxy given
1954      * by the Location field. The Location field gives the URI of the
1955      * proxy.  The recipient is expected to repeat this single request
1956      * via the proxy. 305 responses MUST only be generated by origin
1957      * servers."
1958      */
1959     break;
1960   }
1961   Curl_pgrsTime(data, TIMER_REDIRECT);
1962   Curl_pgrsResetTimes(data);
1963
1964   return CURLE_OK;
1965 #endif /* CURL_DISABLE_HTTP */
1966 }
1967
1968 static CURLcode
1969 connect_host(struct SessionHandle *data,
1970              struct connectdata **conn)
1971 {
1972   CURLcode res = CURLE_OK;
1973
1974   bool async;
1975   bool protocol_done=TRUE; /* will be TRUE always since this is only used
1976                                 within the easy interface */
1977   Curl_pgrsTime(data, TIMER_STARTSINGLE);
1978   res = Curl_connect(data, conn, &async, &protocol_done);
1979
1980   if((CURLE_OK == res) && async) {
1981     /* Now, if async is TRUE here, we need to wait for the name
1982        to resolve */
1983     res = Curl_wait_for_resolv(*conn, NULL);
1984     if(CURLE_OK == res)
1985       /* Resolved, continue with the connection */
1986       res = Curl_async_resolved(*conn, &protocol_done);
1987     else
1988       /* if we can't resolve, we kill this "connection" now */
1989       (void)Curl_disconnect(*conn, /* dead_connection */ FALSE);
1990   }
1991
1992   return res;
1993 }
1994
1995 CURLcode
1996 Curl_reconnect_request(struct connectdata **connp)
1997 {
1998   CURLcode result = CURLE_OK;
1999   struct connectdata *conn = *connp;
2000   struct SessionHandle *data = conn->data;
2001
2002   /* This was a re-use of a connection and we got a write error in the
2003    * DO-phase. Then we DISCONNECT this connection and have another attempt to
2004    * CONNECT and then DO again! The retry cannot possibly find another
2005    * connection to re-use, since we only keep one possible connection for
2006    * each.  */
2007
2008   infof(data, "Re-used connection seems dead, get a new one\n");
2009
2010   conn->bits.close = TRUE; /* enforce close of this connection */
2011   result = Curl_done(&conn, result, FALSE); /* we are so done with this */
2012
2013   /* conn may no longer be a good pointer */
2014
2015   /*
2016    * According to bug report #1330310. We need to check for CURLE_SEND_ERROR
2017    * here as well. I figure this could happen when the request failed on a FTP
2018    * connection and thus Curl_done() itself tried to use the connection
2019    * (again). Slight Lack of feedback in the report, but I don't think this
2020    * extra check can do much harm.
2021    */
2022   if((CURLE_OK == result) || (CURLE_SEND_ERROR == result)) {
2023     bool async;
2024     bool protocol_done = TRUE;
2025
2026     /* Now, redo the connect and get a new connection */
2027     result = Curl_connect(data, connp, &async, &protocol_done);
2028     if(CURLE_OK == result) {
2029       /* We have connected or sent away a name resolve query fine */
2030
2031       conn = *connp; /* setup conn to again point to something nice */
2032       if(async) {
2033         /* Now, if async is TRUE here, we need to wait for the name
2034            to resolve */
2035         result = Curl_wait_for_resolv(conn, NULL);
2036         if(result)
2037           return result;
2038
2039         /* Resolved, continue with the connection */
2040         result = Curl_async_resolved(conn, &protocol_done);
2041         if(result)
2042           return result;
2043       }
2044     }
2045   }
2046
2047   return result;
2048 }
2049
2050 /* Returns CURLE_OK *and* sets '*url' if a request retry is wanted.
2051
2052    NOTE: that the *url is malloc()ed. */
2053 CURLcode Curl_retry_request(struct connectdata *conn,
2054                             char **url)
2055 {
2056   struct SessionHandle *data = conn->data;
2057
2058   *url = NULL;
2059
2060   /* if we're talking upload, we can't do the checks below, unless the protocol
2061      is HTTP as when uploading over HTTP we will still get a response */
2062   if(data->set.upload && !(conn->protocol&(PROT_HTTP|PROT_RTSP)))
2063     return CURLE_OK;
2064
2065   if(/* workaround for broken TLS servers */ data->state.ssl_connect_retry ||
2066       ((data->req.bytecount +
2067         data->req.headerbytecount == 0) &&
2068         conn->bits.reuse &&
2069         !data->set.opt_no_body &&
2070         data->set.rtspreq != RTSPREQ_RECEIVE)) {
2071     /* We got no data, we attempted to re-use a connection and yet we want a
2072        "body". This might happen if the connection was left alive when we were
2073        done using it before, but that was closed when we wanted to read from
2074        it again. Bad luck. Retry the same request on a fresh connect! */
2075     infof(conn->data, "Connection died, retrying a fresh connect\n");
2076     *url = strdup(conn->data->change.url);
2077     if(!*url)
2078       return CURLE_OUT_OF_MEMORY;
2079
2080     conn->bits.close = TRUE; /* close this connection */
2081     conn->bits.retry = TRUE; /* mark this as a connection we're about
2082                                 to retry. Marking it this way should
2083                                 prevent i.e HTTP transfers to return
2084                                 error just because nothing has been
2085                                 transfered! */
2086   }
2087   return CURLE_OK;
2088 }
2089
2090 static CURLcode Curl_do_perform(struct SessionHandle *data)
2091 {
2092   CURLcode res;
2093   CURLcode res2;
2094   struct connectdata *conn=NULL;
2095   char *newurl = NULL; /* possibly a new URL to follow to! */
2096   followtype follow = FOLLOW_NONE;
2097
2098   data->state.used_interface = Curl_if_easy;
2099
2100   res = Curl_pretransfer(data);
2101   if(res)
2102     return res;
2103
2104   /*
2105    * It is important that there is NO 'return' from this function at any other
2106    * place than falling down to the end of the function! This is because we
2107    * have cleanup stuff that must be done before we get back, and that is only
2108    * performed after this do-while loop.
2109    */
2110
2111   for(;;) {
2112     res = connect_host(data, &conn);   /* primary connection */
2113
2114     if(res == CURLE_OK) {
2115       bool do_done;
2116       if(data->set.connect_only) {
2117         /* keep connection open for application to use the socket */
2118         conn->bits.close = FALSE;
2119         res = Curl_done(&conn, CURLE_OK, FALSE);
2120         break;
2121       }
2122       res = Curl_do(&conn, &do_done);
2123
2124       if(res == CURLE_OK) {
2125         if(conn->data->set.wildcardmatch) {
2126           if(conn->data->wildcard.state == CURLWC_DONE ||
2127              conn->data->wildcard.state == CURLWC_SKIP) {
2128             /* keep connection open for application to use the socket */
2129             conn->bits.close = FALSE;
2130             res = Curl_done(&conn, CURLE_OK, FALSE);
2131             break;
2132           }
2133         }
2134         res = Transfer(conn); /* now fetch that URL please */
2135         if((res == CURLE_OK) || (res == CURLE_RECV_ERROR)) {
2136           bool retry = FALSE;
2137           CURLcode rc = Curl_retry_request(conn, &newurl);
2138           if(rc)
2139             res = rc;
2140           else
2141             retry = (newurl?TRUE:FALSE);
2142
2143           if(retry) {
2144             /* we know (newurl != NULL) at this point */
2145             res = CURLE_OK;
2146             follow = FOLLOW_RETRY;
2147           }
2148           else if (res == CURLE_OK) {
2149             /*
2150              * We must duplicate the new URL here as the connection data may
2151              * be free()ed in the Curl_done() function. We prefer the newurl
2152              * one since that's used for redirects or just further requests
2153              * for retries or multi-stage HTTP auth methods etc.
2154              */
2155             if(data->req.newurl) {
2156               follow = FOLLOW_REDIR;
2157               newurl = strdup(data->req.newurl);
2158               if (!newurl)
2159                 res = CURLE_OUT_OF_MEMORY;
2160             }
2161             else if(data->req.location) {
2162               follow = FOLLOW_FAKE;
2163               newurl = strdup(data->req.location);
2164               if (!newurl)
2165                 res = CURLE_OUT_OF_MEMORY;
2166             }
2167           }
2168
2169           /* in the above cases where 'newurl' gets assigned, we have a fresh
2170            * allocated memory pointed to */
2171         }
2172         if(res != CURLE_OK) {
2173           /* The transfer phase returned error, we mark the connection to get
2174            * closed to prevent being re-used. This is because we can't
2175            * possibly know if the connection is in a good shape or not now. */
2176           conn->bits.close = TRUE;
2177
2178           if(CURL_SOCKET_BAD != conn->sock[SECONDARYSOCKET]) {
2179             /* if we failed anywhere, we must clean up the secondary socket if
2180                it was used */
2181             sclose(conn->sock[SECONDARYSOCKET]);
2182             conn->sock[SECONDARYSOCKET] = CURL_SOCKET_BAD;
2183           }
2184         }
2185
2186         /* Always run Curl_done(), even if some of the previous calls
2187            failed, but return the previous (original) error code */
2188         res2 = Curl_done(&conn, res, FALSE);
2189
2190         if(CURLE_OK == res)
2191           res = res2;
2192       }
2193       else if(conn)
2194         /* Curl_do() failed, clean up left-overs in the done-call, but note
2195            that at some cases the conn pointer is NULL when Curl_do() failed
2196            and the connection cache is very small so only call Curl_done() if
2197            conn is still "alive". */
2198         /* ignore return code since we already have an error to return */
2199         (void)Curl_done(&conn, res, FALSE);
2200
2201       /*
2202        * Important: 'conn' cannot be used here, since it may have been closed
2203        * in 'Curl_done' or other functions.
2204        */
2205
2206       if((res == CURLE_OK) && follow) {
2207         res = Curl_follow(data, newurl, follow);
2208         if(CURLE_OK == res) {
2209           /* if things went fine, Curl_follow() freed or otherwise took
2210              responsibility for the newurl pointer */
2211           newurl = NULL;
2212           if(follow >= FOLLOW_RETRY) {
2213             follow = FOLLOW_NONE;
2214             continue;
2215           }
2216           /* else we break out of the loop below */
2217         }
2218       }
2219     }
2220     break; /* it only reaches here when this shouldn't loop */
2221
2222   } /* loop if Location: */
2223
2224   if(newurl)
2225     free(newurl);
2226
2227   if(res && !data->state.errorbuf) {
2228     /*
2229      * As an extra precaution: if no error string has been set and there was
2230      * an error, use the strerror() string or if things are so bad that not
2231      * even that is good, set a bad string that mentions the error code.
2232      */
2233     const char *str = curl_easy_strerror(res);
2234     if(!str)
2235       failf(data, "unspecified error %d", (int)res);
2236     else
2237       failf(data, "%s", str);
2238   }
2239
2240   /* run post-transfer unconditionally, but don't clobber the return code if
2241      we already have an error code recorder */
2242   res2 = Curl_posttransfer(data);
2243   if(!res && res2)
2244     res = res2;
2245
2246   return res;
2247 }
2248
2249 /*
2250  * Curl_perform() is the internal high-level function that gets called by the
2251  * external curl_easy_perform() function. It inits, performs and cleans up a
2252  * single file transfer.
2253  */
2254 CURLcode Curl_perform(struct SessionHandle *data)
2255 {
2256   CURLcode res;
2257   if(!data->set.wildcardmatch)
2258     return Curl_do_perform(data);
2259
2260   /* init main wildcard structures */
2261   res = Curl_wildcard_init(&data->wildcard);
2262   if(res)
2263     return res;
2264
2265   res = Curl_do_perform(data);
2266   if(res) {
2267     Curl_wildcard_dtor(&data->wildcard);
2268     return res;
2269   }
2270
2271   /* wildcard loop */
2272   while(!res && data->wildcard.state != CURLWC_DONE)
2273     res = Curl_do_perform(data);
2274
2275   Curl_wildcard_dtor(&data->wildcard);
2276
2277   /* wildcard download finished or failed */
2278   data->wildcard.state = CURLWC_INIT;
2279   return res;
2280 }
2281
2282 /*
2283  * Curl_setup_transfer() is called to setup some basic properties for the
2284  * upcoming transfer.
2285  */
2286 void
2287 Curl_setup_transfer(
2288   struct connectdata *conn, /* connection data */
2289   int sockindex,            /* socket index to read from or -1 */
2290   curl_off_t size,          /* -1 if unknown at this point */
2291   bool getheader,           /* TRUE if header parsing is wanted */
2292   curl_off_t *bytecountp,   /* return number of bytes read or NULL */
2293   int writesockindex,       /* socket index to write to, it may very well be
2294                                the same we read from. -1 disables */
2295   curl_off_t *writecountp   /* return number of bytes written or NULL */
2296   )
2297 {
2298   struct SessionHandle *data;
2299   struct SingleRequest *k;
2300
2301   DEBUGASSERT(conn != NULL);
2302
2303   data = conn->data;
2304   k = &data->req;
2305
2306   DEBUGASSERT((sockindex <= 1) && (sockindex >= -1));
2307
2308   /* now copy all input parameters */
2309   conn->sockfd = sockindex == -1 ?
2310       CURL_SOCKET_BAD : conn->sock[sockindex];
2311   conn->writesockfd = writesockindex == -1 ?
2312       CURL_SOCKET_BAD:conn->sock[writesockindex];
2313   k->getheader = getheader;
2314
2315   k->size = size;
2316   k->bytecountp = bytecountp;
2317   k->writebytecountp = writecountp;
2318
2319   /* The code sequence below is placed in this function just because all
2320      necessary input is not always known in do_complete() as this function may
2321      be called after that */
2322
2323   if(!k->getheader) {
2324     k->header = FALSE;
2325     if(size > 0)
2326       Curl_pgrsSetDownloadSize(data, size);
2327   }
2328   /* we want header and/or body, if neither then don't do this! */
2329   if(k->getheader || !data->set.opt_no_body) {
2330
2331     if(conn->sockfd != CURL_SOCKET_BAD)
2332       k->keepon |= KEEP_RECV;
2333
2334     if(conn->writesockfd != CURL_SOCKET_BAD) {
2335       /* HTTP 1.1 magic:
2336
2337          Even if we require a 100-return code before uploading data, we might
2338          need to write data before that since the REQUEST may not have been
2339          finished sent off just yet.
2340
2341          Thus, we must check if the request has been sent before we set the
2342          state info where we wait for the 100-return code
2343       */
2344       if((data->state.expect100header) &&
2345          (data->state.proto.http->sending == HTTPSEND_BODY)) {
2346         /* wait with write until we either got 100-continue or a timeout */
2347         k->exp100 = EXP100_AWAITING_CONTINUE;
2348         k->start100 = k->start;
2349
2350         /* set a timeout for the multi interface */
2351         Curl_expire(data, CURL_TIMEOUT_EXPECT_100);
2352       }
2353       else {
2354         if(data->state.expect100header)
2355           /* when we've sent off the rest of the headers, we must await a
2356              100-continue but first finish sending the request */
2357           k->exp100 = EXP100_SENDING_REQUEST;
2358
2359         /* enable the write bit when we're not waiting for continue */
2360         k->keepon |= KEEP_SEND;
2361       }
2362     } /* if(conn->writesockfd != CURL_SOCKET_BAD) */
2363   } /* if(k->getheader || !data->set.opt_no_body) */
2364
2365 }