luna - curl/lib/ftp.c

   1/***************************************************************************
   2 *                                  _   _ ____  _
   3 *  Project                     ___| | | |  _ \| |
   4 *                             / __| | | | |_) | |
   5 *                            | (__| |_| |  _ <| |___
   6 *                             \___|\___/|_| \_\_____|
   7 *
   8 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
   9 *
  10 * This software is licensed as described in the file COPYING, which
  11 * you should have received as part of this distribution. The terms
  12 * are also available at https://curl.se/docs/copyright.html.
  13 *
  14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15 * copies of the Software, and permit persons to whom the Software is
  16 * furnished to do so, under the terms of the COPYING file.
  17 *
  18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19 * KIND, either express or implied.
  20 *
  21 * SPDX-License-Identifier: curl
  22 *
  23 ***************************************************************************/
  24#include "curl_setup.h"
  25#include "urldata.h"
  26
  27#ifndef CURL_DISABLE_FTP
  28
  29#ifdef HAVE_NETINET_IN_H
  30#include <netinet/in.h>
  31#endif
  32#ifdef HAVE_ARPA_INET_H
  33#include <arpa/inet.h>
  34#endif
  35#ifdef HAVE_NETDB_H
  36#include <netdb.h>
  37#endif
  38#ifdef __VMS
  39#include <in.h>
  40#include <inet.h>
  41#endif
  42
  43#include "sendf.h"
  44#include "curl_addrinfo.h"
  45#include "curl_trc.h"
  46#include "if2ip.h"
  47#include "hostip.h"
  48#include "progress.h"
  49#include "transfer.h"
  50#include "escape.h"
  51#include "ftp.h"
  52#include "ftp-int.h"
  53#include "ftplistparser.h"
  54#include "curl_range.h"
  55#include "strcase.h"
  56#include "vtls/vtls.h"
  57#include "cfilters.h"
  58#include "cf-socket.h"
  59#include "connect.h"
  60#include "curlx/inet_ntop.h"
  61#include "curlx/inet_pton.h"
  62#include "select.h"
  63#include "parsedate.h" /* for the week day and month names */
  64#include "sockaddr.h" /* required for Curl_sockaddr_storage */
  65#include "multiif.h"
  66#include "url.h"
  67#include "http_proxy.h"
  68#include "curlx/strdup.h"
  69#include "curlx/strerr.h"
  70#include "curlx/strparse.h"
  71#include "curl_ctype.h"
  72
  73#ifndef NI_MAXHOST
  74#define NI_MAXHOST 1025
  75#endif
  76#ifndef INET_ADDRSTRLEN
  77#define INET_ADDRSTRLEN 16
  78#endif
  79
  80/* macro to check for a three-digit ftp status code at the start of the
  81   given string */
  82#define STATUSCODE(line) \
  83  (ISDIGIT((line)[0]) && ISDIGIT((line)[1]) && ISDIGIT((line)[2]))
  84
  85/* macro to check for the last line in an FTP server response */
  86#define LASTLINE(line) (STATUSCODE(line) && (' ' == (line)[3]))
  87
  88#ifdef CURLVERBOSE
  89/* for tracing purposes */
  90static const char * const ftp_state_names[] = {
  91  "STOP",
  92  "WAIT220",
  93  "AUTH",
  94  "USER",
  95  "PASS",
  96  "ACCT",
  97  "PBSZ",
  98  "PROT",
  99  "CCC",
 100  "PWD",
 101  "SYST",
 102  "NAMEFMT",
 103  "QUOTE",
 104  "RETR_PREQUOTE",
 105  "STOR_PREQUOTE",
 106  "LIST_PREQUOTE",
 107  "POSTQUOTE",
 108  "CWD",
 109  "MKD",
 110  "MDTM",
 111  "TYPE",
 112  "LIST_TYPE",
 113  "RETR_LIST_TYPE",
 114  "RETR_TYPE",
 115  "STOR_TYPE",
 116  "SIZE",
 117  "RETR_SIZE",
 118  "STOR_SIZE",
 119  "REST",
 120  "RETR_REST",
 121  "PORT",
 122  "PRET",
 123  "PASV",
 124  "LIST",
 125  "RETR",
 126  "STOR",
 127  "QUIT"
 128};
 129#define FTP_CSTATE(ftpc)   ((ftpc) ? ftp_state_names[(ftpc)->state] : "???")
 130
 131#endif /* CURLVERBOSE */
 132
 133/* This is the ONLY way to change FTP state! */
 134static void ftp_state_low(struct Curl_easy *data,
 135                          struct ftp_conn *ftpc,
 136                          ftpstate newstate
 137#ifdef DEBUGBUILD
 138                          , int lineno
 139#endif
 140  )
 141{
 142  if(ftpc->state != newstate) {
 143#ifdef DEBUGBUILD
 144    NOVERBOSE((void)lineno);
 145    CURL_TRC_FTP(data, "[%s] -> [%s] (line %d)", FTP_CSTATE(ftpc),
 146                 ftp_state_names[newstate], lineno);
 147#else
 148    CURL_TRC_FTP(data, "[%s] -> [%s]", FTP_CSTATE(ftpc),
 149                 ftp_state_names[newstate]);
 150#endif
 151  }
 152  ftpc->state = newstate;
 153}
 154
 155/* Local API functions */
 156#ifndef DEBUGBUILD
 157#define ftp_state(x, y, z) ftp_state_low(x, y, z)
 158#else /* !DEBUGBUILD */
 159#define ftp_state(x, y, z) ftp_state_low(x, y, z, __LINE__)
 160#endif /* DEBUGBUILD */
 161
 162static CURLcode ftp_state_mdtm(struct Curl_easy *data,
 163                               struct ftp_conn *ftpc,
 164                               struct FTP *ftp);
 165static CURLcode ftp_state_quote(struct Curl_easy *data,
 166                                struct ftp_conn *ftpc,
 167                                struct FTP *ftp,
 168                                bool init, ftpstate instate);
 169static CURLcode ftp_nb_type(struct Curl_easy *data,
 170                            struct ftp_conn *ftpc,
 171                            struct FTP *ftp,
 172                            bool ascii, ftpstate newstate);
 173static CURLcode getftpresponse(struct Curl_easy *data, size_t *nreadp,
 174                               int *ftpcodep);
 175
 176static void freedirs(struct ftp_conn *ftpc)
 177{
 178  curlx_safefree(ftpc->dirs);
 179  ftpc->dirdepth = 0;
 180  curlx_safefree(ftpc->rawpath);
 181  ftpc->file = NULL;
 182}
 183
 184static size_t numof_slashes(const char *str)
 185{
 186  const char *slashPos;
 187  size_t num = 0;
 188  do {
 189    slashPos = strchr(str, '/');
 190    if(slashPos) {
 191      ++num;
 192      str = slashPos + 1;
 193    }
 194  } while(slashPos);
 195  return num;
 196}
 197
 198#define FTP_MAX_DIR_DEPTH 1000
 199
 200/***********************************************************************
 201 *
 202 * ftp_parse_url_path()
 203 *
 204 * Parse the URL path into separate path components.
 205 *
 206 */
 207static CURLcode ftp_parse_url_path(struct Curl_easy *data,
 208                                   struct ftp_conn *ftpc,
 209                                   struct FTP *ftp)
 210{
 211  const char *slashPos = NULL;
 212  const char *fileName = NULL;
 213  CURLcode result = CURLE_OK;
 214  const char *rawPath = NULL; /* URL-decoded "raw" path */
 215  size_t pathLen = 0;
 216
 217  ftpc->ctl_valid = FALSE;
 218  ftpc->cwdfail = FALSE;
 219
 220  if(ftpc->rawpath)
 221    freedirs(ftpc);
 222  /* URL-decode ftp path before further evaluation */
 223  result = Curl_urldecode(ftp->path, 0, &ftpc->rawpath, &pathLen, REJECT_CTRL);
 224  if(result) {
 225    failf(data, "path contains control characters");
 226    return result;
 227  }
 228  rawPath = ftpc->rawpath;
 229
 230  switch(data->set.ftp_filemethod) {
 231  case FTPFILE_NOCWD: /* fastest, but less standard-compliant */
 232
 233    if((pathLen > 0) && (rawPath[pathLen - 1] != '/'))
 234      fileName = rawPath;  /* this is a full file path */
 235    /*
 236      else: ftpc->file is not used anywhere other than for operations on
 237            a file. In other words, never for directory operations,
 238            so we can safely leave filename as NULL here and use it as a
 239            argument in dir/file decisions.
 240    */
 241    break;
 242
 243  case FTPFILE_SINGLECWD:
 244    slashPos = strrchr(rawPath, '/');
 245    if(slashPos) {
 246      /* get path before last slash, except for / */
 247      size_t dirlen = slashPos - rawPath;
 248      if(dirlen == 0)
 249        dirlen = 1;
 250
 251      ftpc->dirs = curlx_calloc(1, sizeof(ftpc->dirs[0]));
 252      if(!ftpc->dirs)
 253        return CURLE_OUT_OF_MEMORY;
 254
 255      ftpc->dirs[0].start = 0;
 256      ftpc->dirs[0].len = (int)dirlen;
 257      ftpc->dirdepth = 1; /* we consider it to be a single directory */
 258      fileName = slashPos + 1; /* rest is filename */
 259    }
 260    else
 261      fileName = rawPath; /* filename only (or empty) */
 262    break;
 263
 264  default: /* allow pretty much anything */
 265  case FTPFILE_MULTICWD: {
 266    /* current position: begin of next path component */
 267    const char *curPos = rawPath;
 268
 269    /* number of entries to allocate for the 'dirs' array */
 270    size_t dirAlloc = numof_slashes(rawPath);
 271
 272    if(dirAlloc >= FTP_MAX_DIR_DEPTH)
 273      /* suspiciously deep directory hierarchy */
 274      return CURLE_URL_MALFORMAT;
 275
 276    if(dirAlloc) {
 277      ftpc->dirs = curlx_calloc(dirAlloc, sizeof(ftpc->dirs[0]));
 278      if(!ftpc->dirs)
 279        return CURLE_OUT_OF_MEMORY;
 280
 281      /* parse the URL path into separate path components */
 282      while(dirAlloc--) {
 283        const char *spos = strchr(curPos, '/');
 284        size_t clen = spos - curPos;
 285
 286        /* path starts with a slash: add that as a directory */
 287        if(!clen && (ftpc->dirdepth == 0))
 288          ++clen;
 289
 290        /* we skip empty path components, like "x//y" since the FTP command
 291           CWD requires a parameter and a non-existent parameter a) does not
 292           work on many servers and b) has no effect on the others. */
 293        if(clen) {
 294          ftpc->dirs[ftpc->dirdepth].start = (int)(curPos - rawPath);
 295          ftpc->dirs[ftpc->dirdepth].len = (int)clen;
 296          ftpc->dirdepth++;
 297        }
 298        curPos = spos + 1;
 299      }
 300    }
 301    fileName = curPos; /* the rest is the filename (or empty) */
 302  }
 303    break;
 304  } /* switch */
 305
 306  if(fileName && *fileName)
 307    ftpc->file = fileName;
 308  else
 309    ftpc->file = NULL; /* instead of point to a zero byte,
 310                          we make it a NULL pointer */
 311
 312  if(data->state.upload && !ftpc->file && (ftp->transfer == PPTRANSFER_BODY)) {
 313    /* We need a filename when uploading. Return error! */
 314    failf(data, "Uploading to a URL without a filename");
 315    return CURLE_URL_MALFORMAT;
 316  }
 317
 318  ftpc->cwddone = FALSE; /* default to not done */
 319
 320  if((data->set.ftp_filemethod == FTPFILE_NOCWD) && (rawPath[0] == '/'))
 321    ftpc->cwddone = TRUE; /* skip CWD for absolute paths */
 322  else { /* newly created FTP connections are already in entry path */
 323    const char *oldPath = data->conn->bits.reuse ? ftpc->prevpath : "";
 324    if(oldPath) {
 325      size_t n = pathLen;
 326      if(data->set.ftp_filemethod == FTPFILE_NOCWD)
 327        n = 0; /* CWD to entry for relative paths */
 328      else
 329        n -= ftpc->file ? strlen(ftpc->file) : 0;
 330
 331      if((strlen(oldPath) == n) && rawPath && !strncmp(rawPath, oldPath, n)) {
 332        infof(data, "Request has same path as previous transfer");
 333        ftpc->cwddone = TRUE;
 334      }
 335    }
 336  }
 337
 338  return CURLE_OK;
 339}
 340
 341/***********************************************************************
 342 *
 343 * ftp_need_type()
 344 *
 345 * Returns TRUE if we in the current situation should send TYPE
 346 */
 347static int ftp_need_type(struct ftp_conn *ftpc,
 348                         bool ascii_wanted)
 349{
 350  return ftpc->transfertype != (ascii_wanted ? 'A' : 'I');
 351}
 352
 353static void close_secondarysocket(struct Curl_easy *data,
 354                                  struct ftp_conn *ftpc)
 355{
 356  (void)ftpc;
 357  CURL_TRC_FTP(data, "[%s] closing DATA connection", FTP_CSTATE(ftpc));
 358  Curl_conn_close(data, SECONDARYSOCKET);
 359  Curl_conn_cf_discard_all(data, data->conn, SECONDARYSOCKET);
 360}
 361
 362#ifdef CURL_PREFER_LF_LINEENDS
 363/*
 364 * Lineend Conversions
 365 * On ASCII transfers, e.g. directory listings, we might get lines
 366 * ending in '\r\n' and we prefer '\n'.
 367 * We might also get a lonely '\r' which we convert into a '\n'.
 368 */
 369struct ftp_cw_lc_ctx {
 370  struct Curl_cwriter super;
 371  bool newline_pending;
 372};
 373
 374static CURLcode ftp_cw_lc_write(struct Curl_easy *data,
 375                                struct Curl_cwriter *writer, int type,
 376                                const char *buf, size_t blen)
 377{
 378  static const char nl = '\n';
 379  struct ftp_cw_lc_ctx *ctx = writer->ctx;
 380  struct ftp_conn *ftpc = Curl_conn_meta_get(data->conn, CURL_META_FTP_CONN);
 381
 382  if(!ftpc)
 383    return CURLE_FAILED_INIT;
 384
 385  if(!(type & CLIENTWRITE_BODY) || ftpc->transfertype != 'A')
 386    return Curl_cwriter_write(data, writer->next, type, buf, blen);
 387
 388  /* ASCII mode BODY data, convert lineends */
 389  while(blen) {
 390    /* do not pass EOS when writing parts */
 391    int chunk_type = (type & ~CLIENTWRITE_EOS);
 392    const char *cp;
 393    size_t chunk_len;
 394    CURLcode result;
 395
 396    if(ctx->newline_pending) {
 397      if(buf[0] != '\n') {
 398        /* previous chunk ended in '\r' and we do not see a '\n' in this one,
 399         * need to write a newline. */
 400        result = Curl_cwriter_write(data, writer->next, chunk_type, &nl, 1);
 401        if(result)
 402          return result;
 403      }
 404      /* either we wrote the newline or it is part of the next chunk of bytes
 405       * we write. */
 406      ctx->newline_pending = FALSE;
 407    }
 408
 409    cp = memchr(buf, '\r', blen);
 410    if(!cp)
 411      break;
 412
 413    /* write the bytes before the '\r', excluding the '\r' */
 414    chunk_len = cp - buf;
 415    if(chunk_len) {
 416      result = Curl_cwriter_write(data, writer->next, chunk_type,
 417                                  buf, chunk_len);
 418      if(result)
 419        return result;
 420    }
 421    /* skip the '\r', we now have a newline pending */
 422    buf = cp + 1;
 423    blen = blen - chunk_len - 1;
 424    ctx->newline_pending = TRUE;
 425  }
 426
 427  /* Any remaining data does not contain a '\r' */
 428  if(blen) {
 429    DEBUGASSERT(!ctx->newline_pending);
 430    return Curl_cwriter_write(data, writer->next, type, buf, blen);
 431  }
 432  else if(type & CLIENTWRITE_EOS) {
 433    /* EndOfStream, if we have a trailing cr, now is the time to write it */
 434    if(ctx->newline_pending) {
 435      ctx->newline_pending = FALSE;
 436      return Curl_cwriter_write(data, writer->next, type, &nl, 1);
 437    }
 438    /* Always pass on the EOS type indicator */
 439    return Curl_cwriter_write(data, writer->next, type, buf, 0);
 440  }
 441  return CURLE_OK;
 442}
 443
 444static const struct Curl_cwtype ftp_cw_lc = {
 445  "ftp-lineconv",
 446  NULL,
 447  Curl_cwriter_def_init,
 448  ftp_cw_lc_write,
 449  Curl_cwriter_def_close,
 450  sizeof(struct ftp_cw_lc_ctx)
 451};
 452
 453#endif /* CURL_PREFER_LF_LINEENDS */
 454
 455/***********************************************************************
 456 *
 457 * ftp_check_ctrl_on_data_wait()
 458 *
 459 */
 460static CURLcode ftp_check_ctrl_on_data_wait(struct Curl_easy *data,
 461                                            struct ftp_conn *ftpc)
 462{
 463  struct connectdata *conn = data->conn;
 464  curl_socket_t ctrl_sock = conn->sock[FIRSTSOCKET];
 465  struct pingpong *pp = &ftpc->pp;
 466  size_t nread;
 467  int ftpcode;
 468  bool response = FALSE;
 469
 470  /* First check whether there is a cached response from server */
 471  if(curlx_dyn_len(&pp->recvbuf)) {
 472    const char *l = curlx_dyn_ptr(&pp->recvbuf);
 473    if(!ISDIGIT(*l) || (*l > '3')) {
 474      /* Data connection could not be established, let's return */
 475      infof(data, "There is negative response in cache while serv connect");
 476      (void)getftpresponse(data, &nread, &ftpcode);
 477      return CURLE_FTP_ACCEPT_FAILED;
 478    }
 479  }
 480
 481  if(pp->overflow)
 482    /* there is pending control data still in the buffer to read */
 483    response = TRUE;
 484  else {
 485    int socketstate = SOCKET_READABLE(ctrl_sock, 0);
 486    /* see if the connection request is already here */
 487    switch(socketstate) {
 488    case -1: /* error */
 489      /* let's die here */
 490      failf(data, "Error while waiting for server connect");
 491      return CURLE_FTP_ACCEPT_FAILED;
 492    default:
 493      if(socketstate & CURL_CSELECT_IN)
 494        response = TRUE;
 495      break;
 496    }
 497  }
 498
 499  if(response) {
 500    infof(data, "Ctrl conn has data while waiting for data conn");
 501    if(pp->overflow > 3) {
 502      const char *r = curlx_dyn_ptr(&pp->recvbuf);
 503      size_t len = curlx_dyn_len(&pp->recvbuf);
 504
 505      DEBUGASSERT((pp->overflow + pp->nfinal) <= curlx_dyn_len(&pp->recvbuf));
 506      /* move over the most recently handled response line */
 507      r += pp->nfinal;
 508      len -= pp->nfinal;
 509
 510      if((len > 3) && LASTLINE(r)) {
 511        curl_off_t status;
 512        if(!curlx_str_number(&r, &status, 999) && (status == 226)) {
 513          /* funny timing situation where we get the final message on the
 514             control connection before traffic on the data connection has been
 515             noticed. Leave the 226 in there and use this as a trigger to read
 516             the data socket. */
 517          infof(data, "Got 226 before data activity");
 518          return CURLE_OK;
 519        }
 520      }
 521    }
 522
 523    (void)getftpresponse(data, &nread, &ftpcode);
 524
 525    infof(data, "FTP code: %03d", ftpcode);
 526
 527    if(ftpcode / 100 > 3)
 528      return CURLE_FTP_ACCEPT_FAILED;
 529
 530    return CURLE_WEIRD_SERVER_REPLY;
 531  }
 532
 533  return CURLE_OK;
 534}
 535
 536/***********************************************************************
 537 *
 538 * ftp_initiate_transfer()
 539 *
 540 * After connection from server is accepted this function is called to
 541 * setup transfer parameters and initiate the data transfer.
 542 *
 543 */
 544static CURLcode ftp_initiate_transfer(struct Curl_easy *data,
 545                                      struct ftp_conn *ftpc)
 546{
 547  CURLcode result = CURLE_OK;
 548  bool connected;
 549
 550  CURL_TRC_FTP(data, "ftp_initiate_transfer()");
 551  result = Curl_conn_connect(data, SECONDARYSOCKET, TRUE, &connected);
 552  if(result || !connected)
 553    return result;
 554
 555  if(data->state.upload) {
 556    /* When we know we are uploading a specified file, we can get the file
 557       size prior to the actual upload. */
 558    Curl_pgrsSetUploadSize(data, data->state.infilesize);
 559
 560    /* FTP upload, shutdown DATA, ignore shutdown errors, as we rely
 561     * on the server response on the CONTROL connection. */
 562    Curl_xfer_setup_send(data, SECONDARYSOCKET);
 563    Curl_xfer_set_shutdown(data, TRUE, TRUE);
 564  }
 565  else {
 566    /* FTP download, shutdown, do not ignore errors */
 567    Curl_xfer_setup_recv(data, SECONDARYSOCKET, data->req.size);
 568    Curl_xfer_set_shutdown(data, TRUE, FALSE);
 569  }
 570
 571  ftpc->pp.pending_resp = TRUE; /* expect server response */
 572  ftp_state(data, ftpc, FTP_STOP);
 573
 574  return CURLE_OK;
 575}
 576
 577static bool ftp_endofresp(struct Curl_easy *data, struct connectdata *conn,
 578                          const char *line, size_t len, int *code)
 579{
 580  curl_off_t status;
 581  (void)data;
 582  (void)conn;
 583
 584  if((len > 3) && LASTLINE(line) && !curlx_str_number(&line, &status, 999)) {
 585    *code = (int)status;
 586    return TRUE;
 587  }
 588
 589  return FALSE;
 590}
 591
 592static CURLcode ftp_readresp(struct Curl_easy *data,
 593                             struct ftp_conn *ftpc,
 594                             int sockindex,
 595                             struct pingpong *pp,
 596                             int *ftpcodep, /* return the ftp-code if done */
 597                             size_t *size) /* size of the response */
 598{
 599  int code;
 600  CURLcode result = Curl_pp_readresp(data, sockindex, pp, &code, size);
 601  DEBUGASSERT(ftpcodep);
 602
 603  /* store the latest code for later retrieval, except during shutdown */
 604  if(!ftpc->shutdown)
 605    data->info.httpcode = code;
 606
 607  *ftpcodep = code;
 608
 609  if(code == 421) {
 610    /* 421 means "Service not available, closing control connection." and FTP
 611     * servers use it to signal that idle session timeout has been exceeded.
 612     * If we ignored the response, it could end up hanging in some cases.
 613     *
 614     * This response code can come at any point so having it treated
 615     * generically is a good idea.
 616     */
 617    infof(data, "We got a 421 - timeout");
 618    ftp_state(data, ftpc, FTP_STOP);
 619    return CURLE_OPERATION_TIMEDOUT;
 620  }
 621
 622  return result;
 623}
 624
 625/* --- parse FTP server responses --- */
 626
 627/*
 628 * getftpresponse() is a BLOCKING function to read the full response from a
 629 * server after a command.
 630 *
 631 */
 632static CURLcode getftpresponse(struct Curl_easy *data,
 633                               size_t *nreadp, /* return number of bytes
 634                                                  read */
 635                               int *ftpcodep) /* return the ftp-code */
 636{
 637  /*
 638   * We cannot read one byte per read() and then go back to select() as the
 639   * OpenSSL read() does not grok that properly.
 640   *
 641   * Alas, read as much as possible, split up into lines, use the ending
 642   * line in a response or continue reading. */
 643
 644  struct connectdata *conn = data->conn;
 645  curl_socket_t sockfd = conn->sock[FIRSTSOCKET];
 646  CURLcode result = CURLE_OK;
 647  struct ftp_conn *ftpc = Curl_conn_meta_get(data->conn, CURL_META_FTP_CONN);
 648  struct pingpong *pp = &ftpc->pp;
 649  size_t nread;
 650  int cache_skip = 0;
 651  DEBUGASSERT(ftpcodep);
 652
 653  CURL_TRC_FTP(data, "getftpresponse start");
 654  *nreadp = 0;
 655  *ftpcodep = 0; /* 0 for errors */
 656
 657  if(!ftpc)
 658    return CURLE_FAILED_INIT;
 659
 660  while(!*ftpcodep && !result) {
 661    /* check and reset timeout value every lap */
 662    timediff_t timeout = Curl_pp_state_timeleft_ms(data, pp);
 663    timediff_t interval_ms;
 664
 665    if(timeout <= 0) {
 666      failf(data, "FTP response timeout");
 667      return CURLE_OPERATION_TIMEDOUT; /* already too little time */
 668    }
 669
 670    interval_ms = 1000;  /* use 1 second timeout intervals */
 671    if(timeout < interval_ms)
 672      interval_ms = timeout;
 673
 674    /*
 675     * Since this function is blocking, we need to wait here for input on the
 676     * connection and only then we call the response reading function. We do
 677     * timeout at least every second to make the timeout check run.
 678     *
 679     * A caution here is that the ftp_readresp() function has a cache that may
 680     * contain pieces of a response from the previous invoke and we need to
 681     * make sure we do not wait for input while there is unhandled data in
 682     * that cache. Also, if the cache is there, we call ftp_readresp() and
 683     * the cache was not good enough to continue we must not busy-loop around
 684     * this function.
 685     *
 686     */
 687
 688    if(curlx_dyn_len(&pp->recvbuf) && (cache_skip < 2)) {
 689      /*
 690       * There is a cache left since before. We then skipping the wait for
 691       * socket action, unless this is the same cache like the previous round
 692       * as then the cache was deemed not enough to act on and we then need to
 693       * wait for more data anyway.
 694       */
 695    }
 696    else if(!Curl_conn_data_pending(data, FIRSTSOCKET)) {
 697      curl_socket_t wsock = Curl_pp_needs_flush(data, pp) ?
 698        sockfd : CURL_SOCKET_BAD;
 699      int ev = Curl_socket_check(sockfd, CURL_SOCKET_BAD, wsock, interval_ms);
 700      if(ev < 0) {
 701        failf(data, "FTP response aborted due to select/poll error: %d",
 702              SOCKERRNO);
 703        return CURLE_RECV_ERROR;
 704      }
 705      else if(ev == 0) {
 706        result = Curl_pgrsUpdate(data);
 707        continue; /* continue in our loop for the timeout duration */
 708      }
 709    }
 710
 711    if(Curl_pp_needs_flush(data, pp)) {
 712      result = Curl_pp_flushsend(data, pp);
 713      if(result)
 714        break;
 715    }
 716
 717    result = ftp_readresp(data, ftpc, FIRSTSOCKET, pp, ftpcodep, &nread);
 718    if(result)
 719      break;
 720
 721    if(!nread && curlx_dyn_len(&pp->recvbuf))
 722      /* bump cache skip counter as on repeated skips we must wait for more
 723         data */
 724      cache_skip++;
 725    else
 726      /* when we got data or there is no cache left, we reset the cache skip
 727         counter */
 728      cache_skip = 0;
 729
 730    *nreadp += nread;
 731
 732  } /* while there is buffer left and loop is requested */
 733
 734  pp->pending_resp = FALSE;
 735  CURL_TRC_FTP(data, "getftpresponse -> result=%d, nread=%zu, ftpcode=%d",
 736               result, *nreadp, *ftpcodep);
 737
 738  return result;
 739}
 740
 741static CURLcode ftp_state_user(struct Curl_easy *data,
 742                               struct ftp_conn *ftpc,
 743                               struct connectdata *conn)
 744{
 745  CURLcode result = Curl_pp_sendf(data, &ftpc->pp, "USER %s",
 746                                  Curl_creds_user(conn->creds));
 747  if(!result) {
 748    ftpc->ftp_trying_alternative = FALSE;
 749    ftp_state(data, ftpc, FTP_USER);
 750  }
 751  return result;
 752}
 753
 754static CURLcode ftp_state_pwd(struct Curl_easy *data,
 755                              struct ftp_conn *ftpc)
 756{
 757  CURLcode result;
 758#ifdef DEBUGBUILD
 759  if(!data->id && getenv("CURL_FTP_PWD_STOP"))
 760    return CURLE_OK;
 761#endif
 762  result = Curl_pp_sendf(data, &ftpc->pp, "%s", "PWD");
 763  if(!result)
 764    ftp_state(data, ftpc, FTP_PWD);
 765
 766  return result;
 767}
 768
 769/* For the FTP "protocol connect" and "doing" phases only */
 770static CURLcode ftp_pollset(struct Curl_easy *data,
 771                            struct easy_pollset *ps)
 772{
 773  struct ftp_conn *ftpc = Curl_conn_meta_get(data->conn, CURL_META_FTP_CONN);
 774  return ftpc ? Curl_pp_pollset(data, &ftpc->pp, ps) : CURLE_OK;
 775}
 776
 777/* For the FTP "DO_MORE" phase only */
 778static CURLcode ftp_domore_pollset(struct Curl_easy *data,
 779                                   struct easy_pollset *ps)
 780{
 781  struct ftp_conn *ftpc = Curl_conn_meta_get(data->conn, CURL_META_FTP_CONN);
 782
 783  if(!ftpc)
 784    return CURLE_OK;
 785
 786  /* When in DO_MORE state, we could be either waiting for us to connect to a
 787   * remote site, or we could wait for that site to connect to us. Or handle
 788   * ordinary commands.
 789   */
 790  CURL_TRC_FTP(data, "[%s] ftp_domore_pollset()", FTP_CSTATE(ftpc));
 791
 792  if(FTP_STOP == ftpc->state) {
 793    /* if stopped and still in this state, then we are also waiting for a
 794       connect on the secondary connection */
 795    DEBUGASSERT(data->conn->sock[SECONDARYSOCKET] != CURL_SOCKET_BAD ||
 796                (data->conn->cfilter[SECONDARYSOCKET] &&
 797                 !Curl_conn_is_connected(data->conn, SECONDARYSOCKET)));
 798    /* An unconnected SECONDARY will add its socket by itself
 799     * via its adjust_pollset() */
 800    return Curl_pollset_add_in(data, ps, data->conn->sock[FIRSTSOCKET]);
 801  }
 802  return Curl_pp_pollset(data, &ftpc->pp, ps);
 803}
 804
 805static int pathlen(struct ftp_conn *ftpc, int num)
 806{
 807  DEBUGASSERT(ftpc->dirs);
 808  DEBUGASSERT(ftpc->dirdepth > num);
 809  return ftpc->dirs[num].len;
 810}
 811
 812static const char *pathpiece(struct ftp_conn *ftpc, int num)
 813{
 814  DEBUGASSERT(ftpc->dirs);
 815  DEBUGASSERT(ftpc->dirdepth > num);
 816  return &ftpc->rawpath[ftpc->dirs[num].start];
 817}
 818
 819/* This is called after the FTP_QUOTE state is passed.
 820
 821   ftp_state_cwd() sends the range of CWD commands to the server to change to
 822   the correct directory. It may also need to send MKD commands to create
 823   missing ones, if that option is enabled.
 824*/
 825static CURLcode ftp_state_cwd(struct Curl_easy *data,
 826                              struct ftp_conn *ftpc,
 827                              struct FTP *ftp)
 828{
 829  CURLcode result = CURLE_OK;
 830
 831  if(ftpc->cwddone)
 832    /* already done and fine */
 833    result = ftp_state_mdtm(data, ftpc, ftp);
 834  else {
 835    /* FTPFILE_NOCWD with full path: expect ftpc->cwddone! */
 836    DEBUGASSERT((data->set.ftp_filemethod != FTPFILE_NOCWD) ||
 837                !(ftpc->dirdepth && ftpc->rawpath[0] == '/'));
 838
 839    ftpc->count2 = 0; /* count2 counts failed CWDs */
 840
 841    if(data->conn->bits.reuse && ftpc->entrypath &&
 842       /* no need to go to entrypath when we have an absolute path */
 843       !(ftpc->dirdepth && ftpc->rawpath[0] == '/')) {
 844      /* This is a reused connection. Since we change directory to where the
 845         transfer is taking place, we must first get back to the original dir
 846         where we ended up after login: */
 847      ftpc->cwdcount = 0; /* we count this as the first path, then we add one
 848                             for all upcoming ones in the ftp->dirs[] array */
 849      result = Curl_pp_sendf(data, &ftpc->pp, "CWD %s", ftpc->entrypath);
 850      if(!result)
 851        ftp_state(data, ftpc, FTP_CWD);
 852    }
 853    else {
 854      if(ftpc->dirdepth) {
 855        ftpc->cwdcount = 1;
 856        /* issue the first CWD, the rest is sent when the CWD responses are
 857           received... */
 858        result = Curl_pp_sendf(data, &ftpc->pp, "CWD %.*s",
 859                               pathlen(ftpc, 0), pathpiece(ftpc, 0));
 860        if(!result)
 861          ftp_state(data, ftpc, FTP_CWD);
 862      }
 863      else {
 864        /* No CWD necessary */
 865        result = ftp_state_mdtm(data, ftpc, ftp);
 866      }
 867    }
 868  }
 869  return result;
 870}
 871
 872typedef enum {
 873  EPRT,
 874  PORT,
 875  DONE
 876} ftpport;
 877
 878/*
 879 * Parse the CURLOPT_FTPPORT string
 880 * "(ipv4|ipv6|domain|interface)?(:port(-range)?)?"
 881 * and extract addr/addrlen and port_min/port_max.
 882 */
 883static CURLcode ftp_port_parse_string(struct Curl_easy *data,
 884                                      struct connectdata *conn,
 885                                      const char *string_ftpport,
 886                                      struct Curl_sockaddr_storage *ss,
 887                                      unsigned short *port_minp,
 888                                      unsigned short *port_maxp,
 889                                      const char **hostp,
 890                                      char *hbuf, size_t hbuflen)
 891{
 892  const char *ip_end = NULL;
 893  const char *addr = NULL;
 894  size_t addrlen = 0;
 895  unsigned short port_min = 0;
 896  unsigned short port_max = 0;
 897  char ipstr[50];
 898#ifndef USE_IPV6
 899  (void)conn;
 900  (void)ss;
 901#endif
 902
 903  /* default to nothing */
 904  *hostp = NULL;
 905  *port_minp = *port_maxp = 0;
 906
 907  if(!string_ftpport || (strlen(string_ftpport) <= 1))
 908    goto done;
 909
 910#ifdef USE_IPV6
 911  if(*string_ftpport == '[') {
 912    /* [ipv6]:port(-range) */
 913    const char *ip_start = string_ftpport + 1;
 914    ip_end = strchr(ip_start, ']');
 915    if(ip_end) {
 916      addrlen = ip_end - ip_start;
 917      addr = ip_start;
 918    }
 919  }
 920  else
 921#endif
 922    if(*string_ftpport == ':') {
 923      /* :port */
 924      ip_end = string_ftpport;
 925    }
 926    else {
 927      ip_end = strchr(string_ftpport, ':');
 928      addr = string_ftpport;
 929      if(ip_end) {
 930#ifdef USE_IPV6
 931        struct sockaddr_in6 * const sa6 = (void *)ss;
 932#endif
 933        /* either ipv6 or (ipv4|domain|interface):port(-range) */
 934        addrlen = ip_end - string_ftpport;
 935#ifdef USE_IPV6
 936        if(curlx_inet_pton(AF_INET6, string_ftpport, &sa6->sin6_addr) == 1) {
 937          /* ipv6 */
 938          addrlen = strlen(string_ftpport);
 939          ip_end = NULL; /* this got no port ! */
 940        }
 941#endif
 942      }
 943      else
 944        /* ipv4|interface */
 945        addrlen = strlen(string_ftpport);
 946    }
 947
 948  /* parse the port */
 949  if(ip_end) {
 950    const char *portp = strchr(ip_end, ':');
 951    if(portp) {
 952      curl_off_t start;
 953      curl_off_t end;
 954      portp++;
 955      if(!curlx_str_number(&portp, &start, 0xffff)) {
 956        port_min = (unsigned short)start;
 957        if(!curlx_str_single(&portp, '-') &&
 958           !curlx_str_number(&portp, &end, 0xffff))
 959          port_max = (unsigned short)end;
 960        else
 961          port_max = port_min;
 962      }
 963    }
 964  }
 965
 966  /* correct errors like :1234-1230 or :-4711 */
 967  if(port_min > port_max)
 968    port_min = port_max = 0;
 969
 970  if(addrlen) {
 971    const struct Curl_sockaddr_ex *remote_addr =
 972      Curl_conn_get_remote_addr(data, FIRSTSOCKET);
 973
 974    DEBUGASSERT(remote_addr);
 975    DEBUGASSERT(addr);
 976    if(!remote_addr || (addrlen >= sizeof(ipstr)) || (addrlen >= hbuflen))
 977      return CURLE_FTP_PORT_FAILED;
 978    memcpy(ipstr, addr, addrlen);
 979    ipstr[addrlen] = 0;
 980
 981    /* attempt to get the address of the given interface name */
 982    switch(Curl_if2ip(remote_addr->family,
 983#ifdef USE_IPV6
 984                      Curl_ipv6_scope(&remote_addr->curl_sa_addr),
 985                      conn->scope_id,
 986#endif
 987                      ipstr, hbuf, hbuflen)) {
 988    case IF2IP_NOT_FOUND:
 989      /* not an interface, use the string as hostname instead */
 990      memcpy(hbuf, addr, addrlen);
 991      hbuf[addrlen] = 0;
 992      *hostp = hbuf;
 993      break;
 994    case IF2IP_AF_NOT_SUPPORTED:
 995      return CURLE_FTP_PORT_FAILED;
 996    case IF2IP_FOUND:
 997      *hostp = hbuf; /* use the hbuf for hostname */
 998      break;
 999    }
1000  }
1001  /* else: only a port(-range) given, leave host as NULL */
1002
1003done:
1004  *port_minp = port_min;
1005  *port_maxp = port_max;
1006  return CURLE_OK;
1007}
1008
1009/*
1010 * If no host was derived from the FTPPORT string, fall back to the IP address
1011 * of the control connection's local socket.
1012 */
1013static CURLcode ftp_port_default_host(struct Curl_easy *data,
1014                                      struct connectdata *conn,
1015                                      struct Curl_sockaddr_storage *ss,
1016                                      curl_socklen_t *sslenp,
1017                                      const char **hostp,
1018                                      char *hbuf, size_t hbuflen,
1019                                      bool *non_localp)
1020{
1021  struct sockaddr *sa = (struct sockaddr *)ss;
1022  struct sockaddr_in * const sa4 = (void *)sa;
1023#ifdef USE_IPV6
1024  struct sockaddr_in6 * const sa6 = (void *)sa;
1025#endif
1026  char buffer[STRERROR_LEN];
1027  const char *r;
1028
1029  *sslenp = sizeof(*ss);
1030  if(getsockname(conn->sock[FIRSTSOCKET], sa, sslenp)) {
1031    failf(data, "getsockname() failed: %s",
1032          curlx_strerror(SOCKERRNO, buffer, sizeof(buffer)));
1033    return CURLE_FTP_PORT_FAILED;
1034  }
1035  switch(sa->sa_family) {
1036#ifdef USE_IPV6
1037  case AF_INET6:
1038    r = curlx_inet_ntop(sa->sa_family, &sa6->sin6_addr, hbuf, hbuflen);
1039    break;
1040#endif
1041  default:
1042    r = curlx_inet_ntop(sa->sa_family, &sa4->sin_addr, hbuf, hbuflen);
1043    break;
1044  }
1045  if(!r)
1046    return CURLE_FTP_PORT_FAILED;
1047
1048  *hostp = hbuf;
1049  *non_localp = FALSE; /* we know it is local now */
1050  return CURLE_OK;
1051}
1052
1053/*
1054 * Resolve the host string to a list of addresses.
1055 */
1056static CURLcode ftp_port_resolve_host(struct Curl_easy *data,
1057                                      struct connectdata *conn,
1058                                      const char *host,
1059                                      struct Curl_dns_entry **dns_entryp,
1060                                      const struct Curl_addrinfo **resp)
1061{
1062  CURLcode result;
1063
1064  *resp = NULL;
1065  result = Curl_resolv_blocking(
1066    data, Curl_resolv_dns_queries(data, conn->ip_version),
1067    host, 0, Curl_conn_get_transport(data, conn), dns_entryp);
1068  if(result)
1069    failf(data, "failed to resolve the address provided to PORT: %s", host);
1070  else {
1071    DEBUGASSERT(*dns_entryp);
1072    *resp = (*dns_entryp)->addr;
1073  }
1074  return result;
1075}
1076
1077/*
1078 * Open a TCP socket for the resolved address family.
1079 */
1080static CURLcode ftp_port_open_socket(struct Curl_easy *data,
1081                                     struct connectdata *conn,
1082                                     const struct Curl_addrinfo *res,
1083                                     const struct Curl_addrinfo **aip,
1084                                     curl_socket_t *portsockp)
1085{
1086  char buffer[STRERROR_LEN];
1087  int error = 0;
1088  const struct Curl_addrinfo *ai;
1089  CURLcode result = CURLE_FTP_PORT_FAILED;
1090
1091  for(ai = res; ai; ai = ai->ai_next) {
1092    result =
1093      Curl_socket_open(data, ai, NULL,
1094                       Curl_conn_get_transport(data, conn), portsockp);
1095    if(result) {
1096      if(result == CURLE_OUT_OF_MEMORY)
1097        return result;
1098      result = CURLE_FTP_PORT_FAILED;
1099      error = SOCKERRNO;
1100      continue;
1101    }
1102    break;
1103  }
1104  if(!ai) {
1105    failf(data, "socket failure: %s",
1106          curlx_strerror(error, buffer, sizeof(buffer)));
1107    return CURLE_FTP_PORT_FAILED;
1108  }
1109  *aip = ai;
1110  return result;
1111}
1112
1113/*
1114 * Bind the socket to a local address and port within the requested range.
1115 * Falls back to the control-connection address if the user-requested address
1116 * is non-local.
1117 */
1118static CURLcode ftp_port_bind_socket(struct Curl_easy *data,
1119                                     struct connectdata *conn,
1120                                     curl_socket_t portsock,
1121                                     const struct Curl_addrinfo *ai,
1122                                     struct Curl_sockaddr_storage *ss,
1123                                     curl_socklen_t *sslen_io,
1124                                     unsigned short port_min,
1125                                     unsigned short port_max,
1126                                     bool non_local)
1127{
1128  struct sockaddr *sa = (struct sockaddr *)ss;
1129  struct sockaddr_in * const sa4 = (void *)sa;
1130#ifdef USE_IPV6
1131  struct sockaddr_in6 * const sa6 = (void *)sa;
1132#endif
1133  char buffer[STRERROR_LEN];
1134  unsigned short port;
1135  int error;
1136
1137  memcpy(sa, ai->ai_addr, ai->ai_addrlen);
1138  *sslen_io = ai->ai_addrlen;
1139
1140  for(port = port_min; port <= port_max;) {
1141    if(sa->sa_family == AF_INET)
1142      sa4->sin_port = htons(port);
1143#ifdef USE_IPV6
1144    else
1145      sa6->sin6_port = htons(port);
1146#endif
1147    if(bind(portsock, sa, *sslen_io)) {
1148      error = SOCKERRNO;
1149      if(non_local && (error == SOCKEADDRNOTAVAIL)) {
1150        /* The requested bind address is not local. Use the address used for
1151         * the control connection instead and restart the port loop.
1152         */
1153        infof(data, "bind(port=%hu) on non-local address failed: %s", port,
1154              curlx_strerror(error, buffer, sizeof(buffer)));
1155
1156        *sslen_io = sizeof(*ss);
1157        if(getsockname(conn->sock[FIRSTSOCKET], sa, sslen_io)) {
1158          failf(data, "getsockname() failed: %s",
1159                curlx_strerror(SOCKERRNO, buffer, sizeof(buffer)));
1160          return CURLE_FTP_PORT_FAILED;
1161        }
1162        port = port_min;
1163        non_local = FALSE; /* do not try this again */
1164        continue;
1165      }
1166      if(error != SOCKEADDRINUSE && error != SOCKEACCES) {
1167        failf(data, "bind(port=%hu) failed: %s", port,
1168              curlx_strerror(error, buffer, sizeof(buffer)));
1169        return CURLE_FTP_PORT_FAILED;
1170      }
1171    }
1172    else
1173      break;
1174
1175    /* check if port is the maximum value here, because it might be 0xffff
1176       and then the increment below will wrap the 16-bit counter */
1177    if(port == port_max) {
1178      failf(data, "bind() failed, ran out of ports");
1179      return CURLE_FTP_PORT_FAILED;
1180    }
1181    port++;
1182  }
1183
1184  /* re-read the name so we can extract the actual port chosen */
1185  *sslen_io = sizeof(*ss);
1186  if(getsockname(portsock, sa, sslen_io)) {
1187    failf(data, "getsockname() failed: %s",
1188          curlx_strerror(SOCKERRNO, buffer, sizeof(buffer)));
1189    return CURLE_FTP_PORT_FAILED;
1190  }
1191  CURL_TRC_FTP(data, "ftp_port_bind_socket(), socket bound to port %d",
1192               port);
1193  return CURLE_OK;
1194}
1195
1196/*
1197 * Start listening on the data socket.
1198 */
1199static CURLcode ftp_port_listen(struct Curl_easy *data, curl_socket_t portsock)
1200{
1201  char buffer[STRERROR_LEN];
1202
1203  if(listen(portsock, 1)) {
1204    failf(data, "socket failure: %s",
1205          curlx_strerror(SOCKERRNO, buffer, sizeof(buffer)));
1206    return CURLE_FTP_PORT_FAILED;
1207  }
1208  CURL_TRC_FTP(data, "ftp_port_listen(), listening on port");
1209  return CURLE_OK;
1210}
1211
1212/*
1213 * Send the EPRT or PORT command to the server.
1214 */
1215static CURLcode ftp_port_send_command(struct Curl_easy *data,
1216                                      struct ftp_conn *ftpc,
1217                                      struct connectdata *conn,
1218                                      struct Curl_sockaddr_storage *ss,
1219                                      const struct Curl_addrinfo *ai,
1220                                      ftpport fcmd)
1221{
1222  static const char mode[][5] = { "EPRT", "PORT" };
1223  struct sockaddr *sa = (struct sockaddr *)ss;
1224  struct sockaddr_in * const sa4 = (void *)sa;
1225#ifdef USE_IPV6
1226  struct sockaddr_in6 * const sa6 = (void *)sa;
1227#endif
1228  char myhost[MAX_IPADR_LEN + 1] = "";
1229  unsigned short port;
1230  CURLcode result;
1231
1232  /* Get a plain printable version of the numerical address to work with. This
1233     logic uses the address provided by the FTPPORT option, which at times
1234     might differ from the address in 'ss' used to bind to: when a user asks
1235     the server to connect to a specific address knowing that it works, but
1236     curl instead selects to listen to the local address because it cannot use
1237     the provided address. FTP is strange. */
1238  Curl_printable_address(ai, myhost, sizeof(myhost));
1239
1240#ifdef USE_IPV6
1241  if(!conn->bits.ftp_use_eprt && conn->bits.ipv6)
1242    /* EPRT is disabled but we are connected to an IPv6 host, so we ignore the
1243       request and enable EPRT again! */
1244    conn->bits.ftp_use_eprt = TRUE;
1245#endif
1246
1247  for(; fcmd != DONE; fcmd++) {
1248
1249    if(!conn->bits.ftp_use_eprt && (EPRT == fcmd))
1250      /* if disabled, goto next */
1251      continue;
1252
1253    if((PORT == fcmd) && sa->sa_family != AF_INET)
1254      /* PORT is IPv4 only */
1255      continue;
1256
1257    switch(sa->sa_family) {
1258    case AF_INET:
1259      port = ntohs(sa4->sin_port);
1260      break;
1261#ifdef USE_IPV6
1262    case AF_INET6:
1263      port = ntohs(sa6->sin6_port);
1264      break;
1265#endif
1266    default:
1267      continue; /* might as well skip this */
1268    }
1269
1270    if(EPRT == fcmd) {
1271      /*
1272       * Two fine examples from RFC2428;
1273       *
1274       * EPRT |1|132.235.1.2|6275|
1275       *
1276       * EPRT |2|1080::8:800:200C:417A|5282|
1277       */
1278      result = Curl_pp_sendf(data, &ftpc->pp, "%s |%d|%s|%hu|", mode[fcmd],
1279                             sa->sa_family == AF_INET ? 1 : 2,
1280                             myhost, port);
1281      if(result) {
1282        failf(data, "Failure sending EPRT command: %s",
1283              curl_easy_strerror(result));
1284        return result;
1285      }
1286      break;
1287    }
1288    if(PORT == fcmd) {
1289      /* large enough for [IP address],[num],[num] */
1290      char target[sizeof(myhost) + 20];
1291      const char *source = myhost;
1292      char *dest = target;
1293
1294      /* translate x.x.x.x to x,x,x,x */
1295      while(*source) {
1296        if(*source == '.')
1297          *dest = ',';
1298        else
1299          *dest = *source;
1300        dest++;
1301        source++;
1302      }
1303      *dest = 0;
1304      curl_msnprintf(dest, 20, ",%d,%d", (int)(port >> 8), (int)(port & 0xff));
1305
1306      result = Curl_pp_sendf(data, &ftpc->pp, "%s %s", mode[fcmd], target);
1307      if(result) {
1308        failf(data, "Failure sending PORT command: %s",
1309              curl_easy_strerror(result));
1310        return result;
1311      }
1312      break;
1313    }
1314  }
1315
1316  /* store which command was sent */
1317  ftpc->count1 = fcmd;
1318  ftp_state(data, ftpc, FTP_PORT);
1319  return CURLE_OK;
1320}
1321
1322/*
1323 * ftp_state_use_port()
1324 *
1325 * Set up an active-mode FTP data connection (using PORT or EPRT) and start
1326 * listening for the server's incoming connection on SECONDARYSOCKET.
1327 */
1328static CURLcode ftp_state_use_port(struct Curl_easy *data,
1329                                   struct ftp_conn *ftpc,
1330                                   ftpport fcmd) /* start with this */
1331{
1332  CURLcode result = CURLE_FTP_PORT_FAILED;
1333  struct connectdata *conn = data->conn;
1334  curl_socket_t portsock = CURL_SOCKET_BAD;
1335
1336  struct Curl_sockaddr_storage ss;
1337  curl_socklen_t sslen;
1338  char hbuf[NI_MAXHOST];
1339  const char *host = NULL;
1340  const char *string_ftpport = data->set.str[STRING_FTPPORT];
1341  struct Curl_dns_entry *dns_entry = NULL;
1342  const struct Curl_addrinfo *res = NULL;
1343  const struct Curl_addrinfo *ai = NULL;
1344  unsigned short port_min = 0;
1345  unsigned short port_max = 0;
1346  bool non_local = TRUE;
1347
1348  /* parse the FTPPORT string for address and port range */
1349  result = ftp_port_parse_string(data, conn, string_ftpport,
1350                                 &ss, &port_min, &port_max,
1351                                 &host, hbuf, sizeof(hbuf));
1352  if(!result && !host)
1353    /* if no host was specified, use the control connection's local IP */
1354    result = ftp_port_default_host(data, conn, &ss, &sslen, &host,
1355                                   hbuf, sizeof(hbuf), &non_local);
1356
1357  /* resolve host string to address list */
1358  if(!result)
1359    result = ftp_port_resolve_host(data, conn, host, &dns_entry, &res);
1360
1361  /* Open a TCP socket for the data connection */
1362  if(!result)
1363    result = ftp_port_open_socket(data, conn, res, &ai, &portsock);
1364  if(!result) {
1365    CURL_TRC_FTP(data, "[%s] ftp_state_use_port(), opened socket",
1366                 FTP_CSTATE(ftpc));
1367
1368    /* bind to a suitable local address / port */
1369    result = ftp_port_bind_socket(data, conn, portsock, ai, &ss, &sslen,
1370                                  port_min, port_max, non_local);
1371  }
1372
1373  /* listen */
1374  if(!result)
1375    result = ftp_port_listen(data, portsock);
1376
1377  /* send the PORT / EPRT command */
1378  if(!result)
1379    result = ftp_port_send_command(data, ftpc, conn, &ss, ai, fcmd);
1380
1381  /* replace any filter on SECONDARY with one listening on this socket */
1382  if(!result)
1383    result = Curl_conn_tcp_listen_set(data, conn, SECONDARYSOCKET, &portsock);
1384
1385  if(!result)
1386    portsock = CURL_SOCKET_BAD; /* now held in filter */
1387
1388  /* cleanup */
1389
1390  if(dns_entry)
1391    Curl_dns_entry_unlink(data, &dns_entry);
1392  if(result) {
1393    ftp_state(data, ftpc, FTP_STOP);
1394  }
1395  else {
1396    /* successfully set up the listen socket filter. SSL needed? */
1397    if(conn->bits.ftp_use_data_ssl && data->set.ftp_use_port &&
1398       !Curl_conn_is_ssl(conn, SECONDARYSOCKET)) {
1399      result = Curl_ssl_cfilter_add(data, conn, SECONDARYSOCKET);
1400    }
1401    conn->bits.do_more = FALSE;
1402    Curl_pgrsTime(data, TIMER_STARTACCEPT);
1403    Curl_expire(data, (data->set.accepttimeout > 0) ?
1404                data->set.accepttimeout: DEFAULT_ACCEPT_TIMEOUT,
1405                EXPIRE_FTP_ACCEPT);
1406  }
1407  if(portsock != CURL_SOCKET_BAD)
1408    Curl_socket_close(data, conn, portsock);
1409  return result;
1410}
1411
1412static CURLcode ftp_state_use_pasv(struct Curl_easy *data,
1413                                   struct ftp_conn *ftpc,
1414                                   struct connectdata *conn)
1415{
1416  CURLcode result = CURLE_OK;
1417  /*
1418    Here's the executive summary on what to do:
1419
1420    PASV is RFC959, expect:
1421    227 Entering Passive Mode (a1,a2,a3,a4,p1,p2)
1422
1423    LPSV is RFC1639, expect:
1424    228 Entering Long Passive Mode (4,4,a1,a2,a3,a4,2,p1,p2)
1425
1426    EPSV is RFC2428, expect:
1427    229 Entering Extended Passive Mode (|||port|)
1428
1429  */
1430
1431  static const char mode[][5] = { "EPSV", "PASV" };
1432  int modeoff;
1433
1434#ifdef PF_INET6
1435  if(!conn->bits.ftp_use_epsv && conn->bits.ipv6)
1436    /* EPSV is disabled but we are connected to an IPv6 host, so we ignore the
1437       request and enable EPSV again! */
1438    conn->bits.ftp_use_epsv = TRUE;
1439#endif
1440
1441  modeoff = conn->bits.ftp_use_epsv ? 0 : 1;
1442
1443  result = Curl_pp_sendf(data, &ftpc->pp, "%s", mode[modeoff]);
1444  if(!result) {
1445    ftpc->count1 = modeoff;
1446    ftp_state(data, ftpc, FTP_PASV);
1447    infof(data, "Connect data stream passively");
1448  }
1449  return result;
1450}
1451
1452/*
1453 * ftp_state_prepare_transfer() starts PORT, PASV or PRET etc.
1454 *
1455 * REST is the last command in the chain of commands when a "head"-like
1456 * request is made. Thus, if an actual transfer is to be made this is where we
1457 * take off for real.
1458 */
1459static CURLcode ftp_state_prepare_transfer(struct Curl_easy *data,
1460                                           struct ftp_conn *ftpc,
1461                                           struct FTP *ftp)
1462{
1463  CURLcode result = CURLE_OK;
1464  struct connectdata *conn = data->conn;
1465
1466  if(ftp->transfer != PPTRANSFER_BODY) {
1467    /* does not transfer any data */
1468
1469    /* still possibly do PRE QUOTE jobs */
1470    ftp_state(data, ftpc, FTP_RETR_PREQUOTE);
1471    result = ftp_state_quote(data, ftpc, ftp, TRUE, FTP_RETR_PREQUOTE);
1472  }
1473  else if(data->set.ftp_use_port) {
1474    /* We have chosen to use the PORT (or similar) command */
1475    result = ftp_state_use_port(data, ftpc, EPRT);
1476  }
1477  else {
1478    /* We have chosen (this is default) to use the PASV (or similar) command */
1479    if(data->set.ftp_use_pret) {
1480      /* The user has requested that we send a PRET command
1481         to prepare the server for the upcoming PASV */
1482      if(!ftpc->file)
1483        result = Curl_pp_sendf(data, &ftpc->pp, "PRET %s",
1484                               data->set.str[STRING_CUSTOMREQUEST] ?
1485                               data->set.str[STRING_CUSTOMREQUEST] :
1486                               (data->state.list_only ? "NLST" : "LIST"));
1487      else if(data->state.upload)
1488        result = Curl_pp_sendf(data, &ftpc->pp, "PRET STOR %s", ftpc->file);
1489      else
1490        result = Curl_pp_sendf(data, &ftpc->pp, "PRET RETR %s", ftpc->file);
1491      if(!result)
1492        ftp_state(data, ftpc, FTP_PRET);
1493    }
1494    else
1495      result = ftp_state_use_pasv(data, ftpc, conn);
1496  }
1497  return result;
1498}
1499
1500static CURLcode ftp_state_rest(struct Curl_easy *data,
1501                               struct ftp_conn *ftpc,
1502                               struct FTP *ftp)
1503{
1504  CURLcode result = CURLE_OK;
1505
1506  if((ftp->transfer != PPTRANSFER_BODY) && ftpc->file) {
1507    /* if a "head"-like request is being made (on a file) */
1508
1509    /* Determine if server can respond to REST command and therefore
1510       whether it supports range */
1511    result = Curl_pp_sendf(data, &ftpc->pp, "REST %d", 0);
1512    if(!result)
1513      ftp_state(data, ftpc, FTP_REST);
1514  }
1515  else
1516    result = ftp_state_prepare_transfer(data, ftpc, ftp);
1517
1518  return result;
1519}
1520
1521static CURLcode ftp_state_size(struct Curl_easy *data,
1522                               struct ftp_conn *ftpc,
1523                               struct FTP *ftp)
1524{
1525  CURLcode result = CURLE_OK;
1526
1527  if((ftp->transfer == PPTRANSFER_INFO) && ftpc->file) {
1528    /* if a "head"-like request is being made (on a file) */
1529
1530    /* we know ftpc->file is a valid pointer to a filename */
1531    result = Curl_pp_sendf(data, &ftpc->pp, "SIZE %s", ftpc->file);
1532    if(!result)
1533      ftp_state(data, ftpc, FTP_SIZE);
1534  }
1535  else
1536    result = ftp_state_rest(data, ftpc, ftp);
1537
1538  return result;
1539}
1540
1541static CURLcode ftp_state_list(struct Curl_easy *data,
1542                               struct ftp_conn *ftpc,
1543                               struct FTP *ftp)
1544{
1545  CURLcode result = CURLE_OK;
1546
1547  /* If this output is to be machine-parsed, the NLST command might be better
1548     to use, since the LIST command output is not specified or standard in any
1549     way. It has turned out that the NLST list output is not the same on all
1550     servers either... */
1551
1552  /*
1553     if FTPFILE_NOCWD was specified, we should add the path
1554     as argument for the LIST / NLST / or custom command.
1555     Whether the server will support this, is uncertain.
1556
1557     The other ftp_filemethods will CWD into dir/dir/ first and
1558     then do LIST (in that case: nothing to do here)
1559  */
1560  const char *lstArg = NULL;
1561  int lstArglen = 0;
1562  char *cmd;
1563
1564  if((data->set.ftp_filemethod == FTPFILE_NOCWD) && ftp->path) {
1565    /* URL-decode before evaluation: e.g. paths starting/ending with %2f */
1566    const char *rawPath = ftpc->rawpath;
1567    const char *slashPos = strrchr(rawPath, '/');
1568    if(slashPos) {
1569      /* chop off the file part if format is dir/file otherwise remove
1570         the trailing slash for dir/dir/ except for absolute path / */
1571      size_t n = slashPos - rawPath;
1572      if(n == 0)
1573        ++n;
1574
1575      lstArg = rawPath;
1576      lstArglen = (int)n;
1577    }
1578  }
1579
1580  cmd = curl_maprintf("%s%s%.*s",
1581                      data->set.str[STRING_CUSTOMREQUEST] ?
1582                      data->set.str[STRING_CUSTOMREQUEST] :
1583                      (data->state.list_only ? "NLST" : "LIST"),
1584                      lstArg ? " " : "",
1585                      lstArglen, lstArg ? lstArg : "");
1586
1587  if(!cmd)
1588    return CURLE_OUT_OF_MEMORY;
1589
1590  result = Curl_pp_sendf(data, &ftpc->pp, "%s", cmd);
1591  curlx_free(cmd);
1592
1593  if(!result)
1594    ftp_state(data, ftpc, FTP_LIST);
1595
1596  return result;
1597}
1598
1599static CURLcode ftp_state_list_prequote(struct Curl_easy *data,
1600                                        struct ftp_conn *ftpc,
1601                                        struct FTP *ftp)
1602{
1603  /* We have sent the TYPE, now we must send the list of prequote strings */
1604  return ftp_state_quote(data, ftpc, ftp, TRUE, FTP_LIST_PREQUOTE);
1605}
1606
1607static CURLcode ftp_state_retr_prequote(struct Curl_easy *data,
1608                                        struct ftp_conn *ftpc,
1609                                        struct FTP *ftp)
1610{
1611  /* We have sent the TYPE, now we must send the list of prequote strings */
1612  return ftp_state_quote(data, ftpc, ftp, TRUE, FTP_RETR_PREQUOTE);
1613}
1614
1615static CURLcode ftp_state_stor_prequote(struct Curl_easy *data,
1616                                        struct ftp_conn *ftpc,
1617                                        struct FTP *ftp)
1618{
1619  /* We have sent the TYPE, now we must send the list of prequote strings */
1620  return ftp_state_quote(data, ftpc, ftp, TRUE, FTP_STOR_PREQUOTE);
1621}
1622
1623static CURLcode ftp_state_type(struct Curl_easy *data,
1624                               struct ftp_conn *ftpc,
1625                               struct FTP *ftp)
1626{
1627  CURLcode result = CURLE_OK;
1628
1629  /* If we have selected NOBODY and HEADER, it means that we only want file
1630     information. Which in FTP cannot be much more than the file size and
1631     date. */
1632  if(data->req.no_body && ftpc->file &&
1633     ftp_need_type(ftpc, (bool)data->state.prefer_ascii)) {
1634    /* The SIZE command is _not_ RFC 959 specified, and therefore many servers
1635       may not support it! It is however the only way we have to get a file's
1636       size! */
1637
1638    ftp->transfer = PPTRANSFER_INFO;
1639    /* this means no actual transfer will be made */
1640
1641    /* Some servers return different sizes for different modes, and thus we
1642       must set the proper type before we check the size */
1643    result = ftp_nb_type(data, ftpc, ftp, (bool)data->state.prefer_ascii,
1644                         FTP_TYPE);
1645    if(result)
1646      return result;
1647  }
1648  else
1649    result = ftp_state_size(data, ftpc, ftp);
1650
1651  return result;
1652}
1653
1654/* This is called after the CWD commands have been done in the beginning of
1655   the DO phase */
1656static CURLcode ftp_state_mdtm(struct Curl_easy *data,
1657                               struct ftp_conn *ftpc,
1658                               struct FTP *ftp)
1659{
1660  CURLcode result = CURLE_OK;
1661
1662  /* Requested time of file or time-depended transfer? */
1663  if((data->set.get_filetime || data->set.timecondition) && ftpc->file) {
1664
1665    /* we have requested to get the modified-time of the file, this is a white
1666       spot as the MDTM is not mentioned in RFC959 */
1667    result = Curl_pp_sendf(data, &ftpc->pp, "MDTM %s", ftpc->file);
1668
1669    if(!result)
1670      ftp_state(data, ftpc, FTP_MDTM);
1671  }
1672  else
1673    result = ftp_state_type(data, ftpc, ftp);
1674
1675  return result;
1676}
1677
1678/* This is called after the TYPE and possible quote commands have been sent */
1679static CURLcode ftp_state_ul_setup(struct Curl_easy *data,
1680                                   struct ftp_conn *ftpc,
1681                                   struct FTP *ftp,
1682                                   bool sizechecked)
1683{
1684  CURLcode result = CURLE_OK;
1685  curl_bit append = data->set.remote_append;
1686
1687  if((data->state.resume_from && !sizechecked) ||
1688     ((data->state.resume_from > 0) && sizechecked)) {
1689    /* we are about to continue the uploading of a file
1690       1. get already existing file's size. We use the SIZE command for this
1691          which may not exist in the server!  The SIZE command is not in
1692          RFC959.
1693
1694       2. This used to set REST, but since we can do append, we issue no
1695          another ftp command. Skip the source file offset and APPEND the rest
1696          on the file instead
1697
1698       3. pass file-size number of bytes in the source file
1699       4. lower the infilesize counter */
1700    /* => transfer as usual */
1701    int seekerr = CURL_SEEKFUNC_OK;
1702
1703    if(data->state.resume_from < 0) {
1704      /* Got no given size to start from, figure it out */
1705      result = Curl_pp_sendf(data, &ftpc->pp, "SIZE %s", ftpc->file);
1706      if(!result)
1707        ftp_state(data, ftpc, FTP_STOR_SIZE);
1708      return result;
1709    }
1710
1711    /* enable append */
1712    append = TRUE;
1713
1714    /* Let's read off the proper amount of bytes from the input. */
1715    if(data->set.seek_func) {
1716      Curl_set_in_callback(data, TRUE);
1717      seekerr = data->set.seek_func(data->set.seek_client,
1718                                    data->state.resume_from, SEEK_SET);
1719      Curl_set_in_callback(data, FALSE);
1720    }
1721
1722    if(seekerr != CURL_SEEKFUNC_OK) {
1723      curl_off_t passed = 0;
1724      if(seekerr != CURL_SEEKFUNC_CANTSEEK) {
1725        failf(data, "Could not seek stream");
1726        return CURLE_FTP_COULDNT_USE_REST;
1727      }
1728      /* seekerr == CURL_SEEKFUNC_CANTSEEK (cannot seek to offset) */
1729      do {
1730        char scratch[4 * 1024];
1731        size_t readthisamountnow =
1732          (data->state.resume_from - passed > (curl_off_t)sizeof(scratch)) ?
1733          sizeof(scratch) :
1734          curlx_sotouz(data->state.resume_from - passed);
1735
1736        size_t actuallyread =
1737          data->state.fread_func(scratch, 1, readthisamountnow,
1738                                 data->state.in);
1739
1740        passed += actuallyread;
1741        if((actuallyread == 0) || (actuallyread > readthisamountnow)) {
1742          /* this checks for greater-than only to make sure that the
1743             CURL_READFUNC_ABORT return code still aborts */
1744          failf(data, "Failed to read data");
1745          return CURLE_FTP_COULDNT_USE_REST;
1746        }
1747      } while(passed < data->state.resume_from);
1748    }
1749    /* now, decrease the size of the read */
1750    if(data->state.infilesize > 0) {
1751      data->state.infilesize -= data->state.resume_from;
1752
1753      if(data->state.infilesize <= 0) {
1754        infof(data, "File already completely uploaded");
1755
1756        /* no data to transfer */
1757        Curl_xfer_setup_nop(data);
1758
1759        /* Set ->transfer so that we will not get any error in
1760         * ftp_done() because we did not transfer anything! */
1761        ftp->transfer = PPTRANSFER_NONE;
1762
1763        ftp_state(data, ftpc, FTP_STOP);
1764        return CURLE_OK;
1765      }
1766    }
1767    /* we have passed, proceed as normal */
1768  } /* resume_from */
1769
1770  result = Curl_pp_sendf(data, &ftpc->pp, append ? "APPE %s" : "STOR %s",
1771                         ftpc->file);
1772  if(!result)
1773    ftp_state(data, ftpc, FTP_STOR);
1774
1775  return result;
1776}
1777
1778static CURLcode ftp_state_retr(struct Curl_easy *data,
1779                               struct ftp_conn *ftpc,
1780                               struct FTP *ftp,
1781                               curl_off_t filesize)
1782{
1783  CURLcode result = CURLE_OK;
1784
1785  CURL_TRC_FTP(data, "[%s] ftp_state_retr()", FTP_CSTATE(ftpc));
1786  if(data->set.max_filesize && (filesize > data->set.max_filesize)) {
1787    failf(data, "Maximum file size exceeded");
1788    return CURLE_FILESIZE_EXCEEDED;
1789  }
1790  ftp->downloadsize = filesize;
1791
1792  if(data->state.resume_from) {
1793    /* We always (attempt to) get the size of downloads, so it is done before
1794       this even when not doing resumes. */
1795    if(filesize == -1) {
1796      infof(data, "ftp server does not support SIZE");
1797      /* We could not get the size and therefore we cannot know if there
1798         really is a part of the file left to get, although the server will
1799         close the connection when we start the connection so it will not
1800         cause us any harm, not make us exit as nicely. */
1801    }
1802    else {
1803      /* We got a file size report, so we check that there actually is a
1804         part of the file left to get, or else we go home. */
1805      if(data->state.resume_from < 0) {
1806        /* We are supposed to download the last abs(from) bytes */
1807        if(filesize < -data->state.resume_from) {
1808          failf(data, "Offset (%" FMT_OFF_T
1809                ") was beyond file size (%" FMT_OFF_T ")",
1810                data->state.resume_from, filesize);
1811          return CURLE_BAD_DOWNLOAD_RESUME;
1812        }
1813        /* convert to size to download */
1814        ftp->downloadsize = -data->state.resume_from;
1815        /* download from where? */
1816        data->state.resume_from = filesize - ftp->downloadsize;
1817      }
1818      else {
1819        if(filesize < data->state.resume_from) {
1820          failf(data, "Offset (%" FMT_OFF_T
1821                ") was beyond file size (%" FMT_OFF_T ")",
1822                data->state.resume_from, filesize);
1823          return CURLE_BAD_DOWNLOAD_RESUME;
1824        }
1825        /* Now store the number of bytes we are expected to download */
1826        ftp->downloadsize = filesize - data->state.resume_from;
1827      }
1828    }
1829
1830    if(ftp->downloadsize == 0) {
1831      /* no data to transfer */
1832      Curl_xfer_setup_nop(data);
1833      infof(data, "File already completely downloaded");
1834
1835      /* Set ->transfer so that we will not get any error in ftp_done()
1836       * because we did not transfer the any file */
1837      ftp->transfer = PPTRANSFER_NONE;
1838      ftp_state(data, ftpc, FTP_STOP);
1839      return CURLE_OK;
1840    }
1841
1842    /* Set resume file transfer offset */
1843    infof(data, "Instructs server to resume from offset %" FMT_OFF_T,
1844          data->state.resume_from);
1845
1846    result = Curl_pp_sendf(data, &ftpc->pp, "REST %" FMT_OFF_T,
1847                           data->state.resume_from);
1848    if(!result)
1849      ftp_state(data, ftpc, FTP_RETR_REST);
1850  }
1851  else {
1852    /* no resume */
1853    result = Curl_pp_sendf(data, &ftpc->pp, "RETR %s", ftpc->file);
1854    if(!result)
1855      ftp_state(data, ftpc, FTP_RETR);
1856  }
1857
1858  return result;
1859}
1860
1861static CURLcode ftp_state_quote(struct Curl_easy *data,
1862                                struct ftp_conn *ftpc,
1863                                struct FTP *ftp,
1864                                bool init,
1865                                ftpstate instate)
1866{
1867  CURLcode result = CURLE_OK;
1868  bool quote = FALSE;
1869  struct curl_slist *item;
1870
1871  switch(instate) {
1872  case FTP_QUOTE:
1873  default:
1874    item = data->set.quote;
1875    break;
1876  case FTP_RETR_PREQUOTE:
1877  case FTP_STOR_PREQUOTE:
1878  case FTP_LIST_PREQUOTE:
1879    item = data->set.prequote;
1880    break;
1881  case FTP_POSTQUOTE:
1882    item = data->set.postquote;
1883    break;
1884  }
1885
1886  /*
1887   * This state uses:
1888   * 'count1' to iterate over the commands to send
1889   * 'count2' to store whether to allow commands to fail
1890   */
1891
1892  if(init)
1893    ftpc->count1 = 0;
1894  else
1895    ftpc->count1++;
1896
1897  if(item) {
1898    int i = 0;
1899
1900    /* Skip count1 items in the linked list */
1901    while((i < ftpc->count1) && item) {
1902      item = item->next;
1903      i++;
1904    }
1905    if(item) {
1906      const char *cmd = item->data;
1907      if(cmd[0] == '*') {
1908        cmd++;
1909        ftpc->count2 = 1; /* the sent command is allowed to fail */
1910      }
1911      else
1912        ftpc->count2 = 0; /* failure means cancel operation */
1913
1914      result = Curl_pp_sendf(data, &ftpc->pp, "%s", cmd);
1915      if(result)
1916        return result;
1917      ftp_state(data, ftpc, instate);
1918      quote = TRUE;
1919    }
1920  }
1921
1922  if(!quote) {
1923    /* No more quote to send, continue to ... */
1924    switch(instate) {
1925    case FTP_QUOTE:
1926    default:
1927      result = ftp_state_cwd(data, ftpc, ftp);
1928      break;
1929    case FTP_RETR_PREQUOTE:
1930      if(ftp->transfer != PPTRANSFER_BODY)
1931        ftp_state(data, ftpc, FTP_STOP);
1932      else {
1933        if(ftpc->known_filesize != -1) {
1934          Curl_pgrsSetDownloadSize(data, ftpc->known_filesize);
1935          result = ftp_state_retr(data, ftpc, ftp, ftpc->known_filesize);
1936        }
1937        else {
1938          if(data->set.ignorecl || data->state.prefer_ascii) {
1939            /* 'ignorecl' is used to support download of growing files. It
1940               prevents the state machine from requesting the file size from
1941               the server. With an unknown file size the download continues
1942               until the server terminates it, otherwise the client stops if
1943               the received byte count exceeds the reported file size. Set
1944               option CURLOPT_IGNORE_CONTENT_LENGTH to 1 to enable this
1945               behavior.
1946
1947               In addition: asking for the size for 'TYPE A' transfers is not
1948               constructive since servers do not report the converted size.
1949               Thus, skip it.
1950            */
1951            result = Curl_pp_sendf(data, &ftpc->pp, "RETR %s", ftpc->file);
1952            if(!result)
1953              ftp_state(data, ftpc, FTP_RETR);
1954          }
1955          else {
1956            result = Curl_pp_sendf(data, &ftpc->pp, "SIZE %s", ftpc->file);
1957            if(!result)
1958              ftp_state(data, ftpc, FTP_RETR_SIZE);
1959          }
1960        }
1961      }
1962      break;
1963    case FTP_STOR_PREQUOTE:
1964      result = ftp_state_ul_setup(data, ftpc, ftp, FALSE);
1965      break;
1966    case FTP_POSTQUOTE:
1967      break;
1968    case FTP_LIST_PREQUOTE:
1969      ftp_state(data, ftpc, FTP_LIST_TYPE);
1970      result = ftp_state_list(data, ftpc, ftp);
1971      break;
1972    }
1973  }
1974
1975  return result;
1976}
1977
1978/* called from ftp_state_pasv_resp to switch to PASV in case of EPSV
1979   problems */
1980static CURLcode ftp_epsv_disable(struct Curl_easy *data,
1981                                 struct ftp_conn *ftpc,
1982                                 struct connectdata *conn)
1983{
1984  CURLcode result = CURLE_OK;
1985
1986  if(conn->bits.ipv6
1987#ifndef CURL_DISABLE_PROXY
1988     && !(conn->bits.tunnel_proxy || conn->bits.socksproxy)
1989#endif
1990    ) {
1991    /* We cannot disable EPSV when doing IPv6, so this is instead a fail */
1992    failf(data, "Failed EPSV attempt, exiting");
1993    return CURLE_WEIRD_SERVER_REPLY;
1994  }
1995
1996  infof(data, "Failed EPSV attempt. Disabling EPSV");
1997  /* disable it for next transfer */
1998  conn->bits.ftp_use_epsv = FALSE;
1999  close_secondarysocket(data, ftpc);
2000  data->state.errorbuf = FALSE; /* allow error message to get
2001                                         rewritten */
2002  result = Curl_pp_sendf(data, &ftpc->pp, "%s", "PASV");
2003  if(!result) {
2004    ftpc->count1++;
2005    /* remain in/go to the FTP_PASV state */
2006    ftp_state(data, ftpc, FTP_PASV);
2007  }
2008  return result;
2009}
2010
2011static CURLcode ftp_control_addr_dup(struct Curl_easy *data, char **newhostp)
2012{
2013  struct connectdata *conn = data->conn;
2014  struct ip_quadruple ipquad;
2015  bool is_ipv6;
2016
2017  /* Returns the control connection IP address.
2018     If a proxy tunnel is used, returns the original hostname instead, because
2019     the effective control connection address is the proxy address,
2020     not the ftp host. */
2021#ifndef CURL_DISABLE_PROXY
2022  if(conn->bits.tunnel_proxy || conn->bits.socksproxy)
2023    *newhostp = curlx_strdup(conn->origin->hostname);
2024  else
2025#endif
2026  if(!Curl_conn_get_ip_info(data, conn, FIRSTSOCKET, &is_ipv6, &ipquad) &&
2027     *ipquad.remote_ip)
2028    *newhostp = curlx_strdup(ipquad.remote_ip);
2029  else {
2030    /* failed to get the remote_ip of the DATA connection */
2031    failf(data, "unable to get peername of DATA connection");
2032    *newhostp = NULL;
2033    return CURLE_FTP_CANT_GET_HOST;
2034  }
2035  return *newhostp ? CURLE_OK : CURLE_OUT_OF_MEMORY;
2036}
2037
2038static bool match_pasv_6nums(const char *p,
2039                             unsigned int *array) /* 6 numbers */
2040{
2041  int i;
2042  for(i = 0; i < 6; i++) {
2043    curl_off_t num;
2044    if(i) {
2045      if(*p != ',')
2046        return FALSE;
2047      p++;
2048    }
2049    if(curlx_str_number(&p, &num, 0xff))
2050      return FALSE;
2051    array[i] = (unsigned int)num;
2052  }
2053  return TRUE;
2054}
2055
2056static CURLcode ftp_state_pasv_resp(struct Curl_easy *data,
2057                                    struct ftp_conn *ftpc,
2058                                    int ftpcode)
2059{
2060  struct connectdata *conn = data->conn;
2061  CURLcode result;
2062  const struct pingpong *pp = &ftpc->pp;
2063  char *newhost = NULL;
2064  unsigned short newport = 0;
2065  const char *str = curlx_dyn_ptr(&pp->recvbuf) + 4; /* start on the first
2066                                                        letter */
2067  if((ftpc->count1 == 0) &&
2068     (ftpcode == 229)) {
2069    /* positive EPSV response */
2070    const char *ptr = strchr(str, '(');
2071    if(ptr) {
2072      char sep;
2073      ptr++;
2074      /* |||12345| */
2075      sep = ptr[0];
2076      if(sep && (ptr[1] == sep) && (ptr[2] == sep) && ISDIGIT(ptr[3])) {
2077        const char *p = &ptr[3];
2078        curl_off_t num;
2079        if(curlx_str_number(&p, &num, 0xffff) || (*p != sep)) {
2080          failf(data, "Illegal port number in EPSV reply");
2081          return CURLE_FTP_WEIRD_PASV_REPLY;
2082        }
2083        newport = (unsigned short)num;
2084        result = ftp_control_addr_dup(data, &newhost);
2085        if(result)
2086          return result;
2087      }
2088      else
2089        ptr = NULL;
2090    }
2091    if(!ptr) {
2092      failf(data, "Weirdly formatted EPSV reply");
2093      return CURLE_FTP_WEIRD_PASV_REPLY;
2094    }
2095  }
2096  else if((ftpc->count1 == 1) &&
2097          (ftpcode == 227)) {
2098    /* positive PASV response */
2099    unsigned int ip[6];
2100
2101    /*
2102     * Scan for a sequence of six comma-separated numbers and use them as
2103     * IP+port indicators.
2104     *
2105     * Found reply-strings include:
2106     * "227 Entering Passive Mode (127,0,0,1,4,51)"
2107     * "227 Data transfer will passively listen to 127,0,0,1,4,51"
2108     * "227 Entering passive mode. 127,0,0,1,4,51"
2109     */
2110    while(*str) {
2111      if(match_pasv_6nums(str, ip))
2112        break;
2113      str++;
2114    }
2115
2116    if(!*str) {
2117      failf(data, "Could not interpret the 227-response");
2118      return CURLE_FTP_WEIRD_227_FORMAT;
2119    }
2120
2121    /* we got OK from server */
2122    if(data->set.ftp_skip_ip) {
2123      /* told to ignore the remotely given IP but instead use the host we used
2124         for the control connection */
2125      infof(data, "Skip %u.%u.%u.%u for data connection, reuse %s instead",
2126            ip[0], ip[1], ip[2], ip[3], conn->origin->hostname);
2127      result = ftp_control_addr_dup(data, &newhost);
2128      if(result)
2129        return result;
2130    }
2131    else
2132      newhost = curl_maprintf("%u.%u.%u.%u", ip[0], ip[1], ip[2], ip[3]);
2133
2134    if(!newhost)
2135      return CURLE_OUT_OF_MEMORY;
2136
2137    newport = (unsigned short)(((ip[4] << 8) + ip[5]) & 0xffff);
2138  }
2139  else if(ftpc->count1 == 0) {
2140    /* EPSV failed, move on to PASV */
2141    return ftp_epsv_disable(data, ftpc, conn);
2142  }
2143  else {
2144    failf(data, "Bad PASV/EPSV response: %03d", ftpcode);
2145    return CURLE_FTP_WEIRD_PASV_REPLY;
2146  }
2147
2148  DEBUGASSERT(newhost);
2149  Curl_peer_unlink(&conn->origin2);
2150  result = Curl_peer_create(data, conn->scheme, newhost, newport,
2151                            &conn->origin2);
2152  if(result)
2153    goto error;
2154
2155  /* If FIRSTSOCKET goes via another peer, SECONDARY needs as well,
2156   * but with its new port. */
2157  if(conn->via_peer) {
2158    Curl_peer_unlink(&conn->via_peer2);
2159    result = Curl_peer_create(data, conn->via_peer->scheme,
2160                              conn->via_peer->hostname, newport,
2161                              &conn->via_peer2);
2162    if(result)
2163      goto error;
2164  }
2165
2166  result = Curl_conn_setup(data, conn, SECONDARYSOCKET,
2167                           conn->bits.ftp_use_data_ssl ?
2168                           CURL_CF_SSL_ENABLE : CURL_CF_SSL_DISABLE);
2169
2170  if(result) {
2171    if((result != CURLE_OUT_OF_MEMORY) &&
2172       (ftpc->count1 == 0) && (ftpcode == 229)) {
2173      result = ftp_epsv_disable(data, ftpc, conn);
2174    }
2175    goto error;
2176  }
2177
2178  /*
2179   * When this is used from the multi interface, this might have returned with
2180   * the 'connected' set to FALSE and thus we are now awaiting a non-blocking
2181   * connect to connect.
2182   */
2183
2184#ifdef CURLVERBOSE
2185  if(data->set.verbose) {
2186    /* Dump information about this second connection when we have issued
2187     * a PASV command. */
2188    infof(data, "Connecting to %s port %d",
2189          conn->origin2->hostname, conn->origin2->port);
2190  }
2191#endif
2192
2193  conn->bits.do_more = TRUE;
2194  ftp_state(data, ftpc, FTP_STOP); /* this phase is completed */
2195
2196error:
2197  curlx_free(newhost);
2198  return result;
2199}
2200
2201/* called repeatedly until done from multi.c */
2202static CURLcode ftp_statemach(struct Curl_easy *data,
2203                              struct ftp_conn *ftpc,
2204                              bool *done)
2205{
2206  CURLcode result = Curl_pp_statemach(data, &ftpc->pp, FALSE, FALSE);
2207
2208  /* Check for the state outside of the Curl_socket_check() return code checks
2209     since at times we are in fact already in this state when this function
2210     gets called. */
2211  *done = (ftpc->state == FTP_STOP);
2212
2213  return result;
2214}
2215
2216/*
2217 * ftp_do_more()
2218 *
2219 * This function shall be called when the second FTP (data) connection is
2220 * connected.
2221 *
2222 * 'more' can return DOMORE_INCOMPLETE, DOMORE_DONE or DOMORE_GOBACK
2223 * (which is for when PASV is being sent to retry a failed EPSV).
2224 */
2225static CURLcode ftp_do_more(struct Curl_easy *data, domore *more)
2226{
2227  struct connectdata *conn = data->conn;
2228  struct ftp_conn *ftpc = Curl_conn_meta_get(data->conn, CURL_META_FTP_CONN);
2229  struct FTP *ftp = Curl_meta_get(data, CURL_META_FTP_EASY);
2230  CURLcode result = CURLE_OK;
2231  bool connected = FALSE;
2232  bool complete = FALSE;
2233  /* the ftp struct is inited in ftp_connect(). If we are connecting to an HTTP
2234   * proxy then the state will not be valid until after that connection is
2235   * complete */
2236
2237  if(!ftpc || !ftp)
2238    return CURLE_FAILED_INIT;
2239
2240  *more = DOMORE_INCOMPLETE; /* default to stay in the state */
2241
2242  /* if the second connection has been set up, try to connect it fully
2243   * to the remote host. This may not complete at this time, for several
2244   * reasons:
2245   * - we do EPTR and the server will not connect to our listen socket
2246   *   until we send more FTP commands
2247   * - an SSL filter is in place and the server will not start the TLS
2248   *   handshake until we send more FTP commands
2249   */
2250  if(conn->cfilter[SECONDARYSOCKET]) {
2251    bool is_eptr = Curl_conn_is_tcp_listen(data, SECONDARYSOCKET);
2252    result = Curl_conn_connect(data, SECONDARYSOCKET, FALSE, &connected);
2253    if(result == CURLE_OUT_OF_MEMORY)
2254      return result;
2255    if(result || (!connected && !is_eptr &&
2256                  !Curl_conn_is_ip_connected(data, SECONDARYSOCKET))) {
2257      if(result && !is_eptr && (ftpc->count1 == 0)) {
2258        *more = DOMORE_GOBACK; /* go back to DOING please */
2259        /* this is a EPSV connect failing, try PASV instead */
2260        return ftp_epsv_disable(data, ftpc, conn);
2261      }
2262      return result;
2263    }
2264  }
2265
2266  if(ftpc->state) {
2267    /* already in a state so skip the initial commands.
2268       They are only done to kickstart the do_more state */
2269    result = ftp_statemach(data, ftpc, &complete);
2270
2271    if(complete)
2272      *more = DOMORE_DONE;
2273
2274    /* if we got an error or if we do not wait for a data connection return
2275       immediately */
2276    if(result || !ftpc->wait_data_conn)
2277      return result;
2278
2279    /* if we reach the end of the FTP state machine here, *complete will be
2280       TRUE but so is ftpc->wait_data_conn, which says we need to wait for the
2281       data connection and therefore we are not actually complete */
2282    *more = DOMORE_INCOMPLETE;
2283  }
2284
2285  if(ftp->transfer <= PPTRANSFER_INFO) {
2286    /* a transfer is about to take place, or if not a filename was given so we
2287       will do a SIZE on it later and then we need the right TYPE first */
2288
2289    if(ftpc->wait_data_conn) {
2290      bool serv_conned;
2291
2292      result = Curl_conn_connect(data, SECONDARYSOCKET, FALSE, &serv_conned);
2293      if(result)
2294        return result; /* Failed to accept data connection */
2295
2296      if(serv_conned) {
2297        /* It looks data connection is established */
2298        ftpc->wait_data_conn = FALSE;
2299        result = ftp_initiate_transfer(data, ftpc);
2300
2301        if(result)
2302          return result;
2303
2304        *more = DOMORE_DONE; /* this state is now complete when the server has
2305                                connected back to us */
2306      }
2307      else {
2308        result = ftp_check_ctrl_on_data_wait(data, ftpc);
2309        if(result)
2310          return result;
2311      }
2312    }
2313    else if(data->state.upload) {
2314      result = ftp_nb_type(data, ftpc, ftp, (bool)data->state.prefer_ascii,
2315                           FTP_STOR_TYPE);
2316      if(result)
2317        return result;
2318
2319      result = ftp_statemach(data, ftpc, &complete);
2320      /* ftp_nb_type() might have skipped sending `TYPE A|I` when not
2321       * deemed necessary and directly sent `STORE name`. If this was
2322       * then complete, but we are still waiting on the data connection,
2323       * the transfer has not been initiated yet. */
2324      *more = (!ftpc->wait_data_conn && complete) ?
2325        DOMORE_DONE : DOMORE_INCOMPLETE;
2326    }
2327    else {
2328      /* download */
2329      ftp->downloadsize = -1; /* unknown as of yet */
2330
2331      result = Curl_range(data);
2332
2333      if(result == CURLE_OK && data->req.maxdownload >= 0) {
2334        /* Do not check for successful transfer */
2335        ftpc->dont_check = TRUE;
2336      }
2337
2338      if(result)
2339        ;
2340      else if((data->state.list_only || !ftpc->file) &&
2341              !(data->set.prequote)) {
2342        /* The specified path ends with a slash, and therefore we think this
2343           is a directory that is requested, use LIST. Before that, we also
2344           need to set ASCII transfer mode. */
2345
2346        /* Only if a body transfer was requested. */
2347        if(ftp->transfer == PPTRANSFER_BODY) {
2348          result = ftp_nb_type(data, ftpc, ftp, TRUE, FTP_LIST_TYPE);
2349          if(result)
2350            return result;
2351        }
2352        /* otherwise fall through */
2353      }
2354      else {
2355        if(data->set.prequote && !ftpc->file) {
2356          result = ftp_nb_type(data, ftpc, ftp, TRUE,
2357                               FTP_RETR_LIST_TYPE);
2358        }
2359        else {
2360          result = ftp_nb_type(data, ftpc, ftp, (bool)data->state.prefer_ascii,
2361                               FTP_RETR_TYPE);
2362        }
2363        if(result)
2364          return result;
2365      }
2366
2367      result = ftp_statemach(data, ftpc, &complete);
2368      if(complete)
2369        *more = DOMORE_DONE;
2370    }
2371    return result;
2372  }
2373
2374  /* no data to transfer */
2375  Curl_xfer_setup_nop(data);
2376
2377  if(!ftpc->wait_data_conn) {
2378    /* no waiting for the data connection so this is now complete */
2379    *more = DOMORE_DONE;
2380    CURL_TRC_FTP(data, "[%s] DO-MORE phase ends with %d", FTP_CSTATE(ftpc),
2381                 (int)result);
2382  }
2383
2384  return result;
2385}
2386
2387/* call this when the DO phase has completed */
2388static CURLcode ftp_dophase_done(struct Curl_easy *data,
2389                                 struct ftp_conn *ftpc,
2390                                 struct FTP *ftp,
2391                                 bool connected)
2392{
2393  if(connected) {
2394    domore completed;
2395    CURLcode result = ftp_do_more(data, &completed);
2396
2397    if(result) {
2398      close_secondarysocket(data, ftpc);
2399      return result;
2400    }
2401  }
2402
2403  if(ftp->transfer != PPTRANSFER_BODY)
2404    /* no data to transfer */
2405    Curl_xfer_setup_nop(data);
2406  else if(!connected)
2407    /* since we did not connect now, we want do_more to get called */
2408    data->conn->bits.do_more = TRUE;
2409
2410  ftpc->ctl_valid = TRUE; /* seems good */
2411
2412  return CURLE_OK;
2413}
2414
2415static CURLcode ftp_state_port_resp(struct Curl_easy *data,
2416                                    struct ftp_conn *ftpc,
2417                                    struct FTP *ftp,
2418                                    int ftpcode)
2419{
2420  struct connectdata *conn = data->conn;
2421  ftpport fcmd = (ftpport)ftpc->count1;
2422  CURLcode result = CURLE_OK;
2423
2424  /* The FTP spec tells a positive response should have code 200.
2425     Be more permissive here to tolerate deviant servers. */
2426  if(ftpcode / 100 != 2) {
2427    /* the command failed */
2428
2429    if(EPRT == fcmd) {
2430      infof(data, "disabling EPRT usage");
2431      conn->bits.ftp_use_eprt = FALSE;
2432    }
2433    fcmd++;
2434
2435    if(fcmd == DONE) {
2436      failf(data, "Failed to do PORT");
2437      result = CURLE_FTP_PORT_FAILED;
2438    }
2439    else
2440      /* try next */
2441      result = ftp_state_use_port(data, ftpc, fcmd);
2442  }
2443  else {
2444    infof(data, "Connect data stream actively");
2445    ftp_state(data, ftpc, FTP_STOP); /* end of DO phase */
2446    result = ftp_dophase_done(data, ftpc, ftp, FALSE);
2447  }
2448
2449  return result;
2450}
2451
2452/* return TRUE on error, FALSE on success */
2453static bool twodigit(const char *p, int *val)
2454{
2455  if(!ISDIGIT(p[0]) || !ISDIGIT(p[1]))
2456    return TRUE;
2457  /* curlx_hexval() works fine here since we make sure it is decimal above */
2458  *val = (curlx_hexval(p[0]) * 10) + curlx_hexval(p[1]);
2459  return FALSE;
2460}
2461
2462/*
2463 * @unittest 1668
2464 */
2465UNITTEST bool ftp_213_date(const char *p, int *year, int *month, int *day,
2466                           int *hour, int *minute, int *second);
2467UNITTEST bool ftp_213_date(const char *p, int *year, int *month, int *day,
2468                           int *hour, int *minute, int *second)
2469{
2470  int century;
2471  if((strlen(p) < 14) || twodigit(&p[0], &century) || twodigit(&p[2], year) ||
2472     twodigit(&p[4], month) || twodigit(&p[6], day) ||
2473     twodigit(&p[8], hour) || twodigit(&p[10], minute) ||
2474     twodigit(&p[12], second))
2475    return FALSE;
2476
2477  *year += century * 100;
2478  if((*month > 12) || (*day > 31) || (*hour > 23) || (*minute > 59) ||
2479     (*second > 60))
2480    return FALSE;
2481  return TRUE;
2482}
2483
2484static CURLcode client_write_header(struct Curl_easy *data,
2485                                    char *buf, size_t blen)
2486{
2487  /* Some replies from an FTP server are written to the client
2488   * as CLIENTWRITE_HEADER, formatted as if they came from a
2489   * HTTP conversation.
2490   * In all protocols, CLIENTWRITE_HEADER data is only passed to
2491   * the body write callback when data->set.include_header is set
2492   * via CURLOPT_HEADER.
2493   * For historic reasons, FTP never played this game and expects
2494   * all its headers to do that always. Set that flag during the
2495   * call to Curl_client_write() so it does the right thing.
2496   *
2497   * Notice that we cannot enable this flag for FTP in general,
2498   * as an FTP transfer might involve an HTTP proxy connection and
2499   * headers from CONNECT should not automatically be part of the
2500   * output. */
2501  CURLcode result;
2502  bool save = (bool)data->set.include_header;
2503  data->set.include_header = TRUE;
2504  result = Curl_client_write(data, CLIENTWRITE_HEADER, buf, blen);
2505  data->set.include_header = save;
2506  return result;
2507}
2508
2509static CURLcode ftp_state_mdtm_resp(struct Curl_easy *data,
2510                                    struct ftp_conn *ftpc,
2511                                    struct FTP *ftp,
2512                                    int ftpcode)
2513{
2514  CURLcode result = CURLE_OK;
2515
2516  switch(ftpcode) {
2517  case 213: {
2518    /* we got a time. Format should be: "YYYYMMDDHHMMSS[.sss]" where the
2519       last .sss part is optional and means fractions of a second */
2520    int year, month, day, hour, minute, second;
2521    struct pingpong *pp = &ftpc->pp;
2522    const char *resp = curlx_dyn_ptr(&pp->recvbuf) + 4;
2523    bool showtime = FALSE;
2524    if(ftp_213_date(resp, &year, &month, &day, &hour, &minute, &second)) {
2525      /* we have a time, reformat it */
2526      char timebuf[24];
2527      curl_msnprintf(timebuf, sizeof(timebuf),
2528                     "%04d%02d%02d %02d:%02d:%02d GMT",
2529                     year, month, day, hour, minute, second);
2530      /* now, convert this into a time() value: */
2531      if(!Curl_getdate_capped(timebuf, &data->info.filetime))
2532        showtime = TRUE;
2533    }
2534
2535    /* If we asked for a time of the file and we actually got one as well,
2536       we "emulate" an HTTP-style header in our output. */
2537
2538#if defined(CURL_HAVE_DIAG) && (defined(__DJGPP__) || defined(__AMIGA__))
2539#pragma GCC diagnostic push
2540/* 'time_t' is unsigned in MSDOS and AmigaOS. Silence:
2541   warning: comparison of unsigned expression in '>= 0' is always true */
2542#pragma GCC diagnostic ignored "-Wtype-limits"
2543#endif
2544    if(data->req.no_body && ftpc->file &&
2545       data->set.get_filetime && showtime) {
2546#if defined(CURL_HAVE_DIAG) && (defined(__DJGPP__) || defined(__AMIGA__))
2547#pragma GCC diagnostic pop
2548#endif
2549      char headerbuf[128];
2550      int headerbuflen;
2551      time_t filetime = data->info.filetime;
2552      struct tm buffer;
2553      const struct tm *tm = &buffer;
2554
2555      result = curlx_gmtime(filetime, &buffer);
2556      if(result)
2557        return result;
2558
2559      /* format: "Tue, 15 Nov 1994 12:45:26" */
2560      headerbuflen =
2561        curl_msnprintf(headerbuf, sizeof(headerbuf),
2562                       "Last-Modified: %s, %02d %s %4d %02d:%02d:%02d "
2563                       "GMT\r\n",
2564                       Curl_wkday[tm->tm_wday ? tm->tm_wday-1 : 6],
2565                       tm->tm_mday,
2566                       Curl_month[tm->tm_mon],
2567                       tm->tm_year + 1900,
2568                       tm->tm_hour,
2569                       tm->tm_min,
2570                       tm->tm_sec);
2571      result = client_write_header(data, headerbuf, headerbuflen);
2572      if(result)
2573        return result;
2574    } /* end of a ridiculous amount of conditionals */
2575  }
2576    break;
2577  default:
2578    infof(data, "unsupported MDTM reply format");
2579    break;
2580  case 550: /* 550 is used for several different problems, e.g.
2581               "No such file or directory" or "Permission denied".
2582               It does not mean that the file does not exist at all. */
2583    infof(data, "MDTM failed: file does not exist or permission problem,"
2584          " continuing");
2585    break;
2586  }
2587
2588  if(data->set.timecondition) {
2589    if((data->info.filetime > 0) && (data->set.timevalue > 0)) {
2590      switch(data->set.timecondition) {
2591      case CURL_TIMECOND_IFMODSINCE:
2592      default:
2593        if(data->info.filetime <= data->set.timevalue) {
2594          infof(data, "The requested document is not new enough");
2595          ftp->transfer = PPTRANSFER_NONE; /* mark to not transfer data */
2596          data->info.timecond = TRUE;
2597          ftp_state(data, ftpc, FTP_STOP);
2598          return CURLE_OK;
2599        }
2600        break;
2601      case CURL_TIMECOND_IFUNMODSINCE:
2602        if(data->info.filetime > data->set.timevalue) {
2603          infof(data, "The requested document is not old enough");
2604          ftp->transfer = PPTRANSFER_NONE; /* mark to not transfer data */
2605          data->info.timecond = TRUE;
2606          ftp_state(data, ftpc, FTP_STOP);
2607          return CURLE_OK;
2608        }
2609        break;
2610      } /* switch */
2611    }
2612    else {
2613      infof(data, "Skipping time comparison");
2614    }
2615  }
2616
2617  if(!result)
2618    result = ftp_state_type(data, ftpc, ftp);
2619
2620  return result;
2621}
2622
2623static CURLcode ftp_state_type_resp(struct Curl_easy *data,
2624                                    struct ftp_conn *ftpc,
2625                                    struct FTP *ftp,
2626                                    int ftpcode,
2627                                    ftpstate instate)
2628{
2629  CURLcode result = CURLE_OK;
2630
2631  if(ftpcode / 100 != 2) {
2632    /* "sasserftpd" and "(u)r(x)bot ftpd" both responds with 226 after a
2633       successful 'TYPE I'. While that is not as RFC959 says, it is still a
2634       positive response code and we allow that. */
2635    failf(data, "Could not set desired mode");
2636    return CURLE_FTP_COULDNT_SET_TYPE;
2637  }
2638  if(ftpcode != 200)
2639    infof(data, "Got a %03d response code instead of the assumed 200",
2640          ftpcode);
2641
2642  if(instate == FTP_TYPE)
2643    result = ftp_state_size(data, ftpc, ftp);
2644  else if(instate == FTP_LIST_TYPE)
2645    result = ftp_state_list(data, ftpc, ftp);
2646  else if(instate == FTP_RETR_TYPE)
2647    result = ftp_state_retr_prequote(data, ftpc, ftp);
2648  else if(instate == FTP_STOR_TYPE)
2649    result = ftp_state_stor_prequote(data, ftpc, ftp);
2650  else if(instate == FTP_RETR_LIST_TYPE)
2651    result = ftp_state_list_prequote(data, ftpc, ftp);
2652
2653  return result;
2654}
2655
2656static CURLcode ftp_state_size_resp(struct Curl_easy *data,
2657                                    struct ftp_conn *ftpc,
2658                                    struct FTP *ftp,
2659                                    int ftpcode,
2660                                    ftpstate instate)
2661{
2662  CURLcode result = CURLE_OK;
2663  curl_off_t filesize = -1;
2664  const char *buf = curlx_dyn_ptr(&ftpc->pp.recvbuf);
2665  size_t len = ftpc->pp.nfinal;
2666
2667  /* get the size from the ascii string: */
2668  if(ftpcode == 213) {
2669    /* To allow servers to prepend "rubbish" in the response string, we scan
2670       for all the digits at the end of the response and parse only those as a
2671       number. */
2672    const char *start = &buf[4];
2673    const char *fdigit = memchr(start, '\r', len - 4);
2674    if(fdigit) {
2675      fdigit--;
2676      if(*fdigit == '\n')
2677        fdigit--;
2678      while(ISDIGIT(fdigit[-1]) && (fdigit > start))
2679        fdigit--;
2680    }
2681    else
2682      fdigit = start;
2683    if(curlx_str_number(&fdigit, &filesize, CURL_OFF_T_MAX))
2684      filesize = -1; /* size remain unknown */
2685  }
2686  else if(ftpcode == 550) { /* "No such file or directory" */
2687    /* allow a SIZE failure for (resumed) uploads, when probing what command
2688       to use */
2689    if(instate != FTP_STOR_SIZE) {
2690      failf(data, "The file does not exist");
2691      return CURLE_REMOTE_FILE_NOT_FOUND;
2692    }
2693  }
2694
2695  if(instate == FTP_SIZE) {
2696    if(filesize != -1) {
2697      char clbuf[128];
2698      int clbuflen = curl_msnprintf(clbuf, sizeof(clbuf),
2699                                    "Content-Length: %" FMT_OFF_T "\r\n",
2700                                    filesize);
2701      result = client_write_header(data, clbuf, clbuflen);
2702      if(result)
2703        return result;
2704    }
2705    Curl_pgrsSetDownloadSize(data, filesize);
2706    result = ftp_state_rest(data, ftpc, ftp);
2707  }
2708  else if(instate == FTP_RETR_SIZE) {
2709    Curl_pgrsSetDownloadSize(data, filesize);
2710    result = ftp_state_retr(data, ftpc, ftp, filesize);
2711  }
2712  else if(instate == FTP_STOR_SIZE) {
2713    data->state.resume_from = filesize;
2714    result = ftp_state_ul_setup(data, ftpc, ftp, TRUE);
2715  }
2716
2717  return result;
2718}
2719
2720static CURLcode ftp_state_rest_resp(struct Curl_easy *data,
2721                                    struct ftp_conn *ftpc,
2722                                    struct FTP *ftp,
2723                                    int ftpcode,
2724                                    ftpstate instate)
2725{
2726  CURLcode result = CURLE_OK;
2727
2728  switch(instate) {
2729  case FTP_REST:
2730  default:
2731    if(ftpcode == 350) {
2732      char buffer[24] = { "Accept-ranges: bytes\r\n" };
2733      result = client_write_header(data, buffer, strlen(buffer));
2734      if(result)
2735        return result;
2736    }
2737    result = ftp_state_prepare_transfer(data, ftpc, ftp);
2738    break;
2739
2740  case FTP_RETR_REST:
2741    if(ftpcode != 350) {
2742      failf(data, "Could not use REST");
2743      result = CURLE_FTP_COULDNT_USE_REST;
2744    }
2745    else {
2746      result = Curl_pp_sendf(data, &ftpc->pp, "RETR %s", ftpc->file);
2747      if(!result)
2748        ftp_state(data, ftpc, FTP_RETR);
2749    }
2750    break;
2751  }
2752
2753  return result;
2754}
2755
2756static CURLcode ftp_state_stor_resp(struct Curl_easy *data,
2757                                    struct ftp_conn *ftpc,
2758                                    int ftpcode)
2759{
2760  CURLcode result = CURLE_OK;
2761
2762  if(ftpcode >= 400) {
2763    failf(data, "Failed FTP upload: %0d", ftpcode);
2764    ftp_state(data, ftpc, FTP_STOP);
2765    return CURLE_UPLOAD_FAILED;
2766  }
2767
2768  /* PORT means we are now awaiting the server to connect to us. */
2769  if(data->set.ftp_use_port) {
2770    bool connected;
2771
2772    ftp_state(data, ftpc, FTP_STOP); /* no longer in STOR state */
2773
2774    result = Curl_conn_connect(data, SECONDARYSOCKET, FALSE, &connected);
2775    if(result)
2776      return result;
2777
2778    if(!connected) {
2779      infof(data, "Data conn was not available immediately");
2780      ftpc->wait_data_conn = TRUE;
2781      return ftp_check_ctrl_on_data_wait(data, ftpc);
2782    }
2783    ftpc->wait_data_conn = FALSE;
2784  }
2785  return ftp_initiate_transfer(data, ftpc);
2786}
2787
2788/* for LIST and RETR responses */
2789static CURLcode ftp_state_get_resp(struct Curl_easy *data,
2790                                   struct ftp_conn *ftpc,
2791                                   struct FTP *ftp,
2792                                   int ftpcode,
2793                                   ftpstate instate)
2794{
2795  CURLcode result = CURLE_OK;
2796
2797  if((ftpcode == 150) || (ftpcode == 125)) {
2798
2799    /*
2800      A;
2801      150 Opening BINARY mode data connection for /etc/passwd (2241
2802      bytes).  (ok, the file is being transferred)
2803
2804      B:
2805      150 Opening ASCII mode data connection for /bin/ls
2806
2807      C:
2808      150 ASCII data connection for /bin/ls (137.167.104.91,37445) (0 bytes).
2809
2810      D:
2811      150 Opening ASCII mode data connection for [file] (0.0.0.0,0) (545 bytes)
2812
2813      E:
2814      125 Data connection already open; Transfer starting. */
2815
2816    data->req.size = -1; /* default unknown size */
2817
2818    /*
2819     * It appears that there are FTP-servers that return size 0 for files when
2820     * SIZE is used on the file while being in BINARY mode. To work around
2821     * that (stupid) behavior, we attempt to parse the RETR response even if
2822     * the SIZE returned size zero.
2823     *
2824     * Debugging help from Salvatore Sorrentino on February 26, 2003.
2825     */
2826
2827    if((instate != FTP_LIST) &&
2828       !data->state.prefer_ascii &&
2829       !data->set.ignorecl &&
2830       (ftp->downloadsize < 1)) {
2831      /*
2832       * It seems directory listings either do not show the size or often uses
2833       * size 0 anyway. ASCII transfers may cause that the transferred amount
2834       * of data is not the same as this line tells, why using this number in
2835       * those cases only confuses us.
2836       *
2837       * Example D above makes this parsing a little tricky */
2838      size_t len = curlx_dyn_len(&ftpc->pp.recvbuf);
2839      if(len >= 7) { /* "1 bytes" is 7 characters */
2840        size_t i;
2841        for(i = 0; i < len - 7; i++) {
2842          curl_off_t what;
2843          const char *buf = curlx_dyn_ptr(&ftpc->pp.recvbuf);
2844          const char *c = &buf[i];
2845          if(!curlx_str_number(&c, &what, CURL_OFF_T_MAX) &&
2846             !curlx_str_single(&c, ' ') &&
2847             !strncmp(c, "bytes", 5)) {
2848            data->req.size = what;
2849            break;
2850          }
2851        }
2852      }
2853    }
2854    else if(ftp->downloadsize > -1)
2855      data->req.size = ftp->downloadsize;
2856
2857    if(data->req.size > data->req.maxdownload && data->req.maxdownload > 0)
2858      data->req.size = data->req.maxdownload;
2859    else if((instate != FTP_LIST) && (data->state.prefer_ascii))
2860      data->req.size = -1; /* for servers that understate ASCII mode file
2861                              size */
2862
2863    infof(data, "Maxdownload = %" FMT_OFF_T, data->req.maxdownload);
2864
2865    if(instate != FTP_LIST)
2866      infof(data, "Getting file with size: %" FMT_OFF_T, data->req.size);
2867
2868    if(data->set.ftp_use_port) {
2869      bool connected;
2870
2871      result = Curl_conn_connect(data, SECONDARYSOCKET, FALSE, &connected);
2872      if(result)
2873        return result;
2874
2875      if(!connected) {
2876        infof(data, "Data conn was not available immediately");
2877        ftp_state(data, ftpc, FTP_STOP);
2878        ftpc->wait_data_conn = TRUE;
2879        return ftp_check_ctrl_on_data_wait(data, ftpc);
2880      }
2881      ftpc->wait_data_conn = FALSE;
2882    }
2883    return ftp_initiate_transfer(data, ftpc);
2884  }
2885  else {
2886    if((instate == FTP_LIST) && (ftpcode == 450)) {
2887      /* no matching files in the directory listing */
2888      ftp->transfer = PPTRANSFER_NONE; /* do not download anything */
2889      ftp_state(data, ftpc, FTP_STOP); /* this phase is over */
2890    }
2891    else {
2892      failf(data, "RETR response: %03d", ftpcode);
2893      return instate == FTP_RETR && ftpcode == 550 ?
2894        CURLE_REMOTE_FILE_NOT_FOUND :
2895        CURLE_FTP_COULDNT_RETR_FILE;
2896    }
2897  }
2898
2899  return result;
2900}
2901
2902/* after USER, PASS and ACCT */
2903static CURLcode ftp_state_loggedin(struct Curl_easy *data,
2904                                   struct ftp_conn *ftpc)
2905{
2906  CURLcode result = CURLE_OK;
2907
2908  if(Curl_conn_is_ssl(data->conn, FIRSTSOCKET)) {
2909    /* PBSZ = PROTECTION BUFFER SIZE.
2910
2911    The 'draft-murray-auth-ftp-ssl' (draft 12, page 7) says:
2912
2913    Specifically, the PROT command MUST be preceded by a PBSZ
2914    command and a PBSZ command MUST be preceded by a successful
2915    security data exchange (the TLS negotiation in this case)
2916
2917    ... (and on page 8):
2918
2919    Thus the PBSZ command must still be issued, but must have a
2920    parameter of '0' to indicate that no buffering is taking place
2921    and the data connection should not be encapsulated.
2922    */
2923    result = Curl_pp_sendf(data, &ftpc->pp, "PBSZ %d", 0);
2924    if(!result)
2925      ftp_state(data, ftpc, FTP_PBSZ);
2926  }
2927  else {
2928    result = ftp_state_pwd(data, ftpc);
2929  }
2930  return result;
2931}
2932
2933/* for USER and PASS responses */
2934static CURLcode ftp_state_user_resp(struct Curl_easy *data,
2935                                    struct ftp_conn *ftpc,
2936                                    int ftpcode)
2937{
2938  CURLcode result = CURLE_OK;
2939
2940  /* some need password anyway, and others return 2xx ignored */
2941  if((ftpcode == 331) && (ftpc->state == FTP_USER)) {
2942    /* 331 Password required for ...
2943       (the server requires to send the user's password too) */
2944    result = Curl_pp_sendf(data, &ftpc->pp, "PASS %s",
2945                           Curl_creds_passwd(data->conn->creds));
2946    if(!result)
2947      ftp_state(data, ftpc, FTP_PASS);
2948  }
2949  else if(ftpcode / 100 == 2) {
2950    /* 230 User ... logged in.
2951       (the user logged in with or without password) */
2952    result = ftp_state_loggedin(data, ftpc);
2953  }
2954  else if(ftpcode == 332) {
2955    if(data->set.str[STRING_FTP_ACCOUNT]) {
2956      result = Curl_pp_sendf(data, &ftpc->pp, "ACCT %s",
2957                             data->set.str[STRING_FTP_ACCOUNT]);
2958      if(!result)
2959        ftp_state(data, ftpc, FTP_ACCT);
2960    }
2961    else {
2962      failf(data, "ACCT requested but none available");
2963      result = CURLE_LOGIN_DENIED;
2964    }
2965  }
2966  else {
2967    /* All other response codes, like:
2968
2969    530 User ... access denied
2970    (the server denies to log the specified user) */
2971
2972    if(data->set.str[STRING_FTP_ALTERNATIVE_TO_USER] &&
2973       !ftpc->ftp_trying_alternative) {
2974      /* Ok, USER failed. Let's try the supplied command. */
2975      result = Curl_pp_sendf(data, &ftpc->pp, "%s",
2976                             data->set.str[STRING_FTP_ALTERNATIVE_TO_USER]);
2977      if(!result) {
2978        ftpc->ftp_trying_alternative = TRUE;
2979        ftp_state(data, ftpc, FTP_USER);
2980      }
2981    }
2982    else {
2983      failf(data, "Access denied: %03d", ftpcode);
2984      result = CURLE_LOGIN_DENIED;
2985    }
2986  }
2987  return result;
2988}
2989
2990/* for ACCT response */
2991static CURLcode ftp_state_acct_resp(struct Curl_easy *data,
2992                                    struct ftp_conn *ftpc,
2993                                    int ftpcode)
2994{
2995  CURLcode result = CURLE_OK;
2996  if(ftpcode != 230) {
2997    failf(data, "ACCT rejected by server: %03d", ftpcode);
2998    result = CURLE_FTP_WEIRD_PASS_REPLY; /* FIX */
2999  }
3000  else
3001    result = ftp_state_loggedin(data, ftpc);
3002
3003  return result;
3004}
3005
3006static CURLcode ftp_pwd_resp(struct Curl_easy *data,
3007                             struct ftp_conn *ftpc,
3008                             int ftpcode)
3009{
3010  struct pingpong *pp = &ftpc->pp;
3011  CURLcode result;
3012
3013  if(ftpcode == 257) {
3014    const char *ptr = curlx_dyn_ptr(&pp->recvbuf) + 4; /* start on the first
3015                                                          letter */
3016    bool entry_extracted = FALSE;
3017    struct dynbuf out;
3018    curlx_dyn_init(&out, 1000);
3019
3020    /* Reply format is like
3021       257<space>[rubbish]"<directory-name>"<space><commentary> and the
3022       RFC959 says
3023
3024       The directory name can contain any character; embedded
3025       double-quotes should be escaped by double-quotes (the
3026       "quote-doubling" convention).
3027    */
3028
3029    /* scan for the first double-quote for non-standard responses */
3030    while(*ptr != '\n' && *ptr != '\0' && *ptr != '"')
3031      ptr++;
3032
3033    if('\"' == *ptr) {
3034      /* it started good */
3035      for(ptr++; *ptr; ptr++) {
3036        if('\"' == *ptr) {
3037          if('\"' == ptr[1]) {
3038            /* "quote-doubling" */
3039            result = curlx_dyn_addn(&out, &ptr[1], 1);
3040            ptr++;
3041          }
3042          else {
3043            /* end of path */
3044            if(curlx_dyn_len(&out))
3045              entry_extracted = TRUE;
3046            break; /* get out of this loop */
3047          }
3048        }
3049        else {
3050          if(ISCNTRL(*ptr)) {
3051            /* control characters have no business in a path */
3052            curlx_dyn_free(&out);
3053            return CURLE_WEIRD_SERVER_REPLY;
3054          }
3055          result = curlx_dyn_addn(&out, ptr, 1);
3056        }
3057        if(result) {
3058          curlx_dyn_free(&out);
3059          return result;
3060        }
3061      }
3062    }
3063    if(entry_extracted) {
3064      /* If the path name does not look like an absolute path (i.e.: it
3065         does not start with a '/'), we probably need some server-dependent
3066         adjustments. For example, this is the case when connecting to
3067         an OS400 FTP server: this server supports two name syntaxes,
3068         the default one being incompatible with standard paths. In
3069         addition, this server switches automatically to the regular path
3070         syntax when one is encountered in a command: this results in
3071         having an entrypath in the wrong syntax when later used in CWD.
3072         The method used here is to check the server OS: we do it only
3073         if the path name looks strange to minimize overhead on other
3074         systems. */
3075      char *dir = curlx_dyn_ptr(&out);
3076
3077      if(!ftpc->server_os && dir[0] != '/') {
3078        result = Curl_pp_sendf(data, &ftpc->pp, "%s", "SYST");
3079        if(result) {
3080          curlx_dyn_free(&out);
3081          return result;
3082        }
3083      }
3084
3085      curlx_free(ftpc->entrypath);
3086      ftpc->entrypath = dir; /* remember this */
3087      infof(data, "Entry path is '%s'", ftpc->entrypath);
3088      /* also save it where getinfo can access it: */
3089      curlx_free(data->state.most_recent_ftp_entrypath);
3090      data->state.most_recent_ftp_entrypath = curlx_strdup(ftpc->entrypath);
3091      if(!data->state.most_recent_ftp_entrypath)
3092        return CURLE_OUT_OF_MEMORY;
3093
3094      if(!ftpc->server_os && dir[0] != '/') {
3095        ftp_state(data, ftpc, FTP_SYST);
3096        return CURLE_OK;
3097      }
3098    }
3099    else {
3100      /* could not get the path */
3101      curlx_dyn_free(&out);
3102      infof(data, "Failed to figure out path");
3103    }
3104  }
3105  ftp_state(data, ftpc, FTP_STOP); /* we are done with CONNECT phase! */
3106  CURL_TRC_FTP(data, "[%s] protocol connect phase DONE", FTP_CSTATE(ftpc));
3107  return CURLE_OK;
3108}
3109
3110static const char * const ftpauth[] = { "SSL", "TLS" };
3111
3112static CURLcode ftp_wait_resp(struct Curl_easy *data,
3113                              struct connectdata *conn,
3114                              struct ftp_conn *ftpc,
3115                              int ftpcode)
3116{
3117  CURLcode result = CURLE_OK;
3118  if(ftpcode == 230) {
3119    /* 230 User logged in - already! Take as 220 if TLS required. */
3120    if(data->set.use_ssl <= CURLUSESSL_TRY ||
3121       Curl_conn_is_ssl(conn, FIRSTSOCKET))
3122      return ftp_state_user_resp(data, ftpc, ftpcode);
3123  }
3124  else if(ftpcode != 220) {
3125    failf(data, "Got a %03d ftp-server response when 220 was expected",
3126          ftpcode);
3127    return CURLE_WEIRD_SERVER_REPLY;
3128  }
3129
3130  if(data->set.use_ssl && !Curl_conn_is_ssl(conn, FIRSTSOCKET)) {
3131    /* We do not have an SSL/TLS control connection yet, but FTPS is
3132       requested. Try an FTPS connection now */
3133
3134    ftpc->count3 = 0;
3135    switch((long)data->set.ftpsslauth) {
3136    case CURLFTPAUTH_DEFAULT:
3137    case CURLFTPAUTH_SSL:
3138      ftpc->count2 = 1; /* add one to get next */
3139      ftpc->count1 = 0;
3140      break;
3141    case CURLFTPAUTH_TLS:
3142      ftpc->count2 = -1; /* subtract one to get next */
3143      ftpc->count1 = 1;
3144      break;
3145    default:
3146      failf(data, "unsupported parameter to CURLOPT_FTPSSLAUTH: %d",
3147            (int)data->set.ftpsslauth);
3148      return CURLE_UNKNOWN_OPTION; /* we do not know what to do */
3149    }
3150    result = Curl_pp_sendf(data, &ftpc->pp, "AUTH %s", ftpauth[ftpc->count1]);
3151    if(!result)
3152      ftp_state(data, ftpc, FTP_AUTH);
3153  }
3154  else
3155    result = ftp_state_user(data, ftpc, conn);
3156  return result;
3157}
3158
3159static CURLcode ftp_pp_statemachine(struct Curl_easy *data,
3160                                    struct connectdata *conn)
3161{
3162  CURLcode result;
3163  int ftpcode;
3164  struct ftp_conn *ftpc = Curl_conn_meta_get(conn, CURL_META_FTP_CONN);
3165  struct FTP *ftp = Curl_meta_get(data, CURL_META_FTP_EASY);
3166  struct pingpong *pp;
3167  size_t nread = 0;
3168
3169  if(!ftpc || !ftp)
3170    return CURLE_FAILED_INIT;
3171  pp = &ftpc->pp;
3172  if(pp->sendleft)
3173    return Curl_pp_flushsend(data, pp);
3174
3175  result = ftp_readresp(data, ftpc, FIRSTSOCKET, pp, &ftpcode, &nread);
3176  if(result || !ftpcode)
3177    return result;
3178
3179  /* we have now received a full FTP server response */
3180  switch(ftpc->state) {
3181  case FTP_WAIT220:
3182    result = ftp_wait_resp(data, conn, ftpc, ftpcode);
3183    break;
3184
3185  case FTP_AUTH:
3186    /* we have gotten the response to a previous AUTH command */
3187
3188    if(pp->overflow)
3189      return CURLE_WEIRD_SERVER_REPLY; /* Forbid pipelining in response. */
3190
3191    /* RFC2228 (page 5) says:
3192     *
3193     * If the server is willing to accept the named security mechanism,
3194     * and does not require any security data, it must respond with
3195     * reply code 234/334.
3196     */
3197
3198    if((ftpcode == 234) || (ftpcode == 334)) {
3199      /* this was BLOCKING, keep it so for now */
3200      bool done;
3201      if(!Curl_conn_is_ssl(conn, FIRSTSOCKET)) {
3202        result = Curl_ssl_cfilter_add(data, conn, FIRSTSOCKET);
3203        if(result) {
3204          /* we failed and bail out */
3205          return CURLE_USE_SSL_FAILED;
3206        }
3207      }
3208      /* BLOCKING */
3209      result = Curl_conn_connect(data, FIRSTSOCKET, TRUE, &done);
3210      if(!result) {
3211        conn->bits.ftp_use_data_ssl = FALSE; /* clear-text data */
3212        result = ftp_state_user(data, ftpc, conn);
3213      }
3214    }
3215    else if(ftpc->count3 < 1) {
3216      ftpc->count3++;
3217      ftpc->count1 += ftpc->count2; /* get next attempt */
3218      result = Curl_pp_sendf(data, &ftpc->pp, "AUTH %s",
3219                             ftpauth[ftpc->count1]);
3220      /* remain in this same state */
3221    }
3222    else {
3223      if(data->set.use_ssl > CURLUSESSL_TRY)
3224        /* we failed and CURLUSESSL_CONTROL or CURLUSESSL_ALL is set */
3225        result = CURLE_USE_SSL_FAILED;
3226      else
3227        /* ignore the failure and continue */
3228        result = ftp_state_user(data, ftpc, conn);
3229    }
3230    break;
3231
3232  case FTP_USER:
3233  case FTP_PASS:
3234    result = ftp_state_user_resp(data, ftpc, ftpcode);
3235    break;
3236
3237  case FTP_ACCT:
3238    result = ftp_state_acct_resp(data, ftpc, ftpcode);
3239    break;
3240
3241  case FTP_PBSZ:
3242    result =
3243      Curl_pp_sendf(data, &ftpc->pp, "PROT %c",
3244                    data->set.use_ssl == CURLUSESSL_CONTROL ? 'C' : 'P');
3245    if(!result)
3246      ftp_state(data, ftpc, FTP_PROT);
3247    break;
3248
3249  case FTP_PROT:
3250    if(ftpcode / 100 == 2)
3251      /* We have enabled SSL for the data connection! */
3252      conn->bits.ftp_use_data_ssl = (data->set.use_ssl != CURLUSESSL_CONTROL);
3253    /* FTP servers typically responds with 500 if they decide to reject
3254       our 'P' request */
3255    else if(data->set.use_ssl > CURLUSESSL_CONTROL)
3256      /* we failed and bails out */
3257      return CURLE_USE_SSL_FAILED;
3258
3259    if(data->set.ftp_ccc) {
3260      /* CCC - Clear Command Channel
3261       */
3262      result = Curl_pp_sendf(data, &ftpc->pp, "%s", "CCC");
3263      if(!result)
3264        ftp_state(data, ftpc, FTP_CCC);
3265    }
3266    else
3267      result = ftp_state_pwd(data, ftpc);
3268    break;
3269
3270  case FTP_CCC:
3271    if(ftpcode < 500) {
3272      /* First shut down the SSL layer (note: this call will block) */
3273      /* This has only been tested on the proftpd server, and the mod_tls
3274       * code sends a close notify alert without waiting for a close notify
3275       * alert in response. Thus we wait for a close notify alert from the
3276       * server, but we do not send one. Let's hope other servers do
3277       * the same... */
3278      result = Curl_ssl_cfilter_remove(data, FIRSTSOCKET,
3279                                       (data->set.ftp_ccc ==
3280                                        (unsigned char)CURLFTPSSL_CCC_ACTIVE));
3281      if(result)
3282        failf(data, "Failed to clear the command channel (CCC)");
3283    }
3284    if(!result)
3285      /* Then continue as normal */
3286      result = ftp_state_pwd(data, ftpc);
3287    break;
3288
3289  case FTP_PWD:
3290    result = ftp_pwd_resp(data, ftpc, ftpcode);
3291    break;
3292
3293  case FTP_SYST:
3294    if(ftpcode == 215) {
3295      const char *ptr = curlx_dyn_ptr(&pp->recvbuf) + 4; /* start on the first
3296                                                            letter */
3297      const char *start;
3298      char *os;
3299
3300      /* Reply format is like
3301         215<space><OS-name><space><commentary>
3302      */
3303      while(*ptr == ' ')
3304        ptr++;
3305      for(start = ptr; *ptr && *ptr != ' '; ptr++)
3306        ;
3307      os = curlx_memdup0(start, ptr - start);
3308      if(!os)
3309        return CURLE_OUT_OF_MEMORY;
3310
3311      /* Check for special servers here. */
3312      if(curl_strequal(os, "OS/400")) {
3313        /* Force OS400 name format 1. */
3314        result = Curl_pp_sendf(data, &ftpc->pp, "%s", "SITE NAMEFMT 1");
3315        if(result) {
3316          curlx_free(os);
3317          return result;
3318        }
3319        /* remember target server OS */
3320        curlx_free(ftpc->server_os);
3321        ftpc->server_os = os;
3322        ftp_state(data, ftpc, FTP_NAMEFMT);
3323        break;
3324      }
3325      /* Nothing special for the target server. */
3326      /* remember target server OS */
3327      curlx_free(ftpc->server_os);
3328      ftpc->server_os = os;
3329    }
3330    else {
3331      /* Cannot identify server OS. Continue anyway and cross fingers. */
3332    }
3333
3334    ftp_state(data, ftpc, FTP_STOP); /* we are done with CONNECT phase! */
3335    CURL_TRC_FTP(data, "[%s] protocol connect phase DONE", FTP_CSTATE(ftpc));
3336    break;
3337
3338  case FTP_NAMEFMT:
3339    if(ftpcode == 250) {
3340      /* Name format change successful: reload initial path. */
3341      ftp_state_pwd(data, ftpc);
3342      break;
3343    }
3344
3345    ftp_state(data, ftpc, FTP_STOP); /* we are done with CONNECT phase! */
3346    CURL_TRC_FTP(data, "[%s] protocol connect phase DONE", FTP_CSTATE(ftpc));
3347    break;
3348
3349  case FTP_QUOTE:
3350  case FTP_POSTQUOTE:
3351  case FTP_RETR_PREQUOTE:
3352  case FTP_STOR_PREQUOTE:
3353  case FTP_LIST_PREQUOTE:
3354    if((ftpcode >= 400) && !ftpc->count2) {
3355      /* failure response code, and not allowed to fail */
3356      failf(data, "QUOT command failed with %03d", ftpcode);
3357      result = CURLE_QUOTE_ERROR;
3358    }
3359    else
3360      result = ftp_state_quote(data, ftpc, ftp, FALSE, ftpc->state);
3361    break;
3362
3363  case FTP_CWD:
3364    if(ftpcode / 100 != 2) {
3365      /* failure to CWD there */
3366      if(data->set.ftp_create_missing_dirs &&
3367         ftpc->cwdcount && !ftpc->count2) {
3368        /* try making it */
3369        ftpc->count2++; /* counter to prevent CWD-MKD loops */
3370
3371        /* count3 is set to allow MKD to fail once per dir. In the case when
3372           CWD fails and then MKD fails (due to another session raced it to
3373           create the dir) this then allows for a second try to CWD to it. */
3374        ftpc->count3 = (data->set.ftp_create_missing_dirs == 2) ? 1 : 0;
3375
3376        result = Curl_pp_sendf(data, &ftpc->pp, "MKD %.*s",
3377                               pathlen(ftpc, ftpc->cwdcount - 1),
3378                               pathpiece(ftpc, ftpc->cwdcount - 1));
3379        if(!result)
3380          ftp_state(data, ftpc, FTP_MKD);
3381      }
3382      else {
3383        /* return failure */
3384        failf(data, "Server denied you to change to the given directory");
3385        ftpc->cwdfail = TRUE; /* do not remember this path as we failed
3386                                 to enter it */
3387        result = CURLE_REMOTE_ACCESS_DENIED;
3388      }
3389    }
3390    else {
3391      /* success */
3392      ftpc->count2 = 0;
3393      if(ftpc->cwdcount >= ftpc->dirdepth)
3394        result = ftp_state_mdtm(data, ftpc, ftp);
3395      else {
3396        ftpc->cwdcount++;
3397        /* send next CWD */
3398        result = Curl_pp_sendf(data, &ftpc->pp, "CWD %.*s",
3399                               pathlen(ftpc, ftpc->cwdcount - 1),
3400                               pathpiece(ftpc, ftpc->cwdcount - 1));
3401      }
3402    }
3403    break;
3404
3405  case FTP_MKD:
3406    if((ftpcode / 100 != 2) && !ftpc->count3--) {
3407      /* failure to MKD the directory */
3408      failf(data, "Failed to MKD dir: %03d", ftpcode);
3409      result = CURLE_REMOTE_ACCESS_DENIED;
3410    }
3411    else {
3412      ftp_state(data, ftpc, FTP_CWD);
3413      /* send CWD */
3414      result = Curl_pp_sendf(data, &ftpc->pp, "CWD %.*s",
3415                             pathlen(ftpc, ftpc->cwdcount - 1),
3416                             pathpiece(ftpc, ftpc->cwdcount - 1));
3417    }
3418    break;
3419
3420  case FTP_MDTM:
3421    result = ftp_state_mdtm_resp(data, ftpc, ftp, ftpcode);
3422    break;
3423
3424  case FTP_TYPE:
3425  case FTP_LIST_TYPE:
3426  case FTP_RETR_TYPE:
3427  case FTP_STOR_TYPE:
3428  case FTP_RETR_LIST_TYPE:
3429    result = ftp_state_type_resp(data, ftpc, ftp, ftpcode, ftpc->state);
3430    break;
3431
3432  case FTP_SIZE:
3433  case FTP_RETR_SIZE:
3434  case FTP_STOR_SIZE:
3435    result = ftp_state_size_resp(data, ftpc, ftp, ftpcode, ftpc->state);
3436    break;
3437
3438  case FTP_REST:
3439  case FTP_RETR_REST:
3440    result = ftp_state_rest_resp(data, ftpc, ftp, ftpcode, ftpc->state);
3441    break;
3442
3443  case FTP_PRET:
3444    if(ftpcode != 200) {
3445      /* there only is this one standard OK return code. */
3446      failf(data, "PRET command not accepted: %03d", ftpcode);
3447      return CURLE_FTP_PRET_FAILED;
3448    }
3449    result = ftp_state_use_pasv(data, ftpc, conn);
3450    break;
3451
3452  case FTP_PASV:
3453    result = ftp_state_pasv_resp(data, ftpc, ftpcode);
3454    break;
3455
3456  case FTP_PORT:
3457    result = ftp_state_port_resp(data, ftpc, ftp, ftpcode);
3458    break;
3459
3460  case FTP_LIST:
3461  case FTP_RETR:
3462    result = ftp_state_get_resp(data, ftpc, ftp, ftpcode, ftpc->state);
3463    break;
3464
3465  case FTP_STOR:
3466    result = ftp_state_stor_resp(data, ftpc, ftpcode);
3467    break;
3468
3469  case FTP_QUIT:
3470  default:
3471    /* internal error */
3472    ftp_state(data, ftpc, FTP_STOP);
3473    break;
3474  }
3475
3476  return result;
3477}
3478
3479/* called repeatedly until done from multi.c */
3480static CURLcode ftp_multi_statemach(struct Curl_easy *data,
3481                                    bool *done)
3482{
3483  struct ftp_conn *ftpc = Curl_conn_meta_get(data->conn, CURL_META_FTP_CONN);
3484  return ftpc ? ftp_statemach(data, ftpc, done) : CURLE_FAILED_INIT;
3485}
3486
3487static CURLcode ftp_block_statemach(struct Curl_easy *data,
3488                                    struct ftp_conn *ftpc)
3489{
3490  struct pingpong *pp = &ftpc->pp;
3491  CURLcode result = CURLE_OK;
3492
3493  while(ftpc->state != FTP_STOP) {
3494    if(ftpc->shutdown)
3495      CURL_TRC_FTP(data, "in shutdown, waiting for server response");
3496    result = Curl_pp_statemach(data, pp, TRUE, TRUE /* disconnecting */);
3497    if(result)
3498      break;
3499  }
3500
3501  return result;
3502}
3503
3504/*
3505 * ftp_connect() should do everything that is to be considered a part of
3506 * the connection phase.
3507 *
3508 * The variable 'done' points to will be TRUE if the protocol-layer connect
3509 * phase is done when this function returns, or FALSE if not.
3510 *
3511 */
3512static CURLcode ftp_connect(struct Curl_easy *data,
3513                            bool *done) /* see description above */
3514{
3515  CURLcode result;
3516  struct connectdata *conn = data->conn;
3517  struct ftp_conn *ftpc = Curl_conn_meta_get(data->conn, CURL_META_FTP_CONN);
3518  struct pingpong *pp;
3519
3520  *done = FALSE; /* default to not done yet */
3521  if(!ftpc)
3522    return CURLE_FAILED_INIT;
3523  pp = &ftpc->pp;
3524  PINGPONG_SETUP(pp, ftp_pp_statemachine, ftp_endofresp);
3525
3526  if(Curl_conn_is_ssl(conn, FIRSTSOCKET)) {
3527    /* BLOCKING */
3528    result = Curl_conn_connect(data, FIRSTSOCKET, TRUE, done);
3529    if(result)
3530      return result;
3531  }
3532
3533  Curl_pp_init(pp, Curl_pgrs_now(data)); /* once per transfer */
3534
3535  /* When we connect, we start in the state where we await the 220
3536     response */
3537  ftp_state(data, ftpc, FTP_WAIT220);
3538
3539  result = ftp_statemach(data, ftpc, done);
3540
3541  return result;
3542}
3543
3544/***********************************************************************
3545 *
3546 * ftp_sendquote()
3547 *
3548 * Where a 'quote' means a list of custom commands to send to the server.
3549 * The quote list is passed as an argument.
3550 *
3551 * BLOCKING
3552 */
3553static CURLcode ftp_sendquote(struct Curl_easy *data,
3554                              struct ftp_conn *ftpc,
3555                              struct curl_slist *quote)
3556{
3557  struct curl_slist *item;
3558  struct pingpong *pp = &ftpc->pp;
3559
3560  item = quote;
3561  while(item) {
3562    if(item->data) {
3563      size_t nread;
3564      const char *cmd = item->data;
3565      bool acceptfail = FALSE;
3566      CURLcode result;
3567      int ftpcode = 0;
3568
3569      /* if a command starts with an asterisk, which a legal FTP command never
3570         can, the command will be allowed to fail without it causing any
3571         aborts or cancels etc. It will cause libcurl to act as if the command
3572         is successful, whatever the server responds. */
3573
3574      if(cmd[0] == '*') {
3575        cmd++;
3576        acceptfail = TRUE;
3577      }
3578
3579      result = Curl_pp_sendf(data, &ftpc->pp, "%s", cmd);
3580      if(!result) {
3581        pp->response = *Curl_pgrs_now(data); /* timeout relative now */
3582        result = getftpresponse(data, &nread, &ftpcode);
3583      }
3584      if(result)
3585        return result;
3586
3587      if(!acceptfail && (ftpcode >= 400)) {
3588        failf(data, "QUOT string not accepted: %s", cmd);
3589        return CURLE_QUOTE_ERROR;
3590      }
3591    }
3592
3593    item = item->next;
3594  }
3595
3596  return CURLE_OK;
3597}
3598
3599static CURLcode ftp_done_status(struct connectdata *conn,
3600                                struct ftp_conn *ftpc, CURLcode status,
3601                                bool premature)
3602{
3603  switch(status) {
3604  case CURLE_BAD_DOWNLOAD_RESUME:
3605  case CURLE_FTP_WEIRD_PASV_REPLY:
3606  case CURLE_FTP_PORT_FAILED:
3607  case CURLE_FTP_ACCEPT_FAILED:
3608  case CURLE_FTP_ACCEPT_TIMEOUT:
3609  case CURLE_FTP_COULDNT_SET_TYPE:
3610  case CURLE_FTP_COULDNT_RETR_FILE:
3611  case CURLE_PARTIAL_FILE:
3612  case CURLE_UPLOAD_FAILED:
3613  case CURLE_REMOTE_ACCESS_DENIED:
3614  case CURLE_FILESIZE_EXCEEDED:
3615  case CURLE_REMOTE_FILE_NOT_FOUND:
3616  case CURLE_WRITE_ERROR:
3617    /* the connection stays alive fine even though this happened */
3618  case CURLE_OK: /* does not affect the control connection's status */
3619    if(!premature)
3620      break;
3621
3622    /* until we cope better with prematurely ended requests, let them
3623     * fallback as if in complete failure */
3624    FALLTHROUGH();
3625  default:       /* by default, an error means the control connection is
3626                    wedged and should not be used anymore */
3627    ftpc->ctl_valid = FALSE;
3628    ftpc->cwdfail = TRUE; /* set this TRUE to prevent us to remember the
3629                             current path, as this connection is going */
3630    connclose(conn, "FTP ended with bad error code");
3631    return status;      /* use the already set error code */
3632  }
3633  return CURLE_OK;
3634}
3635
3636static void ftp_done_wildcard(struct Curl_easy *data, struct ftp_conn *ftpc)
3637{
3638  if(data->state.wildcardmatch) {
3639    if(data->set.chunk_end && ftpc->file) {
3640      Curl_set_in_callback(data, TRUE);
3641      data->set.chunk_end(data->set.wildcardptr);
3642      Curl_set_in_callback(data, FALSE);
3643      freedirs(ftpc);
3644    }
3645    ftpc->known_filesize = -1;
3646  }
3647}
3648
3649static void ftp_done_path(struct Curl_easy *data, struct ftp_conn *ftpc,
3650                          CURLcode result)
3651{
3652  struct connectdata *conn = data->conn;
3653  if(result) {
3654    /* We can limp along anyway (and should try to since we may already be in
3655     * the error path) */
3656    ftpc->ctl_valid = FALSE; /* mark control connection as bad */
3657    connclose(conn, "FTP: out of memory!"); /* mark for connection closure */
3658    curlx_free(ftpc->prevpath);
3659    ftpc->prevpath = NULL; /* no path remembering */
3660  }
3661  else { /* remember working directory for connection reuse */
3662    const char *rawPath = ftpc->rawpath;
3663    if(rawPath) {
3664      if((data->set.ftp_filemethod == FTPFILE_NOCWD) && (rawPath[0] == '/'))
3665        ; /* full path => no CWDs happened => keep ftpc->prevpath */
3666      else {
3667        size_t pathLen = strlen(ftpc->rawpath);
3668
3669        curlx_free(ftpc->prevpath);
3670
3671        if(!ftpc->cwdfail) {
3672          if(data->set.ftp_filemethod == FTPFILE_NOCWD)
3673            pathLen = 0; /* relative path => working directory is FTP home */
3674          else
3675            /* file is URL-decoded */
3676            pathLen -= ftpc->file ? strlen(ftpc->file) : 0;
3677          ftpc->prevpath = curlx_memdup0(rawPath, pathLen);
3678        }
3679        else
3680          ftpc->prevpath = NULL; /* no path */
3681      }
3682    }
3683    if(ftpc->prevpath)
3684      infof(data, "Remembering we are in directory \"%s\"", ftpc->prevpath);
3685  }
3686}
3687
3688static CURLcode ftp_done_secondary_socket(struct Curl_easy *data,
3689                                          struct ftp_conn *ftpc,
3690                                          CURLcode result)
3691{
3692  struct connectdata *conn = data->conn;
3693  if(Curl_conn_is_setup(conn, SECONDARYSOCKET)) {
3694    if(!result && ftpc->dont_check && data->req.maxdownload > 0) {
3695      /* partial download completed */
3696      result = Curl_pp_sendf(data, &ftpc->pp, "%s", "ABOR");
3697      if(result) {
3698        failf(data, "Failure sending ABOR command: %s",
3699              curl_easy_strerror(result));
3700        ftpc->ctl_valid = FALSE; /* mark control connection as bad */
3701        connclose(conn, "ABOR command failed"); /* connection closure */
3702      }
3703    }
3704
3705    close_secondarysocket(data, ftpc);
3706  }
3707  return result;
3708}
3709
3710static CURLcode ftp_done_control_reply(struct Curl_easy *data,
3711                                       struct ftp_conn *ftpc,
3712                                       struct FTP *ftp, CURLcode result,
3713                                       bool premature)
3714{
3715  struct connectdata *conn = data->conn;
3716  size_t nread;
3717  int ftpcode;
3718
3719  if(!result && (ftp->transfer == PPTRANSFER_BODY) && ftpc->ctl_valid &&
3720     ftpc->pp.pending_resp && !premature) {
3721    /*
3722     * Let's see what the server says about the transfer we performed, but
3723     * lower the timeout as sometimes this connection has died while the data
3724     * has been transferred. This happens when doing through NATs etc that
3725     * abandon old silent connections.
3726     */
3727    ftpc->pp.response = *Curl_pgrs_now(data); /* timeout relative now */
3728    result = getftpresponse(data, &nread, &ftpcode);
3729
3730    if(!nread && (result == CURLE_OPERATION_TIMEDOUT)) {
3731      failf(data, "control connection looks dead");
3732      ftpc->ctl_valid = FALSE; /* mark control connection as bad */
3733      connclose(conn, "Timeout or similar in FTP DONE operation"); /* close */
3734    }
3735
3736    if(result)
3737      return result;
3738
3739    if(ftpc->dont_check && data->req.maxdownload > 0) {
3740      /* we have sent ABOR and there is no reliable way to check if it was
3741       * successful or not; we have to close the connection now */
3742      infof(data, "partial download completed, closing connection");
3743      connclose(conn, "Partial download with no ability to check");
3744      return result;
3745    }
3746
3747    if(!ftpc->dont_check) {
3748      /* 226 Transfer complete, 250 Requested file action okay, completed. */
3749      switch(ftpcode) {
3750      case 226:
3751      case 250:
3752        break;
3753      case 552:
3754        failf(data, "Exceeded storage allocation");
3755        result = CURLE_REMOTE_DISK_FULL;
3756        break;
3757      default:
3758        failf(data, "server did not report OK, got %d", ftpcode);
3759        result = CURLE_PARTIAL_FILE;
3760        break;
3761      }
3762    }
3763  }
3764  return result;
3765}
3766
3767static CURLcode ftp_done_check_partial(struct Curl_easy *data,
3768                                       struct ftp_conn *ftpc,
3769                                       struct FTP *ftp, CURLcode result,
3770                                       bool premature)
3771{
3772  if(result || premature)
3773    /* the response code from the transfer showed an error already so no
3774       use checking further */
3775    ;
3776  else if(data->state.upload) {
3777    if((ftp->transfer == PPTRANSFER_BODY) &&
3778       (data->state.infilesize != -1) && /* upload with known size */
3779       ((!data->set.crlf && !data->state.prefer_ascii && /* no conversion */
3780         (data->state.infilesize != data->req.writebytecount)) ||
3781        ((data->set.crlf || data->state.prefer_ascii) && /* maybe crlf conv */
3782         (data->state.infilesize > data->req.writebytecount))
3783       )) {
3784      failf(data, "Uploaded unaligned file size (%" FMT_OFF_T
3785            " out of %" FMT_OFF_T " bytes)",
3786            data->req.writebytecount, data->state.infilesize);
3787      result = CURLE_PARTIAL_FILE;
3788    }
3789  }
3790  else {
3791    if((data->req.size != -1) &&
3792       (data->req.size != data->req.bytecount) &&
3793       (data->req.maxdownload != data->req.bytecount)) {
3794      failf(data, "Received only partial file: %" FMT_OFF_T " bytes",
3795            data->req.bytecount);
3796      result = CURLE_PARTIAL_FILE;
3797    }
3798    else if(!ftpc->dont_check &&
3799            !data->req.bytecount &&
3800            (data->req.size > 0)) {
3801      failf(data, "No data was received");
3802      result = CURLE_FTP_COULDNT_RETR_FILE;
3803    }
3804  }
3805  return result;
3806}
3807
3808/***********************************************************************
3809 *
3810 * ftp_done()
3811 *
3812 * The DONE function. This does what needs to be done after a single DO has
3813 * performed.
3814 *
3815 * Input argument is already checked for validity.
3816 */
3817static CURLcode ftp_done(struct Curl_easy *data, CURLcode status,
3818                         bool premature)
3819{
3820  struct FTP *ftp = Curl_meta_get(data, CURL_META_FTP_EASY);
3821  struct ftp_conn *ftpc = Curl_conn_meta_get(data->conn, CURL_META_FTP_CONN);
3822  CURLcode result;
3823
3824  if(!ftp || !ftpc)
3825    return CURLE_OK;
3826
3827  result = ftp_done_status(data->conn, ftpc, status, premature);
3828
3829  ftp_done_wildcard(data, ftpc);
3830  ftp_done_path(data, ftpc, result);
3831  result = ftp_done_secondary_socket(data, ftpc, result);
3832  result = ftp_done_control_reply(data, ftpc, ftp, result, premature);
3833  result = ftp_done_check_partial(data, ftpc, ftp, result, premature);
3834
3835  /* clear these for next connection */
3836  ftp->transfer = PPTRANSFER_BODY;
3837  ftpc->dont_check = FALSE;
3838
3839  /* Send any post-transfer QUOTE strings? */
3840  if(!status && !result && !premature && data->set.postquote)
3841    result = ftp_sendquote(data, ftpc, data->set.postquote);
3842  CURL_TRC_FTP(data, "[%s] done, result=%d", FTP_CSTATE(ftpc), result);
3843  return result;
3844}
3845
3846/***********************************************************************
3847 *
3848 * ftp_nb_type()
3849 *
3850 * Set TYPE. We only deal with ASCII or BINARY so this function
3851 * sets one of them.
3852 * If the transfer type is not sent, simulate on OK response in newstate
3853 */
3854static CURLcode ftp_nb_type(struct Curl_easy *data,
3855                            struct ftp_conn *ftpc,
3856                            struct FTP *ftp,
3857                            bool ascii, ftpstate newstate)
3858{
3859  CURLcode result;
3860  char want = (char)(ascii ? 'A' : 'I');
3861
3862  if(ftpc->transfertype == want) {
3863    ftp_state(data, ftpc, newstate);
3864    return ftp_state_type_resp(data, ftpc, ftp, 200, newstate);
3865  }
3866
3867  result = Curl_pp_sendf(data, &ftpc->pp, "TYPE %c", want);
3868  if(!result) {
3869    ftp_state(data, ftpc, newstate);
3870
3871    /* keep track of our current transfer type */
3872    ftpc->transfertype = want;
3873  }
3874  return result;
3875}
3876
3877/***********************************************************************
3878 *
3879 * ftp_perform()
3880 *
3881 * This is the actual DO function for FTP. Get a file/directory according to
3882 * the options previously setup.
3883 */
3884static CURLcode ftp_perform(
3885  struct Curl_easy *data,
3886  struct ftp_conn *ftpc,
3887  struct FTP *ftp,
3888  bool *connected,  /* connect status after PASV / PORT */
3889  bool *dophase_done)
3890{
3891  /* this is FTP and no proxy */
3892  CURLcode result = CURLE_OK;
3893
3894  CURL_TRC_FTP(data, "[%s] DO phase starts", FTP_CSTATE(ftpc));
3895
3896  if(data->req.no_body) {
3897    /* requested no body means no transfer... */
3898    ftp->transfer = PPTRANSFER_INFO;
3899  }
3900
3901  *dophase_done = FALSE; /* not done yet */
3902
3903  /* start the first command in the DO phase */
3904  result = ftp_state_quote(data, ftpc, ftp, TRUE, FTP_QUOTE);
3905  if(result)
3906    return result;
3907
3908  /* run the state-machine */
3909  result = ftp_statemach(data, ftpc, dophase_done);
3910
3911  *connected = Curl_conn_is_connected(data->conn, SECONDARYSOCKET);
3912
3913  if(*connected)
3914    infof(data, "[FTP] [%s] perform, DATA connection established",
3915          FTP_CSTATE(ftpc));
3916  else
3917    CURL_TRC_FTP(data, "[%s] perform, awaiting DATA connect",
3918                 FTP_CSTATE(ftpc));
3919
3920  if(*dophase_done)
3921    CURL_TRC_FTP(data, "[%s] DO phase is complete1", FTP_CSTATE(ftpc));
3922
3923  return result;
3924}
3925
3926static void wc_data_dtor(void *ptr)
3927{
3928  struct ftp_wc *ftpwc = ptr;
3929  if(ftpwc && ftpwc->parser)
3930    Curl_ftp_parselist_data_free(&ftpwc->parser);
3931  curlx_free(ftpwc);
3932}
3933
3934static CURLcode init_wc_data(struct Curl_easy *data,
3935                             struct ftp_conn *ftpc,
3936                             struct FTP *ftp)
3937{
3938  char *last_slash;
3939  char *path = ftp->path;
3940  struct WildcardData *wildcard = data->wildcard;
3941  CURLcode result = CURLE_OK;
3942  struct ftp_wc *ftpwc = NULL;
3943
3944  last_slash = strrchr(ftp->path, '/');
3945  if(last_slash) {
3946    last_slash++;
3947    if(last_slash[0] == '\0') {
3948      wildcard->state = CURLWC_CLEAN;
3949      return ftp_parse_url_path(data, ftpc, ftp);
3950    }
3951    wildcard->pattern = curlx_strdup(last_slash);
3952    if(!wildcard->pattern)
3953      return CURLE_OUT_OF_MEMORY;
3954    last_slash[0] = '\0'; /* cut file from path */
3955  }
3956  else { /* there is only 'wildcard pattern' or nothing */
3957    if(path[0]) {
3958      wildcard->pattern = curlx_strdup(path);
3959      if(!wildcard->pattern)
3960        return CURLE_OUT_OF_MEMORY;
3961      path[0] = '\0';
3962    }
3963    else { /* only list */
3964      wildcard->state = CURLWC_CLEAN;
3965      return ftp_parse_url_path(data, ftpc, ftp);
3966    }
3967  }
3968
3969  /* program continues only if URL is not ending with slash, allocate needed
3970     resources for wildcard transfer */
3971
3972  /* allocate ftp protocol specific wildcard data */
3973  ftpwc = curlx_calloc(1, sizeof(struct ftp_wc));
3974  if(!ftpwc) {
3975    result = CURLE_OUT_OF_MEMORY;
3976    goto fail;
3977  }
3978
3979  /* INITIALIZE parselist structure */
3980  ftpwc->parser = Curl_ftp_parselist_data_alloc();
3981  if(!ftpwc->parser) {
3982    result = CURLE_OUT_OF_MEMORY;
3983    goto fail;
3984  }
3985
3986  wildcard->ftpwc = ftpwc; /* put it to the WildcardData tmp pointer */
3987  wildcard->dtor = wc_data_dtor;
3988
3989  /* wildcard does not support NOCWD option (assert it?) */
3990  if(data->set.ftp_filemethod == FTPFILE_NOCWD)
3991    data->set.ftp_filemethod = FTPFILE_MULTICWD;
3992
3993  /* try to parse ftp URL */
3994  result = ftp_parse_url_path(data, ftpc, ftp);
3995  if(result) {
3996    goto fail;
3997  }
3998
3999  wildcard->path = curlx_strdup(ftp->path);
4000  if(!wildcard->path) {
4001    result = CURLE_OUT_OF_MEMORY;
4002    goto fail;
4003  }
4004
4005  /* backup old write_function */
4006  ftpwc->backup.write_function = data->set.fwrite_func;
4007  /* parsing write function */
4008  data->set.fwrite_func = Curl_ftp_parselist;
4009  /* backup old file descriptor */
4010  ftpwc->backup.file_descriptor = data->set.out;
4011  /* let the writefunc callback know the transfer */
4012  data->set.out = data;
4013
4014  infof(data, "Wildcard - Parsing started");
4015  return CURLE_OK;
4016
4017fail:
4018  if(ftpwc) {
4019    Curl_ftp_parselist_data_free(&ftpwc->parser);
4020    curlx_free(ftpwc);
4021  }
4022  curlx_safefree(wildcard->pattern);
4023  wildcard->dtor = ZERO_NULL;
4024  wildcard->ftpwc = NULL;
4025  return result;
4026}
4027
4028static CURLcode wc_statemach(struct Curl_easy *data,
4029                             struct ftp_conn *ftpc,
4030                             struct FTP *ftp)
4031{
4032  struct WildcardData * const wildcard = data->wildcard;
4033  CURLcode result = CURLE_OK;
4034
4035  for(;;) {
4036    switch(wildcard->state) {
4037    case CURLWC_INIT:
4038      result = init_wc_data(data, ftpc, ftp);
4039      if(wildcard->state == CURLWC_CLEAN)
4040        /* only listing! */
4041        return result;
4042      wildcard->state = result ? CURLWC_ERROR : CURLWC_MATCHING;
4043      return result;
4044
4045    case CURLWC_MATCHING: {
4046      /* In this state is LIST response successfully parsed, so lets restore
4047         previous WRITEFUNCTION callback and WRITEDATA pointer */
4048      struct ftp_wc *ftpwc = wildcard->ftpwc;
4049      data->set.fwrite_func = ftpwc->backup.write_function;
4050      data->set.out = ftpwc->backup.file_descriptor;
4051      ftpwc->backup.write_function = ZERO_NULL;
4052      ftpwc->backup.file_descriptor = NULL;
4053      wildcard->state = CURLWC_DOWNLOADING;
4054
4055      if(Curl_ftp_parselist_geterror(ftpwc->parser)) {
4056        /* error found in LIST parsing */
4057        wildcard->state = CURLWC_CLEAN;
4058        continue;
4059      }
4060      if(Curl_llist_count(&wildcard->filelist) == 0) {
4061        /* no corresponding file */
4062        wildcard->state = CURLWC_CLEAN;
4063        return CURLE_REMOTE_FILE_NOT_FOUND;
4064      }
4065      continue;
4066    }
4067
4068    case CURLWC_DOWNLOADING: {
4069      /* filelist has at least one file, lets get first one */
4070      struct Curl_llist_node *head = Curl_llist_head(&wildcard->filelist);
4071      struct curl_fileinfo *finfo = Curl_node_elem(head);
4072
4073      char *tmp_path = curl_maprintf("%s%s", wildcard->path, finfo->filename);
4074      if(!tmp_path)
4075        return CURLE_OUT_OF_MEMORY;
4076
4077      /* switch default ftp->path and tmp_path */
4078      curlx_free(ftp->pathalloc);
4079      ftp->pathalloc = ftp->path = tmp_path;
4080
4081      infof(data, "Wildcard - START of \"%s\"", finfo->filename);
4082      if(data->set.chunk_bgn) {
4083        long userresponse;
4084        Curl_set_in_callback(data, TRUE);
4085        userresponse = data->set.chunk_bgn(
4086          finfo, data->set.wildcardptr,
4087          (int)Curl_llist_count(&wildcard->filelist));
4088        Curl_set_in_callback(data, FALSE);
4089        switch(userresponse) {
4090        case CURL_CHUNK_BGN_FUNC_SKIP:
4091          infof(data, "Wildcard - \"%s\" skipped by user", finfo->filename);
4092          wildcard->state = CURLWC_SKIP;
4093          continue;
4094        case CURL_CHUNK_BGN_FUNC_FAIL:
4095          return CURLE_CHUNK_FAILED;
4096        }
4097      }
4098
4099      if(finfo->filetype != CURLFILETYPE_FILE) {
4100        wildcard->state = CURLWC_SKIP;
4101        continue;
4102      }
4103
4104      if(finfo->flags & CURLFINFOFLAG_KNOWN_SIZE)
4105        ftpc->known_filesize = finfo->size;
4106
4107      result = ftp_parse_url_path(data, ftpc, ftp);
4108      if(result)
4109        return result;
4110
4111      /* we do not need the Curl_fileinfo of first file anymore */
4112      Curl_node_remove(Curl_llist_head(&wildcard->filelist));
4113
4114      if(Curl_llist_count(&wildcard->filelist) == 0) {
4115        /* remains only one file to down. */
4116        wildcard->state = CURLWC_CLEAN;
4117        /* after that will be ftp_do called once again and no transfer
4118           will be done because of CURLWC_CLEAN state */
4119        return CURLE_OK;
4120      }
4121      return result;
4122    }
4123
4124    case CURLWC_SKIP: {
4125      if(data->set.chunk_end) {
4126        Curl_set_in_callback(data, TRUE);
4127        data->set.chunk_end(data->set.wildcardptr);
4128        Curl_set_in_callback(data, FALSE);
4129      }
4130      Curl_node_remove(Curl_llist_head(&wildcard->filelist));
4131      wildcard->state = (Curl_llist_count(&wildcard->filelist) == 0) ?
4132        CURLWC_CLEAN : CURLWC_DOWNLOADING;
4133      continue;
4134    }
4135
4136    case CURLWC_CLEAN: {
4137      struct ftp_wc *ftpwc = wildcard->ftpwc;
4138      result = CURLE_OK;
4139      if(ftpwc)
4140        result = Curl_ftp_parselist_geterror(ftpwc->parser);
4141
4142      wildcard->state = result ? CURLWC_ERROR : CURLWC_DONE;
4143      return result;
4144    }
4145
4146    case CURLWC_DONE:
4147    case CURLWC_ERROR:
4148    case CURLWC_CLEAR:
4149      if(wildcard->dtor) {
4150        wildcard->dtor(wildcard->ftpwc);
4151        wildcard->ftpwc = NULL;
4152      }
4153      return result;
4154    }
4155  }
4156  /* UNREACHABLE */
4157}
4158
4159/***********************************************************************
4160 *
4161 * ftp_regular_transfer()
4162 *
4163 * The input argument is already checked for validity.
4164 *
4165 * Performs all commands done before a regular transfer between a local and a
4166 * remote host.
4167 *
4168 * ftp->ctl_valid starts out as FALSE, and gets set to TRUE if we reach the
4169 * ftp_done() function without finding any major problem.
4170 */
4171static CURLcode ftp_regular_transfer(struct Curl_easy *data,
4172                                     struct ftp_conn *ftpc,
4173                                     struct FTP *ftp,
4174                                     bool *dophase_done)
4175{
4176  CURLcode result = CURLE_OK;
4177  bool connected = FALSE;
4178  data->req.size = -1; /* make sure this is unknown at this point */
4179
4180  Curl_pgrsReset(data);
4181
4182  ftpc->ctl_valid = TRUE; /* starts good */
4183
4184  result = ftp_perform(data, ftpc, ftp,
4185                       &connected, /* have we connected after PASV/PORT */
4186                       dophase_done); /* all commands in the DO-phase done? */
4187
4188  if(!result) {
4189
4190    if(!*dophase_done)
4191      /* the DO phase has not completed yet */
4192      return CURLE_OK;
4193
4194    result = ftp_dophase_done(data, ftpc, ftp, connected);
4195
4196    if(result)
4197      return result;
4198  }
4199  else
4200    freedirs(ftpc);
4201
4202  return result;
4203}
4204
4205/***********************************************************************
4206 *
4207 * ftp_do()
4208 *
4209 * This function is registered as 'curl_do' function. It decodes the path
4210 * parts etc as a wrapper to the actual DO function (ftp_perform).
4211 *
4212 * The input argument is already checked for validity.
4213 */
4214static CURLcode ftp_do(struct Curl_easy *data, bool *done)
4215{
4216  CURLcode result = CURLE_OK;
4217  struct ftp_conn *ftpc = Curl_conn_meta_get(data->conn, CURL_META_FTP_CONN);
4218  struct FTP *ftp = Curl_meta_get(data, CURL_META_FTP_EASY);
4219
4220  *done = FALSE; /* default to false */
4221  if(!ftpc || !ftp)
4222    return CURLE_FAILED_INIT;
4223  ftpc->wait_data_conn = FALSE; /* default to no such wait */
4224
4225#ifdef CURL_PREFER_LF_LINEENDS
4226  {
4227    /* FTP data may need conversion. */
4228    struct Curl_cwriter *ftp_lc_writer;
4229
4230    result = Curl_cwriter_create(&ftp_lc_writer, data, &ftp_cw_lc,
4231                                 CURL_CW_CONTENT_DECODE);
4232    if(result)
4233      return result;
4234
4235    result = Curl_cwriter_add(data, ftp_lc_writer);
4236    if(result) {
4237      Curl_cwriter_free(data, ftp_lc_writer);
4238      return result;
4239    }
4240  }
4241#endif /* CURL_PREFER_LF_LINEENDS */
4242
4243  if(data->state.wildcardmatch) {
4244    result = wc_statemach(data, ftpc, ftp);
4245    if(data->wildcard->state == CURLWC_SKIP ||
4246       data->wildcard->state == CURLWC_DONE) {
4247      /* do not call ftp_regular_transfer */
4248      return CURLE_OK;
4249    }
4250    if(result) /* error, loop or skipping the file */
4251      return result;
4252  }
4253  else { /* no wildcard FSM needed */
4254    result = ftp_parse_url_path(data, ftpc, ftp);
4255    if(result)
4256      return result;
4257  }
4258
4259  result = ftp_regular_transfer(data, ftpc, ftp, done);
4260
4261  return result;
4262}
4263
4264/***********************************************************************
4265 *
4266 * ftp_quit()
4267 *
4268 * This should be called before calling sclose() on an ftp control connection
4269 * (not data connections). We should then wait for the response from the
4270 * server before returning. The calling code should then try to close the
4271 * connection.
4272 *
4273 */
4274static CURLcode ftp_quit(struct Curl_easy *data,
4275                         struct ftp_conn *ftpc)
4276{
4277  CURLcode result = CURLE_OK;
4278
4279  if(ftpc->ctl_valid) {
4280    CURL_TRC_FTP(data, "sending QUIT to close session");
4281    result = Curl_pp_sendf(data, &ftpc->pp, "%s", "QUIT");
4282    if(result) {
4283      failf(data, "Failure sending QUIT command: %s",
4284            curl_easy_strerror(result));
4285      ftpc->ctl_valid = FALSE; /* mark control connection as bad */
4286      connclose(data->conn, "QUIT command failed"); /* mark for closure */
4287      ftp_state(data, ftpc, FTP_STOP);
4288      return result;
4289    }
4290
4291    ftp_state(data, ftpc, FTP_QUIT);
4292
4293    result = ftp_block_statemach(data, ftpc);
4294  }
4295
4296  return result;
4297}
4298
4299/***********************************************************************
4300 *
4301 * ftp_disconnect()
4302 *
4303 * Disconnect from an FTP server. Cleanup protocol-specific per-connection
4304 * resources. BLOCKING.
4305 */
4306static CURLcode ftp_disconnect(struct Curl_easy *data,
4307                               struct connectdata *conn,
4308                               bool dead_connection)
4309{
4310  struct ftp_conn *ftpc = Curl_conn_meta_get(conn, CURL_META_FTP_CONN);
4311
4312  if(!ftpc)
4313    return CURLE_FAILED_INIT;
4314  /* We cannot send quit unconditionally. If this connection is stale or
4315     bad in any way, sending quit and waiting around here will make the
4316     disconnect wait in vain and cause more problems than we need to.
4317
4318     ftp_quit() will check the state of ftp->ctl_valid. If it is ok it
4319     will try to send the QUIT command, otherwise it will return.
4320  */
4321  ftpc->shutdown = TRUE;
4322  if(dead_connection || Curl_pp_needs_flush(data, &ftpc->pp))
4323    ftpc->ctl_valid = FALSE;
4324
4325  /* The FTP session may or may not have been allocated/setup at this point! */
4326  (void)ftp_quit(data, ftpc); /* ignore errors on the QUIT */
4327  return CURLE_OK;
4328}
4329
4330/* called from multi.c while DOing */
4331static CURLcode ftp_doing(struct Curl_easy *data,
4332                          bool *dophase_done)
4333{
4334  struct ftp_conn *ftpc = Curl_conn_meta_get(data->conn, CURL_META_FTP_CONN);
4335  struct FTP *ftp = Curl_meta_get(data, CURL_META_FTP_EASY);
4336  CURLcode result;
4337
4338  if(!ftpc || !ftp)
4339    return CURLE_FAILED_INIT;
4340  result = ftp_statemach(data, ftpc, dophase_done);
4341
4342  if(result)
4343    CURL_TRC_FTP(data, "[%s] DO phase failed", FTP_CSTATE(ftpc));
4344  else if(*dophase_done) {
4345    result = ftp_dophase_done(data, ftpc, ftp, FALSE /* not connected */);
4346
4347    CURL_TRC_FTP(data, "[%s] DO phase is complete2", FTP_CSTATE(ftpc));
4348  }
4349  return result;
4350}
4351
4352static void ftp_easy_dtor(void *key, size_t klen, void *entry)
4353{
4354  struct FTP *ftp = entry;
4355  (void)key;
4356  (void)klen;
4357  curlx_safefree(ftp->pathalloc);
4358  curlx_free(ftp);
4359}
4360
4361static void ftp_conn_dtor(void *key, size_t klen, void *entry)
4362{
4363  struct ftp_conn *ftpc = entry;
4364  (void)key;
4365  (void)klen;
4366  freedirs(ftpc);
4367  curlx_safefree(ftpc->account);
4368  curlx_safefree(ftpc->alternative_to_user);
4369  curlx_safefree(ftpc->entrypath);
4370  curlx_safefree(ftpc->prevpath);
4371  curlx_safefree(ftpc->server_os);
4372  Curl_pp_disconnect(&ftpc->pp);
4373  curlx_free(ftpc);
4374}
4375
4376static void type_url_check(struct Curl_easy *data, struct FTP *ftp)
4377{
4378  size_t len = strlen(ftp->path);
4379  /* FTP URLs support an extension like ";type=<typecode>" that
4380   * we will try to get now! */
4381  if((len >= 7) && !memcmp(&ftp->path[len - 7], ";type=", 6)) {
4382    char *type = &ftp->path[len - 7];
4383    char command = Curl_raw_toupper(type[6]);
4384
4385    *type = 0; /* cut it off */
4386
4387    switch(command) {
4388    case 'A': /* ASCII mode */
4389      data->state.prefer_ascii = TRUE;
4390      break;
4391
4392    case 'D': /* directory mode */
4393      data->state.list_only = TRUE;
4394      break;
4395
4396    case 'I': /* binary mode */
4397    default:
4398      /* switch off ASCII */
4399      data->state.prefer_ascii = FALSE;
4400      break;
4401    }
4402  }
4403}
4404
4405static CURLcode ftp_setup_connection(struct Curl_easy *data,
4406                                     struct connectdata *conn)
4407{
4408  struct FTP *ftp;
4409  CURLcode result = CURLE_OK;
4410  struct ftp_conn *ftpc;
4411
4412  ftp = curlx_calloc(1, sizeof(*ftp));
4413  if(!ftp ||
4414     Curl_meta_set(data, CURL_META_FTP_EASY, ftp, ftp_easy_dtor))
4415    return CURLE_OUT_OF_MEMORY;
4416
4417  ftpc = curlx_calloc(1, sizeof(*ftpc));
4418  if(!ftpc ||
4419     Curl_conn_meta_set(conn, CURL_META_FTP_CONN, ftpc, ftp_conn_dtor))
4420    return CURLE_OUT_OF_MEMORY;
4421
4422  /* clone connection related data that is FTP specific */
4423  if(data->set.str[STRING_FTP_ACCOUNT]) {
4424    ftpc->account = curlx_strdup(data->set.str[STRING_FTP_ACCOUNT]);
4425    if(!ftpc->account) {
4426      Curl_conn_meta_remove(conn, CURL_META_FTP_CONN);
4427      return CURLE_OUT_OF_MEMORY;
4428    }
4429  }
4430  if(data->set.str[STRING_FTP_ALTERNATIVE_TO_USER]) {
4431    ftpc->alternative_to_user =
4432      curlx_strdup(data->set.str[STRING_FTP_ALTERNATIVE_TO_USER]);
4433    if(!ftpc->alternative_to_user) {
4434      curlx_safefree(ftpc->account);
4435      Curl_conn_meta_remove(conn, CURL_META_FTP_CONN);
4436      return CURLE_OUT_OF_MEMORY;
4437    }
4438  }
4439
4440  ftp->path = &data->state.up.path[1]; /* do not include the initial slash */
4441
4442  type_url_check(data, ftp);
4443
4444  /* get some initial data into the ftp struct */
4445  ftp->transfer = PPTRANSFER_BODY;
4446  ftp->downloadsize = 0;
4447  ftpc->known_filesize = -1; /* unknown size for now */
4448  ftpc->use_ssl = data->set.use_ssl;
4449  ftpc->ccc = data->set.ftp_ccc;
4450
4451  CURL_TRC_FTP(data, "[%s] setup connection -> %d", FTP_CSTATE(ftpc), result);
4452  return result;
4453}
4454
4455bool ftp_conns_match(struct connectdata *needle, struct connectdata *conn)
4456{
4457  struct ftp_conn *nftpc = Curl_conn_meta_get(needle, CURL_META_FTP_CONN);
4458  struct ftp_conn *cftpc = Curl_conn_meta_get(conn, CURL_META_FTP_CONN);
4459  /* Also match ACCOUNT, ALTERNATIVE-TO-USER, USE_SSL and CCC options */
4460  if(!nftpc || !cftpc ||
4461     Curl_timestrcmp(nftpc->account, cftpc->account) ||
4462     Curl_timestrcmp(nftpc->alternative_to_user,
4463                     cftpc->alternative_to_user) ||
4464     (nftpc->use_ssl != cftpc->use_ssl) ||
4465     (nftpc->ccc != cftpc->ccc))
4466    return FALSE;
4467  return TRUE;
4468}
4469
4470/*
4471 * FTP protocol.
4472 */
4473const struct Curl_protocol Curl_protocol_ftp = {
4474  ftp_setup_connection,            /* setup_connection */
4475  ftp_do,                          /* do_it */
4476  ftp_done,                        /* done */
4477  ftp_do_more,                     /* do_more */
4478  ftp_connect,                     /* connect_it */
4479  ftp_multi_statemach,             /* connecting */
4480  ftp_doing,                       /* doing */
4481  ftp_pollset,                     /* proto_pollset */
4482  ftp_pollset,                     /* doing_pollset */
4483  ftp_domore_pollset,              /* domore_pollset */
4484  ZERO_NULL,                       /* perform_pollset */
4485  ftp_disconnect,                  /* disconnect */
4486  ZERO_NULL,                       /* write_resp */
4487  ZERO_NULL,                       /* write_resp_hd */
4488  ZERO_NULL,                       /* connection_is_dead */
4489  ZERO_NULL,                       /* attach connection */
4490  ZERO_NULL,                       /* follow */
4491};
4492
4493#endif /* CURL_DISABLE_FTP */