luna - curl/lib/vssh/libssh.c

   1/***************************************************************************
   2 *                                  _   _ ____  _
   3 *  Project                     ___| | | |  _ \| |
   4 *                             / __| | | | |_) | |
   5 *                            | (__| |_| |  _ <| |___
   6 *                             \___|\___/|_| \_\_____|
   7 *
   8 * Copyright (C) Red Hat, Inc.
   9 *
  10 * Authors: Nikos Mavrogiannopoulos, Tomas Mraz, Stanislav Zidek,
  11 *          Robert Kolcun, Andreas Schneider
  12 *
  13 * This software is licensed as described in the file COPYING, which
  14 * you should have received as part of this distribution. The terms
  15 * are also available at https://curl.se/docs/copyright.html.
  16 *
  17 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  18 * copies of the Software, and permit persons to whom the Software is
  19 * furnished to do so, under the terms of the COPYING file.
  20 *
  21 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  22 * KIND, either express or implied.
  23 *
  24 * SPDX-License-Identifier: curl
  25 *
  26 ***************************************************************************/
  27#include "curl_setup.h"
  28
  29#ifdef USE_LIBSSH
  30
  31#ifdef HAVE_NETINET_IN_H
  32#include <netinet/in.h>
  33#endif
  34#ifdef HAVE_ARPA_INET_H
  35#include <arpa/inet.h>
  36#endif
  37#ifdef HAVE_NETDB_H
  38#include <netdb.h>
  39#endif
  40#ifdef __VMS
  41#include <in.h>
  42#include <inet.h>
  43#endif
  44
  45#include "urldata.h"
  46#include "sendf.h"
  47#include "curl_trc.h"
  48#include "hostip.h"
  49#include "progress.h"
  50#include "transfer.h"
  51#include "vssh/ssh.h"
  52#include "url.h"
  53#include "cfilters.h"
  54#include "connect.h"
  55#include "parsedate.h"          /* for the week day and month names */
  56#include "curlx/strparse.h"
  57#include "multiif.h"
  58#include "select.h"
  59#include "vssh/vssh.h"
  60#include "curlx/base64.h" /* for curlx_base64_encode() */
  61
  62#ifdef HAVE_UNISTD_H
  63#include <unistd.h>
  64#endif
  65#ifdef HAVE_FCNTL_H
  66#include <fcntl.h>
  67#endif
  68
  69/* A recent macro provided by libssh. Or make our own. */
  70#ifndef SSH_STRING_FREE_CHAR
  71#define SSH_STRING_FREE_CHAR(x) \
  72  do {                          \
  73    if(x) {                     \
  74      ssh_string_free_char(x);  \
  75      x = NULL;                 \
  76    }                           \
  77  } while(0)
  78#endif
  79
  80/* These stat values may not be the same as the user's S_IFMT / S_IFLNK */
  81#ifndef SSH_S_IFMT
  82#define SSH_S_IFMT   00170000
  83#endif
  84#ifndef SSH_S_IFLNK
  85#define SSH_S_IFLNK  0120000
  86#endif
  87
  88static CURLcode sftp_error_to_CURLE(int err)
  89{
  90  switch(err) {
  91  case SSH_FX_OK:
  92    return CURLE_OK;
  93
  94  case SSH_FX_NO_SUCH_FILE:
  95  case SSH_FX_NO_SUCH_PATH:
  96    return CURLE_REMOTE_FILE_NOT_FOUND;
  97
  98  case SSH_FX_PERMISSION_DENIED:
  99  case SSH_FX_WRITE_PROTECT:
 100    return CURLE_REMOTE_ACCESS_DENIED;
 101
 102  case SSH_FX_FILE_ALREADY_EXISTS:
 103    return CURLE_REMOTE_FILE_EXISTS;
 104
 105  default:
 106    break;
 107  }
 108
 109  return CURLE_SSH;
 110}
 111
 112/* Multiple options:
 113 * 1. data->set.str[STRING_SSH_HOST_PUBLIC_KEY_SHA256] is set with a SHA256
 114 *    hash.
 115 * 2. data->set.str[STRING_SSH_HOST_PUBLIC_KEY_MD5] is set with an MD5
 116 *    hash (90s style auth, not sure we should have it here)
 117 * 3. data->set.ssh_keyfunc callback is set. Then we do trust on first
 118 *    use. We even save on knownhosts if CURLKHSTAT_FINE_ADD_TO_FILE
 119 *    is returned by it.
 120 * 4. none of the above. We only accept if it is present on known hosts.
 121 *
 122 * Returns SSH_OK or SSH_ERROR.
 123 */
 124static int myssh_is_known(struct Curl_easy *data, struct ssh_conn *sshc)
 125{
 126  int rc;
 127  ssh_key pubkey;
 128  unsigned char *hash_sha256 = NULL;
 129  size_t hlen_sha256;
 130  unsigned char *hash_md5 = NULL;
 131  size_t hlen_md5;
 132  char *found_base64 = NULL;
 133  char *known_base64 = NULL;
 134  int vstate;
 135  enum curl_khmatch keymatch;
 136  struct curl_khkey foundkey;
 137  struct curl_khkey *knownkeyp = NULL;
 138  curl_sshkeycallback func = data->set.ssh_keyfunc;
 139  struct ssh_knownhosts_entry *knownhostsentry = NULL;
 140  struct curl_khkey knownkey;
 141
 142  rc = ssh_get_server_publickey(sshc->ssh_session, &pubkey);
 143
 144  if(rc != SSH_OK)
 145    return rc;
 146
 147  if(data->set.str[STRING_SSH_HOST_PUBLIC_KEY_SHA256]) {
 148    const char *pubkey_sha256 =
 149      data->set.str[STRING_SSH_HOST_PUBLIC_KEY_SHA256];
 150    char *fingerprint_b64 = NULL;
 151    size_t fingerprint_b64_len;
 152    size_t pub_pos = 0;
 153    size_t b64_pos = 0;
 154
 155    rc = ssh_get_publickey_hash(pubkey, SSH_PUBLICKEY_HASH_SHA256,
 156                                &hash_sha256, &hlen_sha256);
 157    if(rc != SSH_OK || hlen_sha256 != 32) {
 158      failf(data, "Denied establishing ssh session: "
 159            "SHA256 fingerprint not available");
 160      goto cleanup;
 161    }
 162
 163    if(curlx_base64_encode((const uint8_t *)hash_sha256, 32, &fingerprint_b64,
 164                           &fingerprint_b64_len) != CURLE_OK) {
 165      rc = SSH_ERROR;
 166      goto cleanup;
 167    }
 168
 169    infof(data, "SSH SHA256 fingerprint: %s", fingerprint_b64);
 170
 171    /* Find the position of any = padding characters in the public key */
 172    while((pubkey_sha256[pub_pos] != '=') && pubkey_sha256[pub_pos]) {
 173      pub_pos++;
 174    }
 175
 176    /* Find the position of any = padding characters in the base64 coded
 177     * hostkey fingerprint */
 178    while((fingerprint_b64[b64_pos] != '=') && fingerprint_b64[b64_pos]) {
 179      b64_pos++;
 180    }
 181
 182    /* Before we authenticate we check the hostkey's SHA256 fingerprint
 183     * against a known fingerprint, if available.
 184     */
 185    if((pub_pos != b64_pos) ||
 186       strncmp(fingerprint_b64, pubkey_sha256, pub_pos)) {
 187      failf(data,
 188            "Denied establishing ssh session: mismatch SHA256 fingerprint. "
 189            "Remote %s is not equal to %s", fingerprint_b64, pubkey_sha256);
 190      curlx_free(fingerprint_b64);
 191      rc = SSH_ERROR;
 192      goto cleanup;
 193    }
 194
 195    curlx_free(fingerprint_b64);
 196
 197    rc = SSH_OK;
 198    goto cleanup;
 199  }
 200
 201  if(data->set.str[STRING_SSH_HOST_PUBLIC_KEY_MD5]) {
 202    const char *pubkey_md5 = data->set.str[STRING_SSH_HOST_PUBLIC_KEY_MD5];
 203    char md5buffer[33];
 204    int i;
 205
 206    rc = ssh_get_publickey_hash(pubkey, SSH_PUBLICKEY_HASH_MD5,
 207                                &hash_md5, &hlen_md5);
 208    if(rc != SSH_OK || hlen_md5 != 16) {
 209      failf(data,
 210            "Denied establishing ssh session: MD5 fingerprint not available");
 211      goto cleanup;
 212    }
 213
 214    for(i = 0; i < 16; i++)
 215      curl_msnprintf(&md5buffer[i * 2], 3, "%02x", hash_md5[i]);
 216
 217    infof(data, "SSH MD5 fingerprint: %s", md5buffer);
 218
 219    if(!curl_strequal(md5buffer, pubkey_md5)) {
 220      failf(data,
 221            "Denied establishing ssh session: mismatch MD5 fingerprint. "
 222            "Remote %s is not equal to %s", md5buffer, pubkey_md5);
 223      rc = SSH_ERROR;
 224      goto cleanup;
 225    }
 226
 227    rc = SSH_OK;
 228    goto cleanup;
 229  }
 230
 231  if(data->set.str[STRING_SSH_KNOWNHOSTS]) {
 232
 233    /* Get the known_key from the known hosts file */
 234    vstate = ssh_session_get_known_hosts_entry(sshc->ssh_session,
 235                                               &knownhostsentry);
 236
 237    /* Case an entry was found in a known hosts file */
 238    if(knownhostsentry) {
 239      if(knownhostsentry->publickey) {
 240        rc = ssh_pki_export_pubkey_base64(knownhostsentry->publickey,
 241                                          &known_base64);
 242        if(rc != SSH_OK) {
 243          goto cleanup;
 244        }
 245        knownkey.key = known_base64;
 246        knownkey.len = strlen(known_base64);
 247
 248        switch(ssh_key_type(knownhostsentry->publickey)) {
 249        case SSH_KEYTYPE_RSA:
 250          knownkey.keytype = CURLKHTYPE_RSA;
 251          break;
 252        case SSH_KEYTYPE_RSA1:
 253          knownkey.keytype = CURLKHTYPE_RSA1;
 254          break;
 255        case SSH_KEYTYPE_ECDSA:
 256        case SSH_KEYTYPE_ECDSA_P256:
 257        case SSH_KEYTYPE_ECDSA_P384:
 258        case SSH_KEYTYPE_ECDSA_P521:
 259          knownkey.keytype = CURLKHTYPE_ECDSA;
 260          break;
 261        case SSH_KEYTYPE_ED25519:
 262          knownkey.keytype = CURLKHTYPE_ED25519;
 263          break;
 264        case SSH_KEYTYPE_DSS:
 265          knownkey.keytype = CURLKHTYPE_DSS;
 266          break;
 267        default:
 268          rc = SSH_ERROR;
 269          goto cleanup;
 270        }
 271        knownkeyp = &knownkey;
 272      }
 273    }
 274
 275    switch(vstate) {
 276    case SSH_KNOWN_HOSTS_OK:
 277      keymatch = CURLKHMATCH_OK;
 278      break;
 279    case SSH_KNOWN_HOSTS_OTHER:
 280    case SSH_KNOWN_HOSTS_NOT_FOUND:
 281    case SSH_KNOWN_HOSTS_UNKNOWN:
 282    case SSH_KNOWN_HOSTS_ERROR:
 283      keymatch = CURLKHMATCH_MISSING;
 284      break;
 285    default:
 286      keymatch = CURLKHMATCH_MISMATCH;
 287      break;
 288    }
 289
 290    if(func) { /* use callback to determine action */
 291      rc = ssh_pki_export_pubkey_base64(pubkey, &found_base64);
 292      if(rc != SSH_OK)
 293        goto cleanup;
 294
 295      foundkey.key = found_base64;
 296      foundkey.len = strlen(found_base64);
 297
 298      switch(ssh_key_type(pubkey)) {
 299      case SSH_KEYTYPE_RSA:
 300        foundkey.keytype = CURLKHTYPE_RSA;
 301        break;
 302      case SSH_KEYTYPE_RSA1:
 303        foundkey.keytype = CURLKHTYPE_RSA1;
 304        break;
 305      case SSH_KEYTYPE_ECDSA:
 306      case SSH_KEYTYPE_ECDSA_P256:
 307      case SSH_KEYTYPE_ECDSA_P384:
 308      case SSH_KEYTYPE_ECDSA_P521:
 309        foundkey.keytype = CURLKHTYPE_ECDSA;
 310        break;
 311      case SSH_KEYTYPE_ED25519:
 312        foundkey.keytype = CURLKHTYPE_ED25519;
 313        break;
 314      case SSH_KEYTYPE_DSS:
 315        foundkey.keytype = CURLKHTYPE_DSS;
 316        break;
 317      default:
 318        rc = SSH_ERROR;
 319        goto cleanup;
 320      }
 321
 322      Curl_set_in_callback(data, TRUE);
 323      rc = func(data, knownkeyp, /* from the knownhosts file */
 324                &foundkey,       /* from the remote host */
 325                keymatch, data->set.ssh_keyfunc_userp);
 326      Curl_set_in_callback(data, FALSE);
 327
 328      switch(rc) {
 329      case CURLKHSTAT_FINE_ADD_TO_FILE:
 330        rc = ssh_session_update_known_hosts(sshc->ssh_session);
 331        if(rc != SSH_OK) {
 332          goto cleanup;
 333        }
 334        break;
 335      case CURLKHSTAT_FINE:
 336        break;
 337      default: /* REJECT/DEFER */
 338        rc = SSH_ERROR;
 339        goto cleanup;
 340      }
 341    }
 342    else {
 343      if(keymatch != CURLKHMATCH_OK) {
 344        rc = SSH_ERROR;
 345        goto cleanup;
 346      }
 347    }
 348  }
 349  rc = SSH_OK;
 350
 351cleanup:
 352  if(found_base64) {
 353    /* !checksrc! disable BANNEDFUNC 1 */
 354    free(found_base64); /* allocated by libssh, deallocate with system free */
 355  }
 356  if(known_base64) {
 357    /* !checksrc! disable BANNEDFUNC 1 */
 358    free(known_base64); /* allocated by libssh, deallocate with system free */
 359  }
 360  if(hash_sha256)
 361    ssh_clean_pubkey_hash(&hash_sha256);
 362  if(hash_md5)
 363    ssh_clean_pubkey_hash(&hash_md5);
 364  ssh_key_free(pubkey);
 365  if(knownhostsentry) {
 366    ssh_knownhosts_entry_free(knownhostsentry);
 367  }
 368  return rc;
 369}
 370
 371static int myssh_to_ERROR(struct Curl_easy *data,
 372                          struct ssh_conn *sshc,
 373                          CURLcode result)
 374{
 375  myssh_to(data, sshc, SSH_SESSION_DISCONNECT);
 376  sshc->actualcode = result;
 377  return SSH_ERROR;
 378}
 379
 380static int myssh_to_SFTP_CLOSE(struct Curl_easy *data,
 381                               struct ssh_conn *sshc)
 382{
 383  myssh_to(data, sshc, SSH_SFTP_CLOSE);
 384  sshc->actualcode = sftp_error_to_CURLE(sftp_get_error(sshc->sftp_session));
 385  return SSH_ERROR;
 386}
 387
 388static int myssh_to_PASSWD_AUTH(struct Curl_easy *data,
 389                                struct ssh_conn *sshc)
 390{
 391  if(sshc->auth_methods & SSH_AUTH_METHOD_PASSWORD) {
 392    myssh_to(data, sshc, SSH_AUTH_PASS_INIT);
 393    return SSH_OK;
 394  }
 395  return myssh_to_ERROR(data, sshc, CURLE_LOGIN_DENIED);
 396}
 397
 398static int myssh_to_KEY_AUTH(struct Curl_easy *data,
 399                             struct ssh_conn *sshc)
 400{
 401  if(sshc->auth_methods & SSH_AUTH_METHOD_INTERACTIVE) {
 402    myssh_to(data, sshc, SSH_AUTH_KEY_INIT);
 403    return SSH_OK;
 404  }
 405  return myssh_to_PASSWD_AUTH(data, sshc);
 406}
 407
 408static int myssh_to_GSSAPI_AUTH(struct Curl_easy *data,
 409                                struct ssh_conn *sshc)
 410{
 411  if(sshc->auth_methods & SSH_AUTH_METHOD_GSSAPI_MIC) {
 412    myssh_to(data, sshc, SSH_AUTH_GSSAPI);
 413    return SSH_OK;
 414  }
 415  return myssh_to_KEY_AUTH(data, sshc);
 416}
 417
 418static int myssh_in_SFTP_READDIR_INIT(struct Curl_easy *data,
 419                                      struct ssh_conn *sshc,
 420                                      struct SSHPROTO *sshp)
 421{
 422  if(!sshp)
 423    return myssh_to_ERROR(data, sshc, CURLE_FAILED_INIT);
 424  Curl_pgrsSetDownloadSize(data, -1);
 425  if(data->req.no_body) {
 426    myssh_to(data, sshc, SSH_STOP);
 427    return SSH_NO_ERROR;
 428  }
 429
 430  /*
 431   * This is a directory that we are trying to get, so produce a directory
 432   * listing
 433   */
 434  sshc->sftp_dir = sftp_opendir(sshc->sftp_session,
 435                                sshp->path);
 436  if(!sshc->sftp_dir) {
 437    failf(data, "Could not open directory for reading: %s",
 438          ssh_get_error(sshc->ssh_session));
 439    return myssh_to_SFTP_CLOSE(data, sshc);
 440  }
 441  myssh_to(data, sshc, SSH_SFTP_READDIR);
 442  return SSH_NO_ERROR;
 443}
 444
 445static int myssh_in_SFTP_READDIR(struct Curl_easy *data,
 446                                 struct ssh_conn *sshc,
 447                                 struct SSHPROTO *sshp)
 448{
 449  CURLcode result = CURLE_OK;
 450
 451  if(!sshp)
 452    return myssh_to_ERROR(data, sshc, CURLE_FAILED_INIT);
 453  curlx_dyn_reset(&sshc->readdir_buf);
 454  if(sshc->readdir_attrs)
 455    sftp_attributes_free(sshc->readdir_attrs);
 456
 457  sshc->readdir_attrs = sftp_readdir(sshc->sftp_session, sshc->sftp_dir);
 458  if(sshc->readdir_attrs) {
 459    sshc->readdir_filename = sshc->readdir_attrs->name;
 460    sshc->readdir_longentry = sshc->readdir_attrs->longname;
 461    sshc->readdir_len = strlen(sshc->readdir_filename);
 462
 463    if(data->set.list_only) {
 464      char *tmpLine;
 465
 466      tmpLine = curl_maprintf("%s\n", sshc->readdir_filename);
 467      if(!tmpLine) {
 468        myssh_to(data, sshc, SSH_SFTP_CLOSE);
 469        sshc->actualcode = CURLE_OUT_OF_MEMORY;
 470        return SSH_ERROR;
 471      }
 472      result = Curl_client_write(data, CLIENTWRITE_BODY,
 473                                 tmpLine, sshc->readdir_len + 1);
 474      curlx_free(tmpLine);
 475
 476      if(result) {
 477        myssh_to(data, sshc, SSH_STOP);
 478        sshc->actualcode = result;
 479        return SSH_NO_ERROR;
 480      }
 481    }
 482    else {
 483      if(curlx_dyn_add(&sshc->readdir_buf, sshc->readdir_longentry)) {
 484        sshc->actualcode = CURLE_OUT_OF_MEMORY;
 485        myssh_to(data, sshc, SSH_STOP);
 486        return SSH_ERROR;
 487      }
 488
 489      if((sshc->readdir_attrs->flags & SSH_FILEXFER_ATTR_PERMISSIONS) &&
 490         ((sshc->readdir_attrs->permissions & SSH_S_IFMT) ==
 491          SSH_S_IFLNK)) {
 492        sshc->readdir_linkPath = curl_maprintf("%s%s", sshp->path,
 493                                               sshc->readdir_filename);
 494
 495        if(!sshc->readdir_linkPath) {
 496          myssh_to(data, sshc, SSH_SFTP_CLOSE);
 497          sshc->actualcode = CURLE_OUT_OF_MEMORY;
 498          return SSH_ERROR;
 499        }
 500
 501        myssh_to(data, sshc, SSH_SFTP_READDIR_LINK);
 502        return SSH_NO_ERROR;
 503      }
 504      myssh_to(data, sshc, SSH_SFTP_READDIR_BOTTOM);
 505      return SSH_NO_ERROR;
 506    }
 507  }
 508  else if(sftp_dir_eof(sshc->sftp_dir)) {
 509    myssh_to(data, sshc, SSH_SFTP_READDIR_DONE);
 510  }
 511  else {
 512    failf(data, "Could not open remote directory for reading: %s",
 513          ssh_get_error(sshc->ssh_session));
 514    return myssh_to_SFTP_CLOSE(data, sshc);
 515  }
 516  return SSH_NO_ERROR;
 517}
 518
 519static int myssh_in_SFTP_READDIR_LINK(struct Curl_easy *data,
 520                                      struct ssh_conn *sshc)
 521{
 522  if(sshc->readdir_link_attrs)
 523    sftp_attributes_free(sshc->readdir_link_attrs);
 524
 525  sshc->readdir_link_attrs = sftp_lstat(sshc->sftp_session,
 526                                        sshc->readdir_linkPath);
 527  if(!sshc->readdir_link_attrs) {
 528    failf(data, "Could not read symlink for reading: %s",
 529          ssh_get_error(sshc->ssh_session));
 530    return myssh_to_SFTP_CLOSE(data, sshc);
 531  }
 532
 533  if(!sshc->readdir_link_attrs->name) {
 534    sshc->readdir_tmp = sftp_readlink(sshc->sftp_session,
 535                                      sshc->readdir_linkPath);
 536    if(!sshc->readdir_tmp)
 537      sshc->readdir_len = 0;
 538    else
 539      sshc->readdir_len = strlen(sshc->readdir_tmp);
 540    sshc->readdir_longentry = NULL;
 541    sshc->readdir_filename = sshc->readdir_tmp;
 542  }
 543  else {
 544    sshc->readdir_len = strlen(sshc->readdir_link_attrs->name);
 545    sshc->readdir_filename = sshc->readdir_link_attrs->name;
 546    sshc->readdir_longentry = sshc->readdir_link_attrs->longname;
 547  }
 548
 549  curlx_safefree(sshc->readdir_linkPath);
 550
 551  if(curlx_dyn_addf(&sshc->readdir_buf, " -> %s", sshc->readdir_filename)) {
 552    /* Not using:
 553     * return myssh_to_SFTP_CLOSE(data, sshc);
 554     *
 555     * as that assumes an sftp related error while
 556     * assigning sshc->actualcode whereas the current
 557     * error is curlx_dyn_addf() related.
 558     */
 559    myssh_to(data, sshc, SSH_SFTP_CLOSE);
 560    sshc->actualcode = CURLE_OUT_OF_MEMORY;
 561    return SSH_ERROR;
 562  }
 563
 564  sftp_attributes_free(sshc->readdir_link_attrs);
 565  sshc->readdir_link_attrs = NULL;
 566  sshc->readdir_filename = NULL;
 567  sshc->readdir_longentry = NULL;
 568
 569  myssh_to(data, sshc, SSH_SFTP_READDIR_BOTTOM);
 570  return SSH_NO_ERROR;
 571}
 572
 573static int myssh_in_SFTP_READDIR_BOTTOM(struct Curl_easy *data,
 574                                        struct ssh_conn *sshc)
 575{
 576  CURLcode result;
 577
 578  if(curlx_dyn_addn(&sshc->readdir_buf, "\n", 1))
 579    result = CURLE_OUT_OF_MEMORY;
 580  else
 581    result = Curl_client_write(data, CLIENTWRITE_BODY,
 582                               curlx_dyn_ptr(&sshc->readdir_buf),
 583                               curlx_dyn_len(&sshc->readdir_buf));
 584
 585  ssh_string_free_char(sshc->readdir_tmp);
 586  sshc->readdir_tmp = NULL;
 587
 588  if(result) {
 589    myssh_to(data, sshc, SSH_STOP);
 590    sshc->actualcode = result;
 591  }
 592  else
 593    myssh_to(data, sshc, SSH_SFTP_READDIR);
 594  return SSH_NO_ERROR;
 595}
 596
 597static int myssh_in_SFTP_READDIR_DONE(struct Curl_easy *data,
 598                                      struct ssh_conn *sshc)
 599{
 600  sftp_closedir(sshc->sftp_dir);
 601  sshc->sftp_dir = NULL;
 602
 603  /* no data to transfer */
 604  Curl_xfer_setup_nop(data);
 605  myssh_to(data, sshc, SSH_STOP);
 606  return SSH_NO_ERROR;
 607}
 608
 609static void myssh_quote_error(struct Curl_easy *data, struct ssh_conn *sshc,
 610                              const char *cmd)
 611{
 612  if(cmd)
 613    failf(data, "%s command failed: %s", cmd,
 614          ssh_get_error(sshc->ssh_session));
 615  curlx_safefree(sshc->quote_path1);
 616  curlx_safefree(sshc->quote_path2);
 617  myssh_to(data, sshc, SSH_SFTP_CLOSE);
 618  sshc->nextstate = SSH_NO_STATE;
 619  sshc->actualcode = CURLE_QUOTE_ERROR;
 620}
 621
 622static int myssh_in_SFTP_QUOTE_STATVFS(struct Curl_easy *data,
 623                                       struct ssh_conn *sshc)
 624{
 625  sftp_statvfs_t statvfs;
 626
 627  statvfs = sftp_statvfs(sshc->sftp_session, sshc->quote_path1);
 628  if(!statvfs && !sshc->acceptfail) {
 629    myssh_quote_error(data, sshc, "statvfs");
 630    return SSH_OK;
 631  }
 632  else if(statvfs) {
 633#ifdef _MSC_VER
 634#define CURL_LIBSSH_VFS_SIZE_MASK "I64u"
 635#elif defined(__MINGW32__) && (__MINGW64_VERSION_MAJOR <= 6)
 636#define CURL_LIBSSH_VFS_SIZE_MASK "llu"
 637#else
 638#define CURL_LIBSSH_VFS_SIZE_MASK PRIu64
 639#endif
 640    CURLcode result = CURLE_OK;
 641    char *tmp = curl_maprintf("statvfs:\n"
 642                              "f_bsize: %" CURL_LIBSSH_VFS_SIZE_MASK "\n"
 643                              "f_frsize: %" CURL_LIBSSH_VFS_SIZE_MASK "\n"
 644                              "f_blocks: %" CURL_LIBSSH_VFS_SIZE_MASK "\n"
 645                              "f_bfree: %" CURL_LIBSSH_VFS_SIZE_MASK "\n"
 646                              "f_bavail: %" CURL_LIBSSH_VFS_SIZE_MASK "\n"
 647                              "f_files: %" CURL_LIBSSH_VFS_SIZE_MASK "\n"
 648                              "f_ffree: %" CURL_LIBSSH_VFS_SIZE_MASK "\n"
 649                              "f_favail: %" CURL_LIBSSH_VFS_SIZE_MASK "\n"
 650                              "f_fsid: %" CURL_LIBSSH_VFS_SIZE_MASK "\n"
 651                              "f_flag: %" CURL_LIBSSH_VFS_SIZE_MASK "\n"
 652                              "f_namemax: %" CURL_LIBSSH_VFS_SIZE_MASK "\n",
 653                              statvfs->f_bsize, statvfs->f_frsize,
 654                              statvfs->f_blocks, statvfs->f_bfree,
 655                              statvfs->f_bavail, statvfs->f_files,
 656                              statvfs->f_ffree, statvfs->f_favail,
 657                              statvfs->f_fsid, statvfs->f_flag,
 658                              statvfs->f_namemax);
 659    sftp_statvfs_free(statvfs);
 660
 661    if(!tmp)
 662      result = CURLE_OUT_OF_MEMORY;
 663
 664    if(!result) {
 665      result = Curl_client_write(data, CLIENTWRITE_HEADER, tmp, strlen(tmp));
 666      curlx_free(tmp);
 667    }
 668    if(result) {
 669      myssh_to(data, sshc, SSH_SFTP_CLOSE);
 670      sshc->nextstate = SSH_NO_STATE;
 671      sshc->actualcode = result;
 672    }
 673  }
 674  myssh_to(data, sshc, SSH_SFTP_NEXT_QUOTE);
 675  return SSH_OK;
 676}
 677
 678static int myssh_auth_interactive(struct connectdata *conn,
 679                                  struct ssh_conn *sshc)
 680{
 681  int rc;
 682  int nprompts;
 683
 684restart:
 685  switch(sshc->kbd_state) {
 686  case 0:
 687    rc = ssh_userauth_kbdint(sshc->ssh_session, NULL, NULL);
 688    if(rc == SSH_AUTH_AGAIN)
 689      return SSH_AGAIN;
 690
 691    if(rc != SSH_AUTH_INFO)
 692      return SSH_ERROR;
 693
 694    nprompts = ssh_userauth_kbdint_getnprompts(sshc->ssh_session);
 695    if(nprompts != 1)
 696      return SSH_ERROR;
 697
 698    rc = ssh_userauth_kbdint_setanswer(sshc->ssh_session, 0,
 699                                       Curl_creds_passwd(conn->creds));
 700    if(rc < 0)
 701      return SSH_ERROR;
 702
 703    FALLTHROUGH();
 704  case 1:
 705    sshc->kbd_state = 1;
 706
 707    rc = ssh_userauth_kbdint(sshc->ssh_session, NULL, NULL);
 708    if(rc == SSH_AUTH_AGAIN)
 709      return SSH_AGAIN;
 710    else if(rc == SSH_AUTH_SUCCESS)
 711      rc = SSH_OK;
 712    else if(rc == SSH_AUTH_INFO) {
 713      nprompts = ssh_userauth_kbdint_getnprompts(sshc->ssh_session);
 714      if(nprompts)
 715        return SSH_ERROR;
 716
 717      sshc->kbd_state = 2;
 718      goto restart;
 719    }
 720    else
 721      rc = SSH_ERROR;
 722    break;
 723  case 2:
 724    sshc->kbd_state = 2;
 725
 726    rc = ssh_userauth_kbdint(sshc->ssh_session, NULL, NULL);
 727    if(rc == SSH_AUTH_AGAIN)
 728      return SSH_AGAIN;
 729    else if(rc == SSH_AUTH_SUCCESS)
 730      rc = SSH_OK;
 731    else
 732      rc = SSH_ERROR;
 733
 734    break;
 735  default:
 736    return SSH_ERROR;
 737  }
 738
 739  sshc->kbd_state = 0;
 740  return rc;
 741}
 742
 743static void myssh_state_init(struct Curl_easy *data,
 744                             struct ssh_conn *sshc)
 745{
 746  sshc->secondCreateDirs = 0;
 747  sshc->nextstate = SSH_NO_STATE;
 748  sshc->actualcode = CURLE_OK;
 749
 750#if 0
 751  ssh_set_log_level(SSH_LOG_PROTOCOL);
 752#endif
 753
 754  /* Set libssh to non-blocking, since everything internally is
 755     non-blocking */
 756  ssh_set_blocking(sshc->ssh_session, 0);
 757
 758  myssh_to(data, sshc, SSH_S_STARTUP);
 759}
 760
 761static void myssh_block2waitfor(struct connectdata *conn,
 762                                struct ssh_conn *sshc,
 763                                bool block)
 764{
 765  (void)conn;
 766  if(block) {
 767    int dir = ssh_get_poll_flags(sshc->ssh_session);
 768    /* translate the libssh define bits into our own bit defines */
 769    sshc->waitfor =
 770      ((dir & SSH_READ_PENDING) ? REQ_IO_RECV : 0) |
 771      ((dir & SSH_WRITE_PENDING) ? REQ_IO_SEND : 0);
 772  }
 773  else
 774    sshc->waitfor = 0;
 775}
 776
 777static int myssh_in_S_STARTUP(struct Curl_easy *data,
 778                              struct ssh_conn *sshc)
 779{
 780  struct connectdata *conn = data->conn;
 781  int rc = ssh_connect(sshc->ssh_session);
 782
 783  myssh_block2waitfor(conn, sshc, (rc == SSH_AGAIN));
 784  if(rc == SSH_AGAIN) {
 785    CURL_TRC_SSH(data, "connect -> EAGAIN");
 786  }
 787  else if(rc != SSH_OK) {
 788    failf(data, "Failure establishing ssh session");
 789    rc = myssh_to_ERROR(data, sshc, CURLE_FAILED_INIT);
 790  }
 791  else
 792    myssh_to(data, sshc, SSH_HOSTKEY);
 793
 794  return rc;
 795}
 796
 797static int myssh_in_AUTHLIST(struct Curl_easy *data,
 798                             struct ssh_conn *sshc)
 799{
 800  int rc;
 801  sshc->authed = FALSE;
 802
 803  rc = ssh_userauth_none(sshc->ssh_session, NULL);
 804  if(rc == SSH_AUTH_AGAIN)
 805    return SSH_AGAIN;
 806
 807  if(rc == SSH_AUTH_SUCCESS) {
 808    sshc->authed = TRUE;
 809    infof(data, "Authenticated with none");
 810    myssh_to(data, sshc, SSH_AUTH_DONE);
 811    return rc;
 812  }
 813  else if(rc == SSH_AUTH_ERROR) {
 814    rc = myssh_to_ERROR(data, sshc, CURLE_LOGIN_DENIED);
 815    return rc;
 816  }
 817
 818  sshc->auth_methods =
 819    (unsigned int)ssh_userauth_list(sshc->ssh_session, NULL);
 820  if(sshc->auth_methods)
 821    infof(data, "SSH authentication methods available: %s%s%s%s",
 822          sshc->auth_methods & SSH_AUTH_METHOD_PUBLICKEY ?
 823          "public key, " : "",
 824          sshc->auth_methods & SSH_AUTH_METHOD_GSSAPI_MIC ?
 825          "GSSAPI, " : "",
 826          sshc->auth_methods & SSH_AUTH_METHOD_INTERACTIVE ?
 827          "keyboard-interactive, " : "",
 828          sshc->auth_methods & SSH_AUTH_METHOD_PASSWORD ?
 829          "password" : "");
 830  /* For public key auth we need either the private key or
 831     CURLSSH_AUTH_AGENT. */
 832  if((sshc->auth_methods & SSH_AUTH_METHOD_PUBLICKEY) &&
 833     (data->set.str[STRING_SSH_PRIVATE_KEY] ||
 834      (data->set.ssh_auth_types & CURLSSH_AUTH_AGENT))) {
 835    myssh_to(data, sshc, SSH_AUTH_PKEY_INIT);
 836    infof(data, "Authentication using SSH public key file");
 837  }
 838  else if(sshc->auth_methods & SSH_AUTH_METHOD_GSSAPI_MIC) {
 839    myssh_to(data, sshc, SSH_AUTH_GSSAPI);
 840  }
 841  else if(sshc->auth_methods & SSH_AUTH_METHOD_INTERACTIVE) {
 842    myssh_to(data, sshc, SSH_AUTH_KEY_INIT);
 843  }
 844  else if(sshc->auth_methods & SSH_AUTH_METHOD_PASSWORD) {
 845    myssh_to(data, sshc, SSH_AUTH_PASS_INIT);
 846  }
 847  else {                  /* unsupported authentication method */
 848    rc = myssh_to_ERROR(data, sshc, CURLE_LOGIN_DENIED);
 849  }
 850  return rc;
 851}
 852
 853static int myssh_in_AUTH_PKEY_INIT(struct Curl_easy *data,
 854                                   struct ssh_conn *sshc)
 855{
 856  int rc;
 857  if(!(data->set.ssh_auth_types & CURLSSH_AUTH_PUBLICKEY)) {
 858    rc = myssh_to_GSSAPI_AUTH(data, sshc);
 859    return rc;
 860  }
 861
 862  /* Two choices, (1) private key was given on CMD,
 863   * (2) use the "default" keys. */
 864  if(data->set.str[STRING_SSH_PRIVATE_KEY]) {
 865    if(sshc->pubkey && !data->set.ssl.key_passwd) {
 866      rc = ssh_userauth_try_publickey(sshc->ssh_session, NULL, sshc->pubkey);
 867      if(rc == SSH_AUTH_AGAIN)
 868        return SSH_AGAIN;
 869
 870      if(rc != SSH_OK) {
 871        rc = myssh_to_GSSAPI_AUTH(data, sshc);
 872        return rc;
 873      }
 874    }
 875
 876    rc = ssh_pki_import_privkey_file(data->
 877                                     set.str[STRING_SSH_PRIVATE_KEY],
 878                                     data->set.ssl.key_passwd, NULL,
 879                                     NULL, &sshc->privkey);
 880    if(rc != SSH_OK) {
 881      failf(data, "Could not load private key file %s",
 882            data->set.str[STRING_SSH_PRIVATE_KEY]);
 883      rc = myssh_to_ERROR(data, sshc, CURLE_LOGIN_DENIED);
 884      return rc;
 885    }
 886
 887    myssh_to(data, sshc, SSH_AUTH_PKEY);
 888  }
 889  else {
 890    rc = ssh_userauth_publickey_auto(sshc->ssh_session, NULL,
 891                                     data->set.ssl.key_passwd);
 892    if(rc == SSH_AUTH_AGAIN)
 893      return SSH_AGAIN;
 894
 895    if(rc == SSH_AUTH_SUCCESS) {
 896      rc = SSH_OK;
 897      sshc->authed = TRUE;
 898      infof(data, "Completed public key authentication");
 899      myssh_to(data, sshc, SSH_AUTH_DONE);
 900      return rc;
 901    }
 902
 903    rc = myssh_to_GSSAPI_AUTH(data, sshc);
 904  }
 905  return rc;
 906}
 907
 908static int myssh_in_AUTH_PKEY(struct Curl_easy *data,
 909                              struct ssh_conn *sshc)
 910{
 911  int rc = ssh_userauth_publickey(sshc->ssh_session, NULL, sshc->privkey);
 912  if(rc == SSH_AUTH_AGAIN)
 913    return SSH_AGAIN;
 914  else if(rc == SSH_AUTH_SUCCESS) {
 915    sshc->authed = TRUE;
 916    infof(data, "Completed public key authentication");
 917    myssh_to(data, sshc, SSH_AUTH_DONE);
 918    return SSH_OK;
 919  }
 920  else {
 921    infof(data, "Failed public key authentication (rc: %d)", rc);
 922    return myssh_to_GSSAPI_AUTH(data, sshc);
 923  }
 924}
 925
 926static int myssh_in_AUTH_GSSAPI(struct Curl_easy *data,
 927                                struct ssh_conn *sshc)
 928{
 929  int rc;
 930  if(!(data->set.ssh_auth_types & CURLSSH_AUTH_GSSAPI))
 931    return myssh_to_KEY_AUTH(data, sshc);
 932
 933  rc = ssh_userauth_gssapi(sshc->ssh_session);
 934  if(rc == SSH_AUTH_AGAIN)
 935    return SSH_AGAIN;
 936
 937  if(rc == SSH_AUTH_SUCCESS) {
 938    sshc->authed = TRUE;
 939    infof(data, "Completed gssapi authentication");
 940    myssh_to(data, sshc, SSH_AUTH_DONE);
 941    return SSH_OK;
 942  }
 943
 944  return myssh_to_KEY_AUTH(data, sshc);
 945}
 946
 947static int myssh_in_AUTH_KEY_INIT(struct Curl_easy *data,
 948                                  struct ssh_conn *sshc)
 949{
 950  if(data->set.ssh_auth_types & CURLSSH_AUTH_KEYBOARD) {
 951    myssh_to(data, sshc, SSH_AUTH_KEY);
 952    return SSH_NO_ERROR;
 953  }
 954  return myssh_to_PASSWD_AUTH(data, sshc);
 955}
 956
 957static int myssh_in_AUTH_KEY(struct Curl_easy *data,
 958                             struct ssh_conn *sshc)
 959{
 960  /* keyboard-interactive authentication */
 961  int rc = myssh_auth_interactive(data->conn, sshc);
 962  if(rc == SSH_AGAIN)
 963    return rc;
 964  else if(rc == SSH_OK) {
 965    sshc->authed = TRUE;
 966    infof(data, "completed keyboard interactive authentication");
 967    myssh_to(data, sshc, SSH_AUTH_DONE);
 968    return SSH_NO_ERROR;
 969  }
 970  else
 971    return myssh_to_PASSWD_AUTH(data, sshc);
 972}
 973
 974static int myssh_in_AUTH_PASS_INIT(struct Curl_easy *data,
 975                                   struct ssh_conn *sshc)
 976{
 977  if(!(data->set.ssh_auth_types & CURLSSH_AUTH_PASSWORD))
 978    return myssh_to_ERROR(data, sshc, CURLE_LOGIN_DENIED);
 979  myssh_to(data, sshc, SSH_AUTH_PASS);
 980  return SSH_NO_ERROR;
 981}
 982
 983static int myssh_in_AUTH_PASS(struct Curl_easy *data,
 984                              struct ssh_conn *sshc)
 985{
 986  int rc = ssh_userauth_password(sshc->ssh_session, NULL,
 987                                 Curl_creds_passwd(data->conn->creds));
 988  if(rc == SSH_AUTH_AGAIN)
 989    return SSH_AGAIN;
 990  else if(rc == SSH_AUTH_SUCCESS) {
 991    sshc->authed = TRUE;
 992    infof(data, "Completed password authentication");
 993    myssh_to(data, sshc, SSH_AUTH_DONE);
 994    return SSH_NO_ERROR;
 995  }
 996  return myssh_to_ERROR(data, sshc, CURLE_LOGIN_DENIED);
 997}
 998
 999static int myssh_in_AUTH_DONE(struct Curl_easy *data,
1000                              struct ssh_conn *sshc)
1001{
1002  struct connectdata *conn = data->conn;
1003  if(!sshc->authed) {
1004    failf(data, "Authentication failure");
1005    return myssh_to_ERROR(data, sshc, CURLE_LOGIN_DENIED);
1006  }
1007
1008  /* At this point we have an authenticated ssh session. */
1009  infof(data, "Authentication complete");
1010  Curl_pgrsTime(data, TIMER_APPCONNECT);      /* SSH is connected */
1011  conn->recv_idx = FIRSTSOCKET;
1012  conn->send_idx = -1;
1013
1014  if(conn->scheme->protocol == CURLPROTO_SFTP) {
1015    myssh_to(data, sshc, SSH_SFTP_INIT);
1016    return SSH_NO_ERROR;
1017  }
1018  infof(data, "SSH CONNECT phase done");
1019  myssh_to(data, sshc, SSH_STOP);
1020  return SSH_NO_ERROR;
1021}
1022
1023static int myssh_in_UPLOAD_INIT(struct Curl_easy *data,
1024                                struct ssh_conn *sshc,
1025                                struct SSHPROTO *sshp)
1026{
1027  int flags;
1028  int rc = 0;
1029
1030  if(!sshp)
1031    return myssh_to_ERROR(data, sshc, CURLE_FAILED_INIT);
1032
1033  if(data->state.resume_from) {
1034    sftp_attributes attrs;
1035
1036    if(data->state.resume_from < 0) {
1037      attrs = sftp_stat(sshc->sftp_session, sshp->path);
1038      if(attrs) {
1039        curl_off_t size = attrs->size;
1040        sftp_attributes_free(attrs);
1041        if(size < 0) {
1042          failf(data, "Bad file size (%" FMT_OFF_T ")", size);
1043          rc = myssh_to_ERROR(data, sshc, CURLE_BAD_DOWNLOAD_RESUME);
1044          return rc;
1045        }
1046        data->state.resume_from = size;
1047      }
1048      else {
1049        data->state.resume_from = 0;
1050      }
1051    }
1052  }
1053
1054  if(data->set.remote_append) {
1055    /* True append mode: create if nonexisting */
1056    flags = O_WRONLY | O_CREAT | O_APPEND;
1057  }
1058  else if(data->state.resume_from > 0) {
1059    /*
1060     * Resume MUST NOT use O_APPEND. Many SFTP servers/impls force all
1061     * writes to EOF when O_APPEND is set, ignoring a prior seek().
1062     * Open write-only and seek to the resume offset instead.
1063     */
1064    flags = O_WRONLY;
1065  }
1066  else
1067    /* Clear file before writing (normal behavior) */
1068    flags = O_WRONLY | O_CREAT | O_TRUNC;
1069
1070  if(sshc->sftp_file)
1071    sftp_close(sshc->sftp_file);
1072  sshc->sftp_file =
1073    sftp_open(sshc->sftp_session, sshp->path,
1074              flags, (mode_t)data->set.new_file_perms);
1075  if(!sshc->sftp_file) {
1076    int err = sftp_get_error(sshc->sftp_session);
1077
1078    if((err == SSH_FX_NO_SUCH_FILE ||
1079        err == SSH_FX_FAILURE ||
1080        err == SSH_FX_NO_SUCH_PATH) &&
1081       data->set.ftp_create_missing_dirs &&
1082       (strlen(sshp->path) > 1)) {
1083      /* try to create the path remotely */
1084      rc = 0;
1085      sshc->secondCreateDirs = 1;
1086      myssh_to(data, sshc, SSH_SFTP_CREATE_DIRS_INIT);
1087      return rc;
1088    }
1089    else {
1090      rc = myssh_to_SFTP_CLOSE(data, sshc);
1091      return rc;
1092    }
1093  }
1094
1095  /* If we have a restart point then we need to seek to the correct
1096     position. Skip if in explicit remote append mode. */
1097  if(data->state.resume_from > 0 && !data->set.remote_append) {
1098    int seekerr = CURL_SEEKFUNC_OK;
1099    /* Let's read off the proper amount of bytes from the input. */
1100    if(data->set.seek_func) {
1101      Curl_set_in_callback(data, TRUE);
1102      seekerr = data->set.seek_func(data->set.seek_client,
1103                                    data->state.resume_from, SEEK_SET);
1104      Curl_set_in_callback(data, FALSE);
1105    }
1106
1107    if(seekerr != CURL_SEEKFUNC_OK) {
1108      curl_off_t passed = 0;
1109
1110      if(seekerr != CURL_SEEKFUNC_CANTSEEK) {
1111        failf(data, "Could not seek stream");
1112        rc = myssh_to_ERROR(data, sshc, CURLE_FTP_COULDNT_USE_REST);
1113        return rc;
1114      }
1115      /* seekerr == CURL_SEEKFUNC_CANTSEEK (cannot seek to offset) */
1116      do {
1117        char scratch[4 * 1024];
1118        size_t readthisamountnow =
1119          (data->state.resume_from - passed >
1120           (curl_off_t)sizeof(scratch)) ?
1121          sizeof(scratch) : curlx_sotouz(data->state.resume_from - passed);
1122
1123        size_t actuallyread =
1124          data->state.fread_func(scratch, 1,
1125                                 readthisamountnow, data->state.in);
1126
1127        passed += actuallyread;
1128        if((actuallyread == 0) || (actuallyread > readthisamountnow)) {
1129          /* this checks for greater-than only to make sure that the
1130             CURL_READFUNC_ABORT return code still aborts */
1131          failf(data, "Failed to read data");
1132          rc = myssh_to_ERROR(data, sshc, CURLE_FTP_COULDNT_USE_REST);
1133          return rc;
1134        }
1135      } while(passed < data->state.resume_from);
1136    }
1137
1138    /* now, decrease the size of the read */
1139    if(data->state.infilesize > 0) {
1140      if(data->state.resume_from > data->state.infilesize) {
1141        failf(data, "Resume point beyond size");
1142        return myssh_to_ERROR(data, sshc, CURLE_BAD_FUNCTION_ARGUMENT);
1143      }
1144      data->state.infilesize -= data->state.resume_from;
1145      data->req.size = data->state.infilesize;
1146      Curl_pgrsSetUploadSize(data, data->state.infilesize);
1147    }
1148
1149    rc = sftp_seek64(sshc->sftp_file, data->state.resume_from);
1150    if(rc) {
1151      rc = myssh_to_SFTP_CLOSE(data, sshc);
1152      return rc;
1153    }
1154  }
1155  if(data->state.infilesize > 0) {
1156    data->req.size = data->state.infilesize;
1157    Curl_pgrsSetUploadSize(data, data->state.infilesize);
1158  }
1159  /* upload data */
1160  Curl_xfer_setup_send(data, FIRSTSOCKET);
1161
1162  /* not set by Curl_xfer_setup to preserve io_flags */
1163  data->conn->recv_idx = FIRSTSOCKET;
1164
1165  /* since we do not really wait for anything at this point, we want the
1166     state machine to move on as soon as possible so we mark this as dirty */
1167  Curl_multi_mark_dirty(data);
1168#if LIBSSH_VERSION_INT > SSH_VERSION_INT(0, 11, 0)
1169  sshc->sftp_send_state = 0;
1170#endif
1171  myssh_to(data, sshc, SSH_STOP);
1172  return rc;
1173}
1174
1175static int myssh_in_SFTP_DOWNLOAD_INIT(struct Curl_easy *data,
1176                                       struct ssh_conn *sshc,
1177                                       struct SSHPROTO *sshp)
1178{
1179  if(!sshp)
1180    return myssh_to_ERROR(data, sshc, CURLE_FAILED_INIT);
1181  /* Work on getting the specified file */
1182  if(sshc->sftp_file)
1183    sftp_close(sshc->sftp_file);
1184
1185  sshc->sftp_file = sftp_open(sshc->sftp_session, sshp->path,
1186                              O_RDONLY, (mode_t)data->set.new_file_perms);
1187  if(!sshc->sftp_file) {
1188    failf(data, "Could not open remote file for reading: %s",
1189          ssh_get_error(sshc->ssh_session));
1190
1191    return myssh_to_SFTP_CLOSE(data, sshc);
1192  }
1193  sftp_file_set_nonblocking(sshc->sftp_file);
1194  myssh_to(data, sshc, SSH_SFTP_DOWNLOAD_STAT);
1195  return SSH_NO_ERROR;
1196}
1197
1198static int myssh_in_SFTP_DOWNLOAD_STAT(struct Curl_easy *data,
1199                                       struct ssh_conn *sshc)
1200{
1201  curl_off_t size;
1202  int rc = 0;
1203  sftp_attributes attrs = sftp_fstat(sshc->sftp_file);
1204  if(!attrs ||
1205     !(attrs->flags & SSH_FILEXFER_ATTR_SIZE) ||
1206     (attrs->size == 0)) {
1207    /*
1208     * sftp_fstat did not return an error, so maybe the server
1209     * does not support stat()
1210     * OR the server does not return a file size with a stat()
1211     * OR file size is 0
1212     */
1213    data->req.size = -1;
1214    data->req.maxdownload = -1;
1215    Curl_pgrsSetDownloadSize(data, -1);
1216    size = 0;
1217    if(attrs)
1218      sftp_attributes_free(attrs);
1219  }
1220  else {
1221    size = attrs->size;
1222
1223    sftp_attributes_free(attrs);
1224
1225    if(size < 0) {
1226      failf(data, "Bad file size (%" FMT_OFF_T ")", size);
1227      return myssh_to_ERROR(data, sshc, CURLE_BAD_DOWNLOAD_RESUME);
1228    }
1229    if(data->state.use_range) {
1230      curl_off_t from;
1231      CURLcode result = Curl_ssh_range(data, data->state.range, size,
1232                                       &from, &size);
1233      if(result)
1234        return myssh_to_ERROR(data, sshc, result);
1235
1236      rc = sftp_seek64(sshc->sftp_file, from);
1237      if(rc)
1238        return myssh_to_SFTP_CLOSE(data, sshc);
1239    }
1240    data->req.size = size;
1241    data->req.maxdownload = size;
1242    Curl_pgrsSetDownloadSize(data, size);
1243  }
1244
1245  /* We can resume if we can seek to the resume position */
1246  if(data->state.resume_from) {
1247    if(data->state.resume_from < 0) {
1248      /* We are supposed to download the last abs(from) bytes */
1249      if(size < -data->state.resume_from) {
1250        failf(data, "Offset (%" FMT_OFF_T ") was beyond file size (%"
1251              FMT_OFF_T ")", data->state.resume_from, size);
1252        return myssh_to_ERROR(data, sshc, CURLE_BAD_DOWNLOAD_RESUME);
1253      }
1254      /* download from where? */
1255      data->state.resume_from += size;
1256    }
1257    else {
1258      if(size < data->state.resume_from) {
1259        failf(data, "Offset (%" FMT_OFF_T
1260              ") was beyond file size (%" FMT_OFF_T ")",
1261              data->state.resume_from, size);
1262        return myssh_to_ERROR(data, sshc, CURLE_BAD_DOWNLOAD_RESUME);
1263      }
1264    }
1265    /* Now store the number of bytes we are expected to download */
1266    data->req.size = size - data->state.resume_from;
1267    data->req.maxdownload = size - data->state.resume_from;
1268    Curl_pgrsSetDownloadSize(data, size - data->state.resume_from);
1269
1270    rc = sftp_seek64(sshc->sftp_file, data->state.resume_from);
1271    if(rc)
1272      return myssh_to_SFTP_CLOSE(data, sshc);
1273  }
1274
1275  /* Setup the actual download */
1276  if(data->req.size == 0) {
1277    /* no data to transfer */
1278    Curl_xfer_setup_nop(data);
1279    infof(data, "File already completely downloaded");
1280    myssh_to(data, sshc, SSH_STOP);
1281    return rc;
1282  }
1283  Curl_xfer_setup_recv(data, FIRSTSOCKET, data->req.size);
1284
1285  /* not set by Curl_xfer_setup to preserve io_flags */
1286  data->conn->send_idx = 0;
1287
1288  sshc->sftp_recv_state = 0;
1289  myssh_to(data, sshc, SSH_STOP);
1290
1291  return rc;
1292}
1293
1294static int myssh_in_SFTP_CLOSE(struct Curl_easy *data,
1295                               struct ssh_conn *sshc,
1296                               struct SSHPROTO *sshp)
1297{
1298  if(!sshp)
1299    return myssh_to_ERROR(data, sshc, CURLE_FAILED_INIT);
1300  if(sshc->sftp_file) {
1301    sftp_close(sshc->sftp_file);
1302    sshc->sftp_file = NULL;
1303  }
1304  curlx_safefree(sshp->path);
1305
1306  CURL_TRC_SSH(data, "SFTP DONE done");
1307
1308  /* Check if nextstate is set and move .nextstate could be POSTQUOTE_INIT
1309     After nextstate is executed, the control should come back to
1310     SSH_SFTP_CLOSE to pass the correct result back */
1311  if(sshc->nextstate != SSH_NO_STATE &&
1312     sshc->nextstate != SSH_SFTP_CLOSE) {
1313    myssh_to(data, sshc, sshc->nextstate);
1314    sshc->nextstate = SSH_SFTP_CLOSE;
1315  }
1316  else {
1317    myssh_to(data, sshc, SSH_STOP);
1318  }
1319  return SSH_NO_ERROR;
1320}
1321
1322static int myssh_in_SFTP_SHUTDOWN(struct Curl_easy *data,
1323                                  struct ssh_conn *sshc)
1324{
1325  /* during times we get here due to a broken transfer and then the
1326     sftp_handle might not have been taken down so make sure that is done
1327     before we proceed */
1328  ssh_set_blocking(sshc->ssh_session, 0);
1329#if LIBSSH_VERSION_INT > SSH_VERSION_INT(0, 11, 0)
1330  SFTP_AIO_FREE(sshc->sftp_send_aio);
1331  SFTP_AIO_FREE(sshc->sftp_recv_aio);
1332#endif
1333
1334  if(sshc->sftp_file) {
1335    sftp_close(sshc->sftp_file);
1336    sshc->sftp_file = NULL;
1337  }
1338
1339  if(sshc->sftp_session) {
1340    sftp_free(sshc->sftp_session);
1341    sshc->sftp_session = NULL;
1342  }
1343
1344  SSH_STRING_FREE_CHAR(sshc->homedir);
1345
1346  myssh_to(data, sshc, SSH_SESSION_DISCONNECT);
1347  return SSH_NO_ERROR;
1348}
1349
1350static int myssh_in_SFTP_INIT(struct Curl_easy *data,
1351                              struct ssh_conn *sshc)
1352{
1353  int rc;
1354  ssh_set_blocking(sshc->ssh_session, 1);
1355
1356  sshc->sftp_session = sftp_new(sshc->ssh_session);
1357  if(!sshc->sftp_session) {
1358    failf(data, "Failure initializing sftp session: %s",
1359          ssh_get_error(sshc->ssh_session));
1360    return myssh_to_ERROR(data, sshc, CURLE_COULDNT_CONNECT);
1361  }
1362
1363  rc = sftp_init(sshc->sftp_session);
1364  if(rc != SSH_OK) {
1365    failf(data, "Failure initializing sftp session: %s",
1366          ssh_get_error(sshc->ssh_session));
1367    return myssh_to_ERROR(data, sshc, sftp_error_to_CURLE(SSH_FX_FAILURE));
1368  }
1369  myssh_to(data, sshc, SSH_SFTP_REALPATH);
1370  return SSH_NO_ERROR;
1371}
1372
1373static int myssh_in_SFTP_REALPATH(struct Curl_easy *data,
1374                                  struct ssh_conn *sshc)
1375{
1376  /* Get the "home" directory */
1377  sshc->homedir = sftp_canonicalize_path(sshc->sftp_session, ".");
1378  if(!sshc->homedir)
1379    return myssh_to_ERROR(data, sshc, CURLE_COULDNT_CONNECT);
1380
1381  curlx_free(data->state.most_recent_ftp_entrypath);
1382  data->state.most_recent_ftp_entrypath = curlx_strdup(sshc->homedir);
1383  if(!data->state.most_recent_ftp_entrypath)
1384    return myssh_to_ERROR(data, sshc, CURLE_OUT_OF_MEMORY);
1385
1386  /* This is the last step in the SFTP connect phase. Do note that while
1387     we get the homedir here, we get the "workingpath" in the DO action
1388     since the homedir remains the same between request but the
1389     working path does not. */
1390  CURL_TRC_SSH(data, "CONNECT phase done");
1391  myssh_to(data, sshc, SSH_STOP);
1392  return SSH_NO_ERROR;
1393}
1394
1395static int myssh_in_SFTP_QUOTE_INIT(struct Curl_easy *data,
1396                                    struct ssh_conn *sshc,
1397                                    struct SSHPROTO *sshp)
1398{
1399  CURLcode result;
1400
1401  if(!sshp)
1402    return myssh_to_ERROR(data, sshc, CURLE_FAILED_INIT);
1403
1404  result = Curl_getworkingpath(data, sshc->homedir, &sshp->path);
1405  if(result) {
1406    sshc->actualcode = result;
1407    myssh_to(data, sshc, SSH_STOP);
1408  }
1409  else if(data->set.quote) {
1410    infof(data, "Sending quote commands");
1411    sshc->quote_item = data->set.quote;
1412    myssh_to(data, sshc, SSH_SFTP_QUOTE);
1413  }
1414  else
1415    myssh_to(data, sshc, SSH_SFTP_GETINFO);
1416  return SSH_NO_ERROR;
1417}
1418
1419static int myssh_in_SFTP_POSTQUOTE_INIT(struct Curl_easy *data,
1420                                        struct ssh_conn *sshc)
1421{
1422  if(data->set.postquote) {
1423    infof(data, "Sending quote commands");
1424    sshc->quote_item = data->set.postquote;
1425    myssh_to(data, sshc, SSH_SFTP_QUOTE);
1426  }
1427  else {
1428    myssh_to(data, sshc, SSH_STOP);
1429  }
1430  return SSH_NO_ERROR;
1431}
1432
1433static int quote_error(struct Curl_easy *data,
1434                       struct ssh_conn *sshc)
1435{
1436  failf(data, "Suspicious data after the command line");
1437  curlx_safefree(sshc->quote_path1);
1438  curlx_safefree(sshc->quote_path2);
1439  myssh_to(data, sshc, SSH_SFTP_CLOSE);
1440  sshc->nextstate = SSH_NO_STATE;
1441  sshc->actualcode = CURLE_QUOTE_ERROR;
1442  return SSH_NO_ERROR;
1443}
1444
1445static int myssh_in_SFTP_QUOTE(struct Curl_easy *data,
1446                               struct ssh_conn *sshc,
1447                               struct SSHPROTO *sshp)
1448{
1449  const char *cp;
1450  CURLcode result;
1451
1452  /*
1453   * Support some of the "FTP" commands
1454   */
1455  const char *cmd = sshc->quote_item->data;
1456  sshc->acceptfail = FALSE;
1457
1458  if(!sshp)
1459    return myssh_to_ERROR(data, sshc, CURLE_FAILED_INIT);
1460
1461  /* if a command starts with an asterisk, which a legal SFTP command never
1462     can, the command is allowed to fail without it causing any
1463     aborts or cancels etc. It causes libcurl to act as if the command
1464     is successful, whatever the server responds. */
1465
1466  if(cmd[0] == '*') {
1467    cmd++;
1468    sshc->acceptfail = TRUE;
1469  }
1470
1471  if(curl_strequal("pwd", cmd)) {
1472    /* output debug output if that is requested */
1473    char *tmp = curl_maprintf("257 \"%s\" is current directory.\n",
1474                              sshp->path);
1475    if(!tmp) {
1476      sshc->actualcode = CURLE_OUT_OF_MEMORY;
1477      myssh_to(data, sshc, SSH_SFTP_CLOSE);
1478      sshc->nextstate = SSH_NO_STATE;
1479      return SSH_NO_ERROR;
1480    }
1481    Curl_debug(data, CURLINFO_HEADER_OUT, "PWD\n", 4);
1482    Curl_debug(data, CURLINFO_HEADER_IN, tmp, strlen(tmp));
1483
1484    /* this sends an FTP-like "header" to the header callback so that
1485       the current directory can be read similar to how it is read when
1486       using ordinary FTP. */
1487    result = Curl_client_write(data, CLIENTWRITE_HEADER, tmp, strlen(tmp));
1488    curlx_free(tmp);
1489    if(result) {
1490      myssh_to(data, sshc, SSH_SFTP_CLOSE);
1491      sshc->nextstate = SSH_NO_STATE;
1492      sshc->actualcode = result;
1493    }
1494    else
1495      myssh_to(data, sshc, SSH_SFTP_NEXT_QUOTE);
1496    return SSH_NO_ERROR;
1497  }
1498
1499  /*
1500   * the arguments following the command must be separated from the
1501   * command with a space so we can check for it unconditionally
1502   */
1503  cp = strchr(cmd, ' ');
1504  if(!cp) {
1505    failf(data, "Syntax error in SFTP command. Supply parameter(s)");
1506    myssh_to(data, sshc, SSH_SFTP_CLOSE);
1507    sshc->nextstate = SSH_NO_STATE;
1508    sshc->actualcode = CURLE_QUOTE_ERROR;
1509    return SSH_NO_ERROR;
1510  }
1511
1512  /*
1513   * also, every command takes at least one argument so we get that
1514   * first argument right now
1515   */
1516  result = Curl_get_pathname(&cp, &sshc->quote_path1, sshc->homedir);
1517  if(result) {
1518    if(result == CURLE_OUT_OF_MEMORY)
1519      failf(data, "Out of memory");
1520    else
1521      failf(data, "Syntax error: Bad first parameter");
1522    myssh_to(data, sshc, SSH_SFTP_CLOSE);
1523    sshc->nextstate = SSH_NO_STATE;
1524    sshc->actualcode = result;
1525    return SSH_NO_ERROR;
1526  }
1527
1528  /*
1529   * SFTP is a binary protocol, so we do not send text commands
1530   * to the server. Instead, we scan for commands used by
1531   * OpenSSH's sftp program and call the appropriate libssh
1532   * functions.
1533   */
1534  if(!strncmp(cmd, "chgrp ", 6) ||
1535     !strncmp(cmd, "chmod ", 6) ||
1536     !strncmp(cmd, "chown ", 6) ||
1537     !strncmp(cmd, "atime ", 6) ||
1538     !strncmp(cmd, "mtime ", 6)) {
1539    /* attribute change */
1540
1541    /* sshc->quote_path1 contains the mode to set */
1542    /* get the destination */
1543    result = Curl_get_pathname(&cp, &sshc->quote_path2, sshc->homedir);
1544    if(result) {
1545      if(result == CURLE_OUT_OF_MEMORY)
1546        failf(data, "Out of memory");
1547      else
1548        failf(data, "Syntax error in chgrp/chmod/chown/atime/mtime: "
1549              "Bad second parameter");
1550      curlx_safefree(sshc->quote_path1);
1551      myssh_to(data, sshc, SSH_SFTP_CLOSE);
1552      sshc->nextstate = SSH_NO_STATE;
1553      sshc->actualcode = result;
1554      return SSH_NO_ERROR;
1555    }
1556    if(*cp)
1557      return quote_error(data, sshc);
1558    sshc->quote_attrs = NULL;
1559    myssh_to(data, sshc, SSH_SFTP_QUOTE_STAT);
1560    return SSH_NO_ERROR;
1561  }
1562  if(!strncmp(cmd, "ln ", 3) ||
1563     !strncmp(cmd, "symlink ", 8)) {
1564    /* symbolic linking */
1565    /* sshc->quote_path1 is the source */
1566    /* get the destination */
1567    result = Curl_get_pathname(&cp, &sshc->quote_path2, sshc->homedir);
1568    if(result) {
1569      if(result == CURLE_OUT_OF_MEMORY)
1570        failf(data, "Out of memory");
1571      else
1572        failf(data, "Syntax error in ln/symlink: Bad second parameter");
1573      curlx_safefree(sshc->quote_path1);
1574      myssh_to(data, sshc, SSH_SFTP_CLOSE);
1575      sshc->nextstate = SSH_NO_STATE;
1576      sshc->actualcode = result;
1577      return SSH_NO_ERROR;
1578    }
1579    if(*cp)
1580      return quote_error(data, sshc);
1581    myssh_to(data, sshc, SSH_SFTP_QUOTE_SYMLINK);
1582    return SSH_NO_ERROR;
1583  }
1584  else if(!strncmp(cmd, "mkdir ", 6)) {
1585    if(*cp)
1586      return quote_error(data, sshc);
1587    /* create directory */
1588    myssh_to(data, sshc, SSH_SFTP_QUOTE_MKDIR);
1589    return SSH_NO_ERROR;
1590  }
1591  else if(!strncmp(cmd, "rename ", 7)) {
1592    /* rename file */
1593    /* first param is the source path */
1594    /* second param is the dest. path */
1595    result = Curl_get_pathname(&cp, &sshc->quote_path2, sshc->homedir);
1596    if(result) {
1597      if(result == CURLE_OUT_OF_MEMORY)
1598        failf(data, "Out of memory");
1599      else
1600        failf(data, "Syntax error in rename: Bad second parameter");
1601      curlx_safefree(sshc->quote_path1);
1602      myssh_to(data, sshc, SSH_SFTP_CLOSE);
1603      sshc->nextstate = SSH_NO_STATE;
1604      sshc->actualcode = result;
1605      return SSH_NO_ERROR;
1606    }
1607    if(*cp)
1608      return quote_error(data, sshc);
1609    myssh_to(data, sshc, SSH_SFTP_QUOTE_RENAME);
1610    return SSH_NO_ERROR;
1611  }
1612  else if(!strncmp(cmd, "rmdir ", 6)) {
1613    /* delete directory */
1614    if(*cp)
1615      return quote_error(data, sshc);
1616    myssh_to(data, sshc, SSH_SFTP_QUOTE_RMDIR);
1617    return SSH_NO_ERROR;
1618  }
1619  else if(!strncmp(cmd, "rm ", 3)) {
1620    if(*cp)
1621      return quote_error(data, sshc);
1622    myssh_to(data, sshc, SSH_SFTP_QUOTE_UNLINK);
1623    return SSH_NO_ERROR;
1624  }
1625#ifdef HAS_STATVFS_SUPPORT
1626  else if(!strncmp(cmd, "statvfs ", 8)) {
1627    if(*cp)
1628      return quote_error(data, sshc);
1629    myssh_to(data, sshc, SSH_SFTP_QUOTE_STATVFS);
1630    return SSH_NO_ERROR;
1631  }
1632#endif
1633
1634  failf(data, "Unknown SFTP command");
1635  curlx_safefree(sshc->quote_path1);
1636  curlx_safefree(sshc->quote_path2);
1637  myssh_to(data, sshc, SSH_SFTP_CLOSE);
1638  sshc->nextstate = SSH_NO_STATE;
1639  sshc->actualcode = CURLE_QUOTE_ERROR;
1640  return SSH_NO_ERROR;
1641}
1642
1643static int myssh_in_SFTP_NEXT_QUOTE(struct Curl_easy *data,
1644                                    struct ssh_conn *sshc)
1645{
1646  curlx_safefree(sshc->quote_path1);
1647  curlx_safefree(sshc->quote_path2);
1648
1649  sshc->quote_item = sshc->quote_item->next;
1650
1651  if(sshc->quote_item) {
1652    myssh_to(data, sshc, SSH_SFTP_QUOTE);
1653  }
1654  else {
1655    if(sshc->nextstate != SSH_NO_STATE) {
1656      myssh_to(data, sshc, sshc->nextstate);
1657      sshc->nextstate = SSH_NO_STATE;
1658    }
1659    else {
1660      myssh_to(data, sshc, SSH_SFTP_GETINFO);
1661    }
1662  }
1663  return SSH_NO_ERROR;
1664}
1665
1666static int myssh_in_SFTP_QUOTE_STAT(struct Curl_easy *data,
1667                                    struct ssh_conn *sshc)
1668{
1669  const char *cmd = sshc->quote_item->data;
1670  sshc->acceptfail = FALSE;
1671
1672  /* if a command starts with an asterisk, which a legal SFTP command never
1673     can, the command is allowed to fail without it causing any
1674     aborts or cancels etc. It causes libcurl to act as if the command
1675     is successful, whatever the server responds. */
1676
1677  if(cmd[0] == '*') {
1678    cmd++;
1679    sshc->acceptfail = TRUE;
1680  }
1681
1682  /* We read the file attributes, store them in sshc->quote_attrs
1683   * and modify them accordingly to command. Then we switch to
1684   * QUOTE_SETSTAT state to write new ones.
1685   */
1686
1687  if(sshc->quote_attrs)
1688    sftp_attributes_free(sshc->quote_attrs);
1689  sshc->quote_attrs = sftp_stat(sshc->sftp_session, sshc->quote_path2);
1690  if(!sshc->quote_attrs) {
1691    failf(data, "Attempt to get SFTP stats failed: %d",
1692          sftp_get_error(sshc->sftp_session));
1693    myssh_quote_error(data, sshc, NULL);
1694    return SSH_NO_ERROR;
1695  }
1696
1697  /* Now set the new attributes... */
1698  if(!strncmp(cmd, "chgrp", 5)) {
1699    const char *p = sshc->quote_path1;
1700    curl_off_t gid;
1701    if(curlx_str_number(&p, &gid, UINT_MAX)) {
1702      failf(data, "Syntax error: chgrp gid not a number");
1703      myssh_quote_error(data, sshc, NULL);
1704      return SSH_NO_ERROR;
1705    }
1706    sshc->quote_attrs->gid = (uint32_t)gid;
1707    sshc->quote_attrs->flags |= SSH_FILEXFER_ATTR_UIDGID;
1708  }
1709  else if(!strncmp(cmd, "chmod", 5)) {
1710    curl_off_t perms;
1711    const char *p = sshc->quote_path1;
1712    if(curlx_str_octal(&p, &perms, 07777)) {
1713      failf(data, "Syntax error: chmod permissions not a number");
1714      myssh_quote_error(data, sshc, NULL);
1715      return SSH_NO_ERROR;
1716    }
1717    sshc->quote_attrs->permissions = (mode_t)perms;
1718    sshc->quote_attrs->flags |= SSH_FILEXFER_ATTR_PERMISSIONS;
1719  }
1720  else if(!strncmp(cmd, "chown", 5)) {
1721    const char *p = sshc->quote_path1;
1722    curl_off_t uid;
1723    if(curlx_str_number(&p, &uid, UINT_MAX)) {
1724      failf(data, "Syntax error: chown uid not a number");
1725      myssh_quote_error(data, sshc, NULL);
1726      return SSH_NO_ERROR;
1727    }
1728    sshc->quote_attrs->uid = (uint32_t)uid;
1729    sshc->quote_attrs->flags |= SSH_FILEXFER_ATTR_UIDGID;
1730  }
1731  else if(!strncmp(cmd, "atime", 5) ||
1732          !strncmp(cmd, "mtime", 5)) {
1733    time_t date;
1734    bool fail = FALSE;
1735    if(Curl_getdate_capped(sshc->quote_path1, &date)) {
1736      failf(data, "incorrect date format for %.*s", 5, cmd);
1737      fail = TRUE;
1738    }
1739#if SIZEOF_TIME_T > 4
1740    else if(date > 0xffffffff) {
1741      failf(data, "date overflow");
1742      fail = TRUE; /* avoid setting a capped time */
1743    }
1744#endif
1745    if(fail) {
1746      myssh_quote_error(data, sshc, NULL);
1747      return SSH_NO_ERROR;
1748    }
1749    if(!strncmp(cmd, "atime", 5))
1750      sshc->quote_attrs->atime = (uint32_t)date;
1751    else /* mtime */
1752      sshc->quote_attrs->mtime = (uint32_t)date;
1753
1754    sshc->quote_attrs->flags |= SSH_FILEXFER_ATTR_ACMODTIME;
1755  }
1756
1757  /* Now send the completed structure... */
1758  myssh_to(data, sshc, SSH_SFTP_QUOTE_SETSTAT);
1759  return SSH_NO_ERROR;
1760}
1761
1762static void conn_forget_socket(struct Curl_easy *data, int sockindex)
1763{
1764  struct connectdata *conn = data->conn;
1765  if(conn && CONN_SOCK_IDX_VALID(sockindex)) {
1766    struct Curl_cfilter *cf = conn->cfilter[sockindex];
1767    if(cf)
1768      (void)Curl_conn_cf_cntrl(cf, data, TRUE, CF_CTRL_FORGET_SOCKET, 0, NULL);
1769    fake_sclose(conn->sock[sockindex]);
1770    conn->sock[sockindex] = CURL_SOCKET_BAD;
1771  }
1772}
1773
1774static void myssh_SESSION_DISCONNECT(struct Curl_easy *data,
1775                                     struct ssh_conn *sshc)
1776{
1777  /* during weird times when we have been prematurely aborted, the channel
1778     is still alive when we reach this state and we MUST kill the channel
1779     properly first */
1780  if(sshc->scp_session) {
1781    ssh_scp_free(sshc->scp_session);
1782    sshc->scp_session = NULL;
1783  }
1784
1785  if(sshc->sftp_file) {
1786    sftp_close(sshc->sftp_file);
1787    sshc->sftp_file = NULL;
1788  }
1789  if(sshc->sftp_session) {
1790    sftp_free(sshc->sftp_session);
1791    sshc->sftp_session = NULL;
1792  }
1793
1794  ssh_disconnect(sshc->ssh_session);
1795  if(!ssh_version(SSH_VERSION_INT(0, 10, 0))) {
1796    /* conn->sock[FIRSTSOCKET] is closed by ssh_disconnect behind our back,
1797       tell the connection to forget about it. This libssh
1798       bug is fixed in 0.10.0. */
1799    conn_forget_socket(data, FIRSTSOCKET);
1800  }
1801
1802  SSH_STRING_FREE_CHAR(sshc->homedir);
1803
1804  myssh_to(data, sshc, SSH_SESSION_FREE);
1805}
1806
1807static int myssh_SSH_SCP_DOWNLOAD(struct Curl_easy *data,
1808                                  struct ssh_conn *sshc)
1809{
1810  curl_off_t bytecount;
1811  int rc = ssh_scp_pull_request(sshc->scp_session);
1812  if(rc != SSH_SCP_REQUEST_NEWFILE) {
1813    const char *err_msg = ssh_get_error(sshc->ssh_session);
1814    failf(data, "%s", err_msg);
1815    return myssh_to_ERROR(data, sshc, CURLE_REMOTE_FILE_NOT_FOUND);
1816  }
1817
1818  /* download data */
1819  bytecount = ssh_scp_request_get_size(sshc->scp_session);
1820  data->req.maxdownload = bytecount;
1821  Curl_xfer_setup_recv(data, FIRSTSOCKET, bytecount);
1822
1823  /* not set by Curl_xfer_setup to preserve io_flags */
1824  data->conn->send_idx = 0;
1825
1826  myssh_to(data, sshc, SSH_STOP);
1827  return 0;
1828}
1829
1830static int myssh_in_TRANS_INIT(struct Curl_easy *data, struct ssh_conn *sshc,
1831                               struct SSHPROTO *sshp)
1832{
1833  CURLcode result;
1834  int rc = 0;
1835  if(!sshp)
1836    return myssh_to_ERROR(data, sshc, CURLE_FAILED_INIT);
1837
1838  result = Curl_getworkingpath(data, sshc->homedir, &sshp->path);
1839  if(result) {
1840    sshc->actualcode = result;
1841    myssh_to(data, sshc, SSH_STOP);
1842    return 0;
1843  }
1844
1845  /* Functions from the SCP subsystem cannot handle/return SSH_AGAIN */
1846  ssh_set_blocking(sshc->ssh_session, 1);
1847
1848  if(data->state.upload) {
1849    if(data->state.infilesize < 0) {
1850      failf(data, "SCP requires a known file size for upload");
1851      return myssh_to_ERROR(data, sshc, CURLE_UPLOAD_FAILED);
1852    }
1853
1854    sshc->scp_session =
1855      ssh_scp_new(sshc->ssh_session, SSH_SCP_WRITE, sshp->path);
1856    myssh_to(data, sshc, SSH_SCP_UPLOAD_INIT);
1857  }
1858  else {
1859    sshc->scp_session =
1860      ssh_scp_new(sshc->ssh_session, SSH_SCP_READ, sshp->path);
1861    myssh_to(data, sshc, SSH_SCP_DOWNLOAD_INIT);
1862  }
1863
1864  if(!sshc->scp_session) {
1865    const char *err_msg = ssh_get_error(sshc->ssh_session);
1866    failf(data, "%s", err_msg);
1867    rc = myssh_to_ERROR(data, sshc, CURLE_UPLOAD_FAILED);
1868  }
1869  return rc;
1870}
1871
1872static void sshc_cleanup(struct ssh_conn *sshc)
1873{
1874  if(sshc->initialized) {
1875    if(sshc->sftp_file) {
1876      sftp_close(sshc->sftp_file);
1877      sshc->sftp_file = NULL;
1878    }
1879    if(sshc->sftp_session) {
1880      sftp_free(sshc->sftp_session);
1881      sshc->sftp_session = NULL;
1882    }
1883    if(sshc->ssh_session) {
1884      ssh_free(sshc->ssh_session);
1885      sshc->ssh_session = NULL;
1886    }
1887
1888    /* worst-case scenario cleanup */
1889    DEBUGASSERT(sshc->ssh_session == NULL);
1890    DEBUGASSERT(sshc->scp_session == NULL);
1891
1892    if(sshc->readdir_tmp) {
1893      ssh_string_free_char(sshc->readdir_tmp);
1894      sshc->readdir_tmp = NULL;
1895    }
1896    if(sshc->quote_attrs) {
1897      sftp_attributes_free(sshc->quote_attrs);
1898      sshc->quote_attrs = NULL;
1899    }
1900    if(sshc->readdir_attrs) {
1901      sftp_attributes_free(sshc->readdir_attrs);
1902      sshc->readdir_attrs = NULL;
1903    }
1904    if(sshc->readdir_link_attrs) {
1905      sftp_attributes_free(sshc->readdir_link_attrs);
1906      sshc->readdir_link_attrs = NULL;
1907    }
1908    if(sshc->privkey) {
1909      ssh_key_free(sshc->privkey);
1910      sshc->privkey = NULL;
1911    }
1912    if(sshc->pubkey) {
1913      ssh_key_free(sshc->pubkey);
1914      sshc->pubkey = NULL;
1915    }
1916
1917    curlx_safefree(sshc->rsa_pub);
1918    curlx_safefree(sshc->rsa);
1919    curlx_safefree(sshc->quote_path1);
1920    curlx_safefree(sshc->quote_path2);
1921    curlx_dyn_free(&sshc->readdir_buf);
1922    curlx_safefree(sshc->readdir_linkPath);
1923    SSH_STRING_FREE_CHAR(sshc->homedir);
1924    sshc->initialized = FALSE;
1925  }
1926}
1927
1928static int myssh_in_SFTP_QUOTE_SETSTAT(struct Curl_easy *data,
1929                                       struct ssh_conn *sshc)
1930{
1931  int rc = sftp_setstat(sshc->sftp_session, sshc->quote_path2,
1932                        sshc->quote_attrs);
1933  if(rc == SSH_AGAIN)
1934    return rc;
1935  if(rc && !sshc->acceptfail) {
1936    myssh_quote_error(data, sshc, "setstat");
1937    return rc;
1938  }
1939  myssh_to(data, sshc, SSH_SFTP_NEXT_QUOTE);
1940  return SSH_NO_ERROR;
1941}
1942
1943static int myssh_in_SFTP_QUOTE_SYMLINK(struct Curl_easy *data,
1944                                       struct ssh_conn *sshc)
1945{
1946  int rc = sftp_symlink(sshc->sftp_session, sshc->quote_path2,
1947                        sshc->quote_path1);
1948  if(rc == SSH_AGAIN)
1949    return rc;
1950  if(rc && !sshc->acceptfail) {
1951    myssh_quote_error(data, sshc, "symlink");
1952    return rc;
1953  }
1954  myssh_to(data, sshc, SSH_SFTP_NEXT_QUOTE);
1955  return SSH_NO_ERROR;
1956}
1957
1958static int myssh_in_SFTP_QUOTE_MKDIR(struct Curl_easy *data,
1959                                     struct ssh_conn *sshc)
1960{
1961  int rc = sftp_mkdir(sshc->sftp_session, sshc->quote_path1,
1962                      (mode_t)data->set.new_directory_perms);
1963  if(rc == SSH_AGAIN)
1964    return rc;
1965  if(rc && !sshc->acceptfail) {
1966    myssh_quote_error(data, sshc, "mkdir");
1967    return rc;
1968  }
1969  myssh_to(data, sshc, SSH_SFTP_NEXT_QUOTE);
1970  return SSH_NO_ERROR;
1971}
1972
1973static int myssh_in_SFTP_QUOTE_RENAME(struct Curl_easy *data,
1974                                      struct ssh_conn *sshc)
1975{
1976  int rc = sftp_rename(sshc->sftp_session, sshc->quote_path1,
1977                       sshc->quote_path2);
1978  if(rc == SSH_AGAIN)
1979    return rc;
1980  if(rc && !sshc->acceptfail) {
1981    myssh_quote_error(data, sshc, "rename");
1982    return rc;
1983  }
1984  myssh_to(data, sshc, SSH_SFTP_NEXT_QUOTE);
1985  return SSH_NO_ERROR;
1986}
1987
1988static int myssh_in_SFTP_QUOTE_RMDIR(struct Curl_easy *data,
1989                                     struct ssh_conn *sshc)
1990{
1991  int rc = sftp_rmdir(sshc->sftp_session, sshc->quote_path1);
1992  if(rc == SSH_AGAIN)
1993    return rc;
1994  if(rc && !sshc->acceptfail) {
1995    myssh_quote_error(data, sshc, "rmdir");
1996    return rc;
1997  }
1998  myssh_to(data, sshc, SSH_SFTP_NEXT_QUOTE);
1999  return SSH_NO_ERROR;
2000}
2001
2002static int myssh_in_SFTP_QUOTE_UNLINK(struct Curl_easy *data,
2003                                      struct ssh_conn *sshc)
2004{
2005  int rc = sftp_unlink(sshc->sftp_session, sshc->quote_path1);
2006  if(rc == SSH_AGAIN)
2007    return rc;
2008  if(rc && !sshc->acceptfail) {
2009    myssh_quote_error(data, sshc, "rm");
2010    return rc;
2011  }
2012  myssh_to(data, sshc, SSH_SFTP_NEXT_QUOTE);
2013  return SSH_NO_ERROR;
2014}
2015
2016static int myssh_in_SFTP_GETINFO(struct Curl_easy *data,
2017                                 struct ssh_conn *sshc)
2018{
2019  if(data->set.get_filetime)
2020    myssh_to(data, sshc, SSH_SFTP_FILETIME);
2021  else
2022    myssh_to(data, sshc, SSH_SFTP_TRANS_INIT);
2023  return SSH_NO_ERROR;
2024}
2025
2026static int myssh_in_SFTP_FILETIME(struct Curl_easy *data,
2027                                  struct ssh_conn *sshc,
2028                                  struct SSHPROTO *sshp)
2029{
2030  sftp_attributes attrs;
2031  if(!sshp)
2032    return myssh_to_ERROR(data, sshc, CURLE_FAILED_INIT);
2033
2034  attrs = sftp_stat(sshc->sftp_session, sshp->path);
2035  if(attrs) {
2036    data->info.filetime = attrs->mtime;
2037    sftp_attributes_free(attrs);
2038  }
2039
2040  myssh_to(data, sshc, SSH_SFTP_TRANS_INIT);
2041  return SSH_NO_ERROR;
2042}
2043
2044static int myssh_in_SFTP_TRANS_INIT(struct Curl_easy *data,
2045                                    struct ssh_conn *sshc,
2046                                    struct SSHPROTO *sshp)
2047{
2048  if(!sshp)
2049    return myssh_to_ERROR(data, sshc, CURLE_FAILED_INIT);
2050  if(data->state.upload)
2051    myssh_to(data, sshc, SSH_SFTP_UPLOAD_INIT);
2052  else {
2053    size_t path_len = strlen(sshp->path);
2054
2055    if(path_len && sshp->path[path_len - 1] == '/')
2056      myssh_to(data, sshc, SSH_SFTP_READDIR_INIT);
2057    else
2058      myssh_to(data, sshc, SSH_SFTP_DOWNLOAD_INIT);
2059  }
2060
2061  return SSH_NO_ERROR;
2062}
2063
2064static int myssh_in_SFTP_CREATE_DIRS_INIT(struct Curl_easy *data,
2065                                          struct ssh_conn *sshc,
2066                                          struct SSHPROTO *sshp)
2067{
2068  if(!sshp)
2069    return myssh_to_ERROR(data, sshc, CURLE_FAILED_INIT);
2070
2071  if(strlen(sshp->path) > 1) {
2072    sshc->slash_pos = sshp->path + 1; /* ignore the leading '/' */
2073    myssh_to(data, sshc, SSH_SFTP_CREATE_DIRS);
2074  }
2075  else {
2076    myssh_to(data, sshc, SSH_SFTP_UPLOAD_INIT);
2077  }
2078  return SSH_NO_ERROR;
2079}
2080
2081static int myssh_in_SFTP_CREATE_DIRS(struct Curl_easy *data,
2082                                     struct ssh_conn *sshc,
2083                                     struct SSHPROTO *sshp)
2084{
2085  if(!sshp)
2086    return myssh_to_ERROR(data, sshc, CURLE_FAILED_INIT);
2087
2088  sshc->slash_pos = strchr(sshc->slash_pos, '/');
2089  if(sshc->slash_pos) {
2090    *sshc->slash_pos = 0;
2091
2092    infof(data, "Creating directory '%s'", sshp->path);
2093    myssh_to(data, sshc, SSH_SFTP_CREATE_DIRS_MKDIR);
2094    return SSH_NO_ERROR;
2095  }
2096  myssh_to(data, sshc, SSH_SFTP_UPLOAD_INIT);
2097  return SSH_NO_ERROR;
2098}
2099
2100static int myssh_in_SFTP_CREATE_DIRS_MKDIR(struct Curl_easy *data,
2101                                           struct ssh_conn *sshc,
2102                                           struct SSHPROTO *sshp)
2103{
2104  int rc;
2105  int err;
2106  /* 'mode' - parameter is preliminary - default to 0644 */
2107  if(!sshp)
2108    return myssh_to_ERROR(data, sshc, CURLE_FAILED_INIT);
2109
2110  rc = sftp_mkdir(sshc->sftp_session, sshp->path,
2111                  (mode_t)data->set.new_directory_perms);
2112  if(rc == SSH_AGAIN)
2113    return rc;
2114  *sshc->slash_pos = '/';
2115  ++sshc->slash_pos;
2116  if(rc < 0) {
2117    /*
2118     * Abort if failure was not that the directory already
2119     * exists or the permission was denied (creation might
2120     * succeed further down the path) - retry on unspecific
2121     * FAILURE also
2122     */
2123    err = sftp_get_error(sshc->sftp_session);
2124    if((err != SSH_FX_FILE_ALREADY_EXISTS) &&
2125       (err != SSH_FX_FAILURE) &&
2126       (err != SSH_FX_PERMISSION_DENIED)) {
2127      return myssh_to_SFTP_CLOSE(data, sshc);
2128    }
2129    rc = 0; /* clear rc and continue */
2130  }
2131  myssh_to(data, sshc, SSH_SFTP_CREATE_DIRS);
2132  return rc;
2133}
2134
2135static int myssh_in_SCP_UPLOAD_INIT(struct Curl_easy *data,
2136                                    struct ssh_conn *sshc,
2137                                    struct SSHPROTO *sshp)
2138{
2139  int rc;
2140  if(!sshp)
2141    return myssh_to_ERROR(data, sshc, CURLE_FAILED_INIT);
2142
2143  rc = ssh_scp_init(sshc->scp_session);
2144  if(rc != SSH_OK) {
2145    const char *err_msg = ssh_get_error(sshc->ssh_session);
2146    failf(data, "%s", err_msg);
2147    return myssh_to_ERROR(data, sshc, CURLE_UPLOAD_FAILED);
2148  }
2149
2150  rc = ssh_scp_push_file64(sshc->scp_session, sshp->path,
2151                           (uint64_t)data->state.infilesize,
2152                           (int)data->set.new_file_perms);
2153
2154  if(rc != SSH_OK) {
2155    const char *err_msg = ssh_get_error(sshc->ssh_session);
2156    failf(data, "%s", err_msg);
2157    return myssh_to_ERROR(data, sshc, CURLE_UPLOAD_FAILED);
2158  }
2159
2160  /* upload data */
2161  Curl_xfer_setup_send(data, FIRSTSOCKET);
2162
2163  /* not set by Curl_xfer_setup to preserve io_flags */
2164  data->conn->recv_idx = FIRSTSOCKET;
2165
2166  myssh_to(data, sshc, SSH_STOP);
2167  return SSH_NO_ERROR;
2168}
2169
2170static int myssh_in_SCP_DOWNLOAD_INIT(struct Curl_easy *data,
2171                                      struct ssh_conn *sshc)
2172{
2173  int rc = ssh_scp_init(sshc->scp_session);
2174  if(rc != SSH_OK) {
2175    const char *err_msg = ssh_get_error(sshc->ssh_session);
2176    failf(data, "%s", err_msg);
2177    return myssh_to_ERROR(data, sshc,
2178                          CURLE_COULDNT_CONNECT);
2179  }
2180  myssh_to(data, sshc, SSH_SCP_DOWNLOAD);
2181  return SSH_NO_ERROR;
2182}
2183
2184static int myssh_in_SCP_DONE(struct Curl_easy *data,
2185                             struct ssh_conn *sshc)
2186{
2187  if(data->state.upload)
2188    myssh_to(data, sshc, SSH_SCP_SEND_EOF);
2189  else
2190    myssh_to(data, sshc, SSH_SCP_CHANNEL_FREE);
2191  return SSH_NO_ERROR;
2192}
2193
2194static int myssh_in_SCP_SEND_EOF(struct Curl_easy *data,
2195                                 struct ssh_conn *sshc)
2196{
2197  if(sshc->scp_session) {
2198    int rc = ssh_scp_close(sshc->scp_session);
2199    if(rc == SSH_AGAIN) {
2200      /* Currently the ssh_scp_close handles waiting for
2201       * EOF in blocking way.
2202       */
2203      return SSH_AGAIN;
2204    }
2205    if(rc != SSH_OK) {
2206      infof(data,
2207            "Failed to close libssh scp channel: %s",
2208            ssh_get_error(sshc->ssh_session));
2209    }
2210  }
2211
2212  myssh_to(data, sshc, SSH_SCP_CHANNEL_FREE);
2213  return SSH_NO_ERROR;
2214}
2215
2216static int myssh_in_SCP_CHANNEL_FREE(struct Curl_easy *data,
2217                                     struct ssh_conn *sshc)
2218{
2219  if(sshc->scp_session) {
2220    ssh_scp_free(sshc->scp_session);
2221    sshc->scp_session = NULL;
2222  }
2223  CURL_TRC_SSH(data, "SCP DONE phase complete");
2224
2225  ssh_set_blocking(sshc->ssh_session, 0);
2226
2227  myssh_to(data, sshc, SSH_SESSION_DISCONNECT);
2228  return SSH_NO_ERROR;
2229}
2230
2231static CURLcode myssh_in_SESSION_FREE(struct Curl_easy *data,
2232                                      struct ssh_conn *sshc)
2233{
2234  CURLcode result;
2235  sshc_cleanup(sshc);
2236  /* the code we are about to return */
2237  result = sshc->actualcode;
2238  memset(sshc, 0, sizeof(struct ssh_conn));
2239  connclose(data->conn, "SSH session free");
2240  sshc->state = SSH_SESSION_FREE;   /* current */
2241  sshc->nextstate = SSH_NO_STATE;
2242  myssh_to(data, sshc, SSH_STOP);
2243  return result;
2244}
2245
2246/*
2247 * myssh_statemachine() runs the SSH state machine as far as it can without
2248 * blocking and without reaching the end. The data the pointer 'block' points
2249 * to is set to TRUE if the libssh function returns SSH_AGAIN
2250 * meaning it wants to be called again when the socket is ready
2251 */
2252static CURLcode myssh_statemachine(struct Curl_easy *data,
2253                                   struct ssh_conn *sshc,
2254                                   struct SSHPROTO *sshp,
2255                                   bool *block)
2256{
2257  CURLcode result = CURLE_OK;
2258  int rc = SSH_NO_ERROR;
2259
2260  *block = FALSE;                   /* we are not blocking by default */
2261  do {
2262
2263    switch(sshc->state) {
2264    case SSH_INIT:
2265      myssh_state_init(data, sshc);
2266      FALLTHROUGH();
2267    case SSH_S_STARTUP:
2268      rc = myssh_in_S_STARTUP(data, sshc);
2269      if(rc)
2270        break;
2271      FALLTHROUGH();
2272    case SSH_HOSTKEY:
2273      rc = myssh_is_known(data, sshc);
2274      if(rc != SSH_OK) {
2275        rc = myssh_to_ERROR(data, sshc, CURLE_PEER_FAILED_VERIFICATION);
2276        break;
2277      }
2278      myssh_to(data, sshc, SSH_AUTHLIST);
2279      FALLTHROUGH();
2280    case SSH_AUTHLIST:
2281      rc = myssh_in_AUTHLIST(data, sshc);
2282      break;
2283    case SSH_AUTH_PKEY_INIT:
2284      rc = myssh_in_AUTH_PKEY_INIT(data, sshc);
2285      break;
2286    case SSH_AUTH_PKEY:
2287      rc = myssh_in_AUTH_PKEY(data, sshc);
2288      break;
2289    case SSH_AUTH_GSSAPI:
2290      rc = myssh_in_AUTH_GSSAPI(data, sshc);
2291      break;
2292    case SSH_AUTH_KEY_INIT:
2293      rc = myssh_in_AUTH_KEY_INIT(data, sshc);
2294      break;
2295    case SSH_AUTH_KEY:
2296      rc = myssh_in_AUTH_KEY(data, sshc);
2297      break;
2298    case SSH_AUTH_PASS_INIT:
2299      rc = myssh_in_AUTH_PASS_INIT(data, sshc);
2300      break;
2301    case SSH_AUTH_PASS:
2302      rc = myssh_in_AUTH_PASS(data, sshc);
2303      break;
2304    case SSH_AUTH_DONE:
2305      rc = myssh_in_AUTH_DONE(data, sshc);
2306      break;
2307    case SSH_SFTP_INIT:
2308      rc = myssh_in_SFTP_INIT(data, sshc);
2309      break;
2310    case SSH_SFTP_REALPATH:
2311      rc = myssh_in_SFTP_REALPATH(data, sshc);
2312      break;
2313    case SSH_SFTP_QUOTE_INIT:
2314      rc = myssh_in_SFTP_QUOTE_INIT(data, sshc, sshp);
2315      break;
2316    case SSH_SFTP_POSTQUOTE_INIT:
2317      rc = myssh_in_SFTP_POSTQUOTE_INIT(data, sshc);
2318      break;
2319    case SSH_SFTP_QUOTE:
2320      rc = myssh_in_SFTP_QUOTE(data, sshc, sshp);
2321      break;
2322    case SSH_SFTP_NEXT_QUOTE:
2323      rc = myssh_in_SFTP_NEXT_QUOTE(data, sshc);
2324      break;
2325    case SSH_SFTP_QUOTE_STAT:
2326      rc = myssh_in_SFTP_QUOTE_STAT(data, sshc);
2327      break;
2328    case SSH_SFTP_QUOTE_SETSTAT:
2329      rc = myssh_in_SFTP_QUOTE_SETSTAT(data, sshc);
2330      break;
2331    case SSH_SFTP_QUOTE_SYMLINK:
2332      rc = myssh_in_SFTP_QUOTE_SYMLINK(data, sshc);
2333      break;
2334    case SSH_SFTP_QUOTE_MKDIR:
2335      rc = myssh_in_SFTP_QUOTE_MKDIR(data, sshc);
2336      break;
2337    case SSH_SFTP_QUOTE_RENAME:
2338      rc = myssh_in_SFTP_QUOTE_RENAME(data, sshc);
2339      break;
2340    case SSH_SFTP_QUOTE_RMDIR:
2341      rc = myssh_in_SFTP_QUOTE_RMDIR(data, sshc);
2342      break;
2343    case SSH_SFTP_QUOTE_UNLINK:
2344      rc = myssh_in_SFTP_QUOTE_UNLINK(data, sshc);
2345      break;
2346    case SSH_SFTP_QUOTE_STATVFS:
2347      rc = myssh_in_SFTP_QUOTE_STATVFS(data, sshc);
2348      break;
2349    case SSH_SFTP_GETINFO:
2350      rc = myssh_in_SFTP_GETINFO(data, sshc);
2351      break;
2352    case SSH_SFTP_FILETIME:
2353      rc = myssh_in_SFTP_FILETIME(data, sshc, sshp);
2354      break;
2355    case SSH_SFTP_TRANS_INIT:
2356      rc = myssh_in_SFTP_TRANS_INIT(data, sshc, sshp);
2357      break;
2358    case SSH_SFTP_UPLOAD_INIT:
2359      rc = myssh_in_UPLOAD_INIT(data, sshc, sshp);
2360      break;
2361    case SSH_SFTP_CREATE_DIRS_INIT:
2362      rc = myssh_in_SFTP_CREATE_DIRS_INIT(data, sshc, sshp);
2363      break;
2364    case SSH_SFTP_CREATE_DIRS:
2365      rc = myssh_in_SFTP_CREATE_DIRS(data, sshc, sshp);
2366      break;
2367    case SSH_SFTP_CREATE_DIRS_MKDIR:
2368      rc = myssh_in_SFTP_CREATE_DIRS_MKDIR(data, sshc, sshp);
2369      break;
2370    case SSH_SFTP_READDIR_INIT:
2371      rc = myssh_in_SFTP_READDIR_INIT(data, sshc, sshp);
2372      break;
2373    case SSH_SFTP_READDIR:
2374      rc = myssh_in_SFTP_READDIR(data, sshc, sshp);
2375      break;
2376    case SSH_SFTP_READDIR_LINK:
2377      rc = myssh_in_SFTP_READDIR_LINK(data, sshc);
2378      break;
2379    case SSH_SFTP_READDIR_BOTTOM:
2380      rc = myssh_in_SFTP_READDIR_BOTTOM(data, sshc);
2381      break;
2382    case SSH_SFTP_READDIR_DONE:
2383      rc = myssh_in_SFTP_READDIR_DONE(data, sshc);
2384      break;
2385    case SSH_SFTP_DOWNLOAD_INIT:
2386      rc = myssh_in_SFTP_DOWNLOAD_INIT(data, sshc, sshp);
2387      break;
2388    case SSH_SFTP_DOWNLOAD_STAT:
2389      rc = myssh_in_SFTP_DOWNLOAD_STAT(data, sshc);
2390      break;
2391    case SSH_SFTP_CLOSE:
2392      rc = myssh_in_SFTP_CLOSE(data, sshc, sshp);
2393      break;
2394    case SSH_SFTP_SHUTDOWN:
2395      rc = myssh_in_SFTP_SHUTDOWN(data, sshc);
2396      break;
2397    case SSH_SCP_TRANS_INIT:
2398      rc = myssh_in_TRANS_INIT(data, sshc, sshp);
2399      break;
2400    case SSH_SCP_UPLOAD_INIT:
2401      rc = myssh_in_SCP_UPLOAD_INIT(data, sshc, sshp);
2402      break;
2403    case SSH_SCP_DOWNLOAD_INIT:
2404      rc = myssh_in_SCP_DOWNLOAD_INIT(data, sshc);
2405      if(rc)
2406        break;
2407      FALLTHROUGH();
2408    case SSH_SCP_DOWNLOAD:
2409      rc = myssh_SSH_SCP_DOWNLOAD(data, sshc);
2410      break;
2411    case SSH_SCP_DONE:
2412      rc = myssh_in_SCP_DONE(data, sshc);
2413      break;
2414    case SSH_SCP_SEND_EOF:
2415      rc = myssh_in_SCP_SEND_EOF(data, sshc);
2416      break;
2417    case SSH_SCP_CHANNEL_FREE:
2418      myssh_in_SCP_CHANNEL_FREE(data, sshc);
2419      FALLTHROUGH();
2420    case SSH_SESSION_DISCONNECT:
2421      myssh_SESSION_DISCONNECT(data, sshc);
2422      FALLTHROUGH();
2423    case SSH_SESSION_FREE:
2424      result = myssh_in_SESSION_FREE(data, sshc);
2425      break;
2426    case SSH_QUIT:
2427    default:
2428      /* internal error */
2429      sshc->nextstate = SSH_NO_STATE;
2430      myssh_to(data, sshc, SSH_STOP);
2431      break;
2432    }
2433    /* break the loop only on STOP or SSH_AGAIN. If `rc` is some
2434     * other error code, we will have progressed the state accordingly. */
2435  } while((rc != SSH_AGAIN) && (sshc->state != SSH_STOP));
2436
2437  if(rc == SSH_AGAIN) {
2438    /* we would block, we need to wait for the socket to be ready (in the
2439       right direction too)! */
2440    *block = TRUE;
2441  }
2442  if(!result && (sshc->state == SSH_STOP))
2443    result = sshc->actualcode;
2444  CURL_TRC_SSH(data, "[%s] statemachine() -> %d, block=%d",
2445               Curl_ssh_statename(sshc->state), result, *block);
2446  return result;
2447}
2448
2449/* called by the multi interface to figure out what socket(s) to wait for and
2450   for what actions in the DO_DONE, PERFORM and WAITPERFORM states */
2451static CURLcode myssh_pollset(struct Curl_easy *data,
2452                              struct easy_pollset *ps)
2453{
2454  struct connectdata *conn = data->conn;
2455  struct ssh_conn *sshc = Curl_conn_meta_get(conn, CURL_META_SSH_CONN);
2456  curl_socket_t sock = conn->sock[FIRSTSOCKET];
2457  int waitfor;
2458
2459  if(!sshc || (sock == CURL_SOCKET_BAD))
2460    return CURLE_FAILED_INIT;
2461
2462  waitfor = sshc->waitfor ? sshc->waitfor : data->req.io_flags;
2463  if(waitfor) {
2464    int flags = 0;
2465    if(waitfor & REQ_IO_RECV)
2466      flags |= CURL_POLL_IN;
2467    if(waitfor & REQ_IO_SEND)
2468      flags |= CURL_POLL_OUT;
2469    DEBUGASSERT(flags);
2470    CURL_TRC_SSH(data, "pollset, flags=%x", flags);
2471    return Curl_pollset_change(data, ps, sock, flags, 0);
2472  }
2473  /* While we still have a session, we listen incoming data. */
2474  if(sshc->ssh_session)
2475    return Curl_pollset_change(data, ps, sock, CURL_POLL_IN, 0);
2476  return CURLE_OK;
2477}
2478
2479/* called repeatedly until done from multi.c */
2480static CURLcode myssh_multi_statemach(struct Curl_easy *data,
2481                                      bool *done)
2482{
2483  struct connectdata *conn = data->conn;
2484  struct ssh_conn *sshc = Curl_conn_meta_get(conn, CURL_META_SSH_CONN);
2485  struct SSHPROTO *sshp = Curl_meta_get(data, CURL_META_SSH_EASY);
2486  bool block;    /* we store the status and use that to provide a ssh_pollset()
2487                    implementation */
2488  CURLcode result;
2489
2490  if(!sshc || !sshp)
2491    return CURLE_FAILED_INIT;
2492  result = myssh_statemachine(data, sshc, sshp, &block);
2493  *done = (sshc->state == SSH_STOP);
2494  myssh_block2waitfor(conn, sshc, block);
2495
2496  return result;
2497}
2498
2499static CURLcode myssh_block_statemach(struct Curl_easy *data,
2500                                      struct ssh_conn *sshc,
2501                                      struct SSHPROTO *sshp,
2502                                      bool disconnect)
2503{
2504  struct connectdata *conn = data->conn;
2505  CURLcode result = CURLE_OK;
2506
2507  while((sshc->state != SSH_STOP) && !result) {
2508    bool block;
2509    timediff_t left_ms = 1000;
2510
2511    result = myssh_statemachine(data, sshc, sshp, &block);
2512    if(result)
2513      break;
2514
2515    if(!disconnect) {
2516      result = Curl_pgrsCheck(data);
2517      if(result)
2518        break;
2519
2520      left_ms = Curl_timeleft_ms(data);
2521      if(left_ms < 0) {
2522        failf(data, "Operation timed out");
2523        return CURLE_OPERATION_TIMEDOUT;
2524      }
2525    }
2526
2527    if(block) {
2528      curl_socket_t fd_read = conn->sock[FIRSTSOCKET];
2529      /* wait for the socket to become ready */
2530      (void)SOCKET_READABLE(fd_read, left_ms > 1000 ? 1000 : left_ms);
2531    }
2532  }
2533
2534  return result;
2535}
2536
2537static void myssh_easy_dtor(void *key, size_t klen, void *entry)
2538{
2539  struct SSHPROTO *sshp = entry;
2540  (void)key;
2541  (void)klen;
2542  curlx_safefree(sshp->path);
2543  curlx_free(sshp);
2544}
2545
2546static void myssh_conn_dtor(void *key, size_t klen, void *entry)
2547{
2548  struct ssh_conn *sshc = entry;
2549  (void)key;
2550  (void)klen;
2551  sshc_cleanup(sshc);
2552  curlx_free(sshc);
2553}
2554
2555/*
2556 * SSH setup connection
2557 */
2558static CURLcode myssh_setup_connection(struct Curl_easy *data,
2559                                       struct connectdata *conn)
2560{
2561  struct SSHPROTO *sshp;
2562  struct ssh_conn *sshc;
2563
2564  sshc = curlx_calloc(1, sizeof(*sshc));
2565  if(!sshc)
2566    return CURLE_OUT_OF_MEMORY;
2567
2568  curlx_dyn_init(&sshc->readdir_buf, CURL_PATH_MAX * 2);
2569  sshc->initialized = TRUE;
2570  if(Curl_conn_meta_set(conn, CURL_META_SSH_CONN, sshc, myssh_conn_dtor))
2571    return CURLE_OUT_OF_MEMORY;
2572
2573  sshp = curlx_calloc(1, sizeof(*sshp));
2574  if(!sshp ||
2575     Curl_meta_set(data, CURL_META_SSH_EASY, sshp, myssh_easy_dtor))
2576    return CURLE_OUT_OF_MEMORY;
2577
2578  return CURLE_OK;
2579}
2580
2581static Curl_recv scp_recv, sftp_recv;
2582static Curl_send scp_send, sftp_send;
2583
2584/*
2585 * Curl_ssh_connect() gets called from Curl_protocol_connect() to allow us to
2586 * do protocol-specific actions at connect-time.
2587 */
2588static CURLcode myssh_connect(struct Curl_easy *data, bool *done)
2589{
2590  CURLcode result;
2591  struct connectdata *conn = data->conn;
2592  struct ssh_conn *sshc = Curl_conn_meta_get(conn, CURL_META_SSH_CONN);
2593  struct SSHPROTO *ssh = Curl_meta_get(data, CURL_META_SSH_EASY);
2594  curl_socket_t sock = conn->sock[FIRSTSOCKET];
2595  int rc;
2596
2597  if(!sshc || !ssh)
2598    return CURLE_FAILED_INIT;
2599
2600  CURL_TRC_SSH(data, "myssh_connect");
2601  if(conn->scheme->protocol & CURLPROTO_SCP) {
2602    conn->recv[FIRSTSOCKET] = scp_recv;
2603    conn->send[FIRSTSOCKET] = scp_send;
2604  }
2605  else {
2606    conn->recv[FIRSTSOCKET] = sftp_recv;
2607    conn->send[FIRSTSOCKET] = sftp_send;
2608  }
2609
2610  sshc->ssh_session = ssh_new();
2611  if(!sshc->ssh_session) {
2612    failf(data, "Failure initialising ssh session");
2613    return CURLE_FAILED_INIT;
2614  }
2615
2616  rc = ssh_options_set(sshc->ssh_session, SSH_OPTIONS_HOST,
2617                       (data->state.up.hostname[0] == '[') ?
2618                       data->state.up.hostname : conn->origin->hostname);
2619
2620  if(rc != SSH_OK) {
2621    failf(data, "Could not set remote host");
2622    return CURLE_FAILED_INIT;
2623  }
2624
2625  rc = ssh_options_parse_config(sshc->ssh_session, NULL);
2626  if(rc != SSH_OK) {
2627    infof(data, "Could not parse SSH configuration files");
2628    /* ignore */
2629  }
2630
2631  CURL_TRC_SSH(data, "myssh_connect, set socket=%" FMT_SOCKET_T, sock);
2632  rc = ssh_options_set(sshc->ssh_session, SSH_OPTIONS_FD, &sock);
2633  if(rc != SSH_OK) {
2634    failf(data, "Could not set socket");
2635    return CURLE_FAILED_INIT;
2636  }
2637
2638  if(Curl_creds_has_user(conn->creds)) {
2639    infof(data, "User: %s", conn->creds->user);
2640    rc = ssh_options_set(sshc->ssh_session, SSH_OPTIONS_USER,
2641                         conn->creds->user);
2642    if(rc != SSH_OK) {
2643      failf(data, "Could not set user");
2644      return CURLE_FAILED_INIT;
2645    }
2646  }
2647
2648  if(data->set.str[STRING_SSH_KNOWNHOSTS]) {
2649    infof(data, "Known hosts: %s", data->set.str[STRING_SSH_KNOWNHOSTS]);
2650    rc = ssh_options_set(sshc->ssh_session, SSH_OPTIONS_KNOWNHOSTS,
2651                         data->set.str[STRING_SSH_KNOWNHOSTS]);
2652    if(rc == SSH_OK)
2653      /* libssh has two separate options for this. Set both to the same file
2654         to avoid surprises */
2655      rc = ssh_options_set(sshc->ssh_session, SSH_OPTIONS_GLOBAL_KNOWNHOSTS,
2656                           data->set.str[STRING_SSH_KNOWNHOSTS]);
2657    if(rc != SSH_OK) {
2658      failf(data, "Could not set known hosts file path");
2659      return CURLE_FAILED_INIT;
2660    }
2661  }
2662
2663  if(conn->origin->port) {
2664    rc = ssh_options_set(sshc->ssh_session, SSH_OPTIONS_PORT,
2665                         &conn->origin->port);
2666    if(rc != SSH_OK) {
2667      failf(data, "Could not set remote port");
2668      return CURLE_FAILED_INIT;
2669    }
2670  }
2671
2672  if(data->set.ssh_compression) {
2673    rc = ssh_options_set(sshc->ssh_session, SSH_OPTIONS_COMPRESSION,
2674                         "zlib,zlib@openssh.com,none");
2675    if(rc != SSH_OK) {
2676      failf(data, "Could not set compression");
2677      return CURLE_FAILED_INIT;
2678    }
2679  }
2680
2681  sshc->privkey = NULL;
2682  sshc->pubkey = NULL;
2683
2684  if(data->set.str[STRING_SSH_PUBLIC_KEY]) {
2685    rc = ssh_pki_import_pubkey_file(data->set.str[STRING_SSH_PUBLIC_KEY],
2686                                    &sshc->pubkey);
2687    if(rc != SSH_OK) {
2688      failf(data, "Could not load public key file");
2689      return CURLE_FAILED_INIT;
2690    }
2691  }
2692
2693  /* we do not verify here, we do it at the state machine,
2694   * after connection */
2695
2696  myssh_to(data, sshc, SSH_INIT);
2697
2698  result = myssh_multi_statemach(data, done);
2699
2700  return result;
2701}
2702
2703/* called from multi.c while DOing */
2704static CURLcode scp_doing(struct Curl_easy *data, bool *dophase_done)
2705{
2706  CURLcode result;
2707
2708  result = myssh_multi_statemach(data, dophase_done);
2709
2710  if(*dophase_done) {
2711    CURL_TRC_SSH(data, "DO phase is complete");
2712  }
2713  return result;
2714}
2715
2716/*
2717 ***********************************************************************
2718 *
2719 * scp_perform()
2720 *
2721 * This is the actual DO function for SCP. Get a file according to
2722 * the options previously setup.
2723 */
2724
2725static CURLcode scp_perform(struct Curl_easy *data,
2726                            bool *connected, bool *dophase_done)
2727{
2728  CURLcode result = CURLE_OK;
2729  struct ssh_conn *sshc = Curl_conn_meta_get(data->conn, CURL_META_SSH_CONN);
2730
2731  CURL_TRC_SSH(data, "DO phase starts");
2732
2733  *dophase_done = FALSE;        /* not done yet */
2734  if(!sshc)
2735    return CURLE_FAILED_INIT;
2736
2737  /* start the first command in the DO phase */
2738  myssh_to(data, sshc, SSH_SCP_TRANS_INIT);
2739
2740  result = myssh_multi_statemach(data, dophase_done);
2741
2742  *connected = Curl_conn_is_connected(data->conn, FIRSTSOCKET);
2743
2744  if(*dophase_done) {
2745    CURL_TRC_SSH(data, "DO phase is complete");
2746  }
2747
2748  return result;
2749}
2750
2751/* BLOCKING, but the function is using the state machine so the only reason
2752   this is still blocking is that the multi interface code has no support for
2753   disconnecting operations that takes a while */
2754static CURLcode scp_disconnect(struct Curl_easy *data,
2755                               struct connectdata *conn,
2756                               bool dead_connection)
2757{
2758  CURLcode result = CURLE_OK;
2759  struct ssh_conn *sshc = Curl_conn_meta_get(conn, CURL_META_SSH_CONN);
2760  struct SSHPROTO *sshp = Curl_meta_get(data, CURL_META_SSH_EASY);
2761  (void)dead_connection;
2762
2763  if(sshc && sshc->ssh_session) {
2764    /* only if there is a session still around to use! */
2765    myssh_to(data, sshc, SSH_SESSION_DISCONNECT);
2766    result = myssh_block_statemach(data, sshc, sshp, TRUE);
2767  }
2768
2769  return result;
2770}
2771
2772/* generic done function for both SCP and SFTP called from their specific
2773   done functions */
2774static CURLcode myssh_done(struct Curl_easy *data,
2775                           struct ssh_conn *sshc,
2776                           CURLcode status)
2777{
2778  CURLcode result = CURLE_OK;
2779  struct SSHPROTO *sshp = Curl_meta_get(data, CURL_META_SSH_EASY);
2780
2781  if(!status && sshp) {
2782    /* run the state-machine */
2783    result = myssh_block_statemach(data, sshc, sshp, FALSE);
2784  }
2785  else
2786    result = status;
2787
2788  if(Curl_pgrsDone(data))
2789    return CURLE_ABORTED_BY_CALLBACK;
2790
2791  CURL_REQ_CLEAR_IO(data);
2792  return result;
2793}
2794
2795static CURLcode scp_done(struct Curl_easy *data, CURLcode status,
2796                         bool premature)
2797{
2798  struct ssh_conn *sshc = Curl_conn_meta_get(data->conn, CURL_META_SSH_CONN);
2799  (void)premature;
2800
2801  if(!sshc)
2802    return CURLE_FAILED_INIT;
2803  if(!status)
2804    myssh_to(data, sshc, SSH_SCP_DONE);
2805
2806  return myssh_done(data, sshc, status);
2807}
2808
2809static CURLcode scp_send(struct Curl_easy *data, int sockindex,
2810                         const uint8_t *mem, size_t len, bool eos,
2811                         size_t *pnwritten)
2812{
2813  int rc;
2814  struct connectdata *conn = data->conn;
2815  struct ssh_conn *sshc = Curl_conn_meta_get(conn, CURL_META_SSH_CONN);
2816
2817  (void)sockindex; /* we only support SCP on the fixed known primary socket */
2818  (void)eos;
2819  *pnwritten = 0;
2820
2821  if(!sshc)
2822    return CURLE_FAILED_INIT;
2823
2824  rc = ssh_scp_write(sshc->scp_session, mem, len);
2825
2826#if 0
2827  /* The following code is misleading, mostly added as wishful thinking
2828   * that libssh at some point would implement non-blocking ssh_scp_write/read.
2829   * Currently rc can only be number of bytes read or SSH_ERROR. */
2830  myssh_block2waitfor(conn, sshc, (rc == SSH_AGAIN));
2831
2832  if(rc == SSH_AGAIN)
2833    return CURLE_AGAIN;
2834  else
2835#endif
2836  if(rc != SSH_OK)
2837    return CURLE_SSH;
2838
2839  *pnwritten = len;
2840  return CURLE_OK;
2841}
2842
2843static CURLcode scp_recv(struct Curl_easy *data, int sockindex,
2844                         char *mem, size_t len, size_t *pnread)
2845{
2846  struct connectdata *conn = data->conn;
2847  struct ssh_conn *sshc = Curl_conn_meta_get(conn, CURL_META_SSH_CONN);
2848  int nread;
2849
2850  (void)sockindex; /* we only support SCP on the fixed known primary socket */
2851  *pnread = 0;
2852
2853  if(!sshc)
2854    return CURLE_FAILED_INIT;
2855
2856  /* libssh returns int */
2857  nread = ssh_scp_read(sshc->scp_session, mem, len);
2858  if(nread == SSH_ERROR)
2859    return CURLE_SSH;
2860#if 0
2861  /* The following code is misleading, mostly added as wishful thinking
2862   * that libssh at some point would implement non-blocking ssh_scp_write/read.
2863   * Currently rc can only be SSH_OK or SSH_ERROR. */
2864
2865  myssh_block2waitfor(conn, sshc, (nread == SSH_AGAIN));
2866  if(nread == SSH_AGAIN)
2867    return CURLE_AGAIN;
2868#endif
2869  *pnread = (size_t)nread;
2870  return CURLE_OK;
2871}
2872
2873/*
2874 * =============== SFTP ===============
2875 */
2876
2877/*
2878 ***********************************************************************
2879 *
2880 * sftp_perform()
2881 *
2882 * This is the actual DO function for SFTP. Get a file/directory according to
2883 * the options previously setup.
2884 */
2885
2886static CURLcode sftp_perform(struct Curl_easy *data,
2887                             bool *connected,
2888                             bool *dophase_done)
2889{
2890  struct ssh_conn *sshc = Curl_conn_meta_get(data->conn, CURL_META_SSH_CONN);
2891  CURLcode result = CURLE_OK;
2892
2893  CURL_TRC_SSH(data, "DO phase starts");
2894
2895  *dophase_done = FALSE; /* not done yet */
2896  if(!sshc)
2897    return CURLE_FAILED_INIT;
2898
2899  /* start the first command in the DO phase */
2900  myssh_to(data, sshc, SSH_SFTP_QUOTE_INIT);
2901
2902  /* run the state-machine */
2903  result = myssh_multi_statemach(data, dophase_done);
2904
2905  *connected = Curl_conn_is_connected(data->conn, FIRSTSOCKET);
2906
2907  if(*dophase_done) {
2908    CURL_TRC_SSH(data, "DO phase is complete");
2909  }
2910
2911  return result;
2912}
2913
2914/* called from multi.c while DOing */
2915static CURLcode sftp_doing(struct Curl_easy *data,
2916                           bool *dophase_done)
2917{
2918  CURLcode result = myssh_multi_statemach(data, dophase_done);
2919  if(*dophase_done) {
2920    CURL_TRC_SSH(data, "DO phase is complete");
2921  }
2922  return result;
2923}
2924
2925/* BLOCKING, but the function is using the state machine so the only reason
2926   this is still blocking is that the multi interface code has no support for
2927   disconnecting operations that takes a while */
2928static CURLcode sftp_disconnect(struct Curl_easy *data,
2929                                struct connectdata *conn,
2930                                bool dead_connection)
2931{
2932  struct ssh_conn *sshc = Curl_conn_meta_get(conn, CURL_META_SSH_CONN);
2933  struct SSHPROTO *sshp = Curl_meta_get(data, CURL_META_SSH_EASY);
2934  CURLcode result = CURLE_OK;
2935  (void)dead_connection;
2936
2937  CURL_TRC_SSH(data, "DISCONNECT starts now");
2938
2939  if(sshc && sshc->ssh_session) {
2940    /* only if there is a session still around to use! */
2941    myssh_to(data, sshc, SSH_SFTP_SHUTDOWN);
2942    result = myssh_block_statemach(data, sshc, sshp, TRUE);
2943  }
2944
2945  CURL_TRC_SSH(data, "DISCONNECT is done");
2946  return result;
2947}
2948
2949static CURLcode sftp_done(struct Curl_easy *data, CURLcode status,
2950                          bool premature)
2951{
2952  struct connectdata *conn = data->conn;
2953  struct ssh_conn *sshc = Curl_conn_meta_get(conn, CURL_META_SSH_CONN);
2954
2955  if(!sshc)
2956    return CURLE_FAILED_INIT;
2957  if(!status) {
2958    /* Post quote commands are executed after the SFTP_CLOSE state to avoid
2959       errors that could happen due to open file handles during POSTQUOTE
2960       operation */
2961    if(!premature && data->set.postquote && !conn->bits.retry)
2962      sshc->nextstate = SSH_SFTP_POSTQUOTE_INIT;
2963    myssh_to(data, sshc, SSH_SFTP_CLOSE);
2964  }
2965  return myssh_done(data, sshc, status);
2966}
2967
2968/* return number of sent bytes */
2969static CURLcode sftp_send(struct Curl_easy *data, int sockindex,
2970                          const uint8_t *mem, size_t len, bool eos,
2971                          size_t *pnwritten)
2972{
2973  struct connectdata *conn = data->conn;
2974  struct ssh_conn *sshc = Curl_conn_meta_get(conn, CURL_META_SSH_CONN);
2975  ssize_t nwrite;
2976
2977  (void)sockindex;
2978  (void)eos;
2979  *pnwritten = 0;
2980
2981  if(!sshc)
2982    return CURLE_FAILED_INIT;
2983
2984#if LIBSSH_VERSION_INT > SSH_VERSION_INT(0, 11, 0)
2985  switch(sshc->sftp_send_state) {
2986  case 0:
2987    sftp_file_set_nonblocking(sshc->sftp_file);
2988    if(sftp_aio_begin_write(sshc->sftp_file, mem, len,
2989                            &sshc->sftp_send_aio) == SSH_ERROR) {
2990      return CURLE_SEND_ERROR;
2991    }
2992    sshc->sftp_send_state = 1;
2993    FALLTHROUGH();
2994  case 1:
2995    nwrite = sftp_aio_wait_write(&sshc->sftp_send_aio);
2996    myssh_block2waitfor(conn, sshc, (nwrite == SSH_AGAIN) ? TRUE : FALSE);
2997    if(nwrite == SSH_AGAIN)
2998      return CURLE_AGAIN;
2999    else if(nwrite < 0)
3000      return CURLE_SEND_ERROR;
3001
3002    /*
3003     * sftp_aio_wait_write() would free sftp_send_aio and
3004     * assign it NULL in all cases except when it returns
3005     * SSH_AGAIN.
3006     */
3007
3008    sshc->sftp_send_state = 0;
3009    *pnwritten = (size_t)nwrite;
3010    return CURLE_OK;
3011  default:
3012    /* we never reach here */
3013    return CURLE_SEND_ERROR;
3014  }
3015#else
3016  /*
3017   * limit the writes to the maximum specified in Section 3 of
3018   * https://datatracker.ietf.org/doc/html/draft-ietf-secsh-filexfer-02
3019   *
3020   * libssh started applying appropriate read/write length limits
3021   * internally since version 0.11.0, hence such an operation is
3022   * not needed for versions after (and including) 0.11.0.
3023   */
3024  if(len > 32768)
3025    len = 32768;
3026
3027  nwrite = sftp_write(sshc->sftp_file, mem, len);
3028
3029  myssh_block2waitfor(conn, sshc, FALSE);
3030
3031#if 0 /* not returned by libssh on write */
3032  if(nwrite == SSH_AGAIN) {
3033    *err = CURLE_AGAIN;
3034    nwrite = 0;
3035  }
3036  else
3037#endif
3038  if(nwrite < 0)
3039    return CURLE_SSH;
3040
3041  *pnwritten = (size_t)nwrite;
3042  return CURLE_OK;
3043#endif
3044}
3045
3046/*
3047 * Return number of received (decrypted) bytes
3048 * or <0 on error
3049 */
3050static CURLcode sftp_recv(struct Curl_easy *data, int sockindex,
3051                          char *mem, size_t len, size_t *pnread)
3052{
3053  struct connectdata *conn = data->conn;
3054  struct ssh_conn *sshc = Curl_conn_meta_get(conn, CURL_META_SSH_CONN);
3055  ssize_t nread;
3056
3057  (void)sockindex;
3058  *pnread = 0;
3059
3060  DEBUGASSERT(len < CURL_MAX_READ_SIZE);
3061  if(!sshc)
3062    return CURLE_FAILED_INIT;
3063
3064  switch(sshc->sftp_recv_state) {
3065  case 0:
3066#if LIBSSH_VERSION_INT > SSH_VERSION_INT(0, 11, 0)
3067    if(sftp_aio_begin_read(sshc->sftp_file, len,
3068                           &sshc->sftp_recv_aio) == SSH_ERROR) {
3069      return CURLE_RECV_ERROR;
3070    }
3071#else
3072    sshc->sftp_file_index =
3073      sftp_async_read_begin(sshc->sftp_file, (uint32_t)len);
3074    if(sshc->sftp_file_index < 0)
3075      return CURLE_RECV_ERROR;
3076#endif
3077
3078    FALLTHROUGH();
3079  case 1:
3080    sshc->sftp_recv_state = 1;
3081
3082#if LIBSSH_VERSION_INT > SSH_VERSION_INT(0, 11, 0)
3083    nread = sftp_aio_wait_read(&sshc->sftp_recv_aio, mem, len);
3084#else
3085    nread = sftp_async_read(sshc->sftp_file, mem, (uint32_t)len,
3086                            (uint32_t)sshc->sftp_file_index);
3087#endif
3088
3089    myssh_block2waitfor(conn, sshc, (nread == SSH_AGAIN));
3090
3091    if(nread == SSH_AGAIN)
3092      return CURLE_AGAIN;
3093    else if(nread < 0)
3094      return CURLE_RECV_ERROR;
3095
3096    /*
3097     * sftp_aio_wait_read() would free sftp_recv_aio and
3098     * assign it NULL in all cases except when it returns
3099     * SSH_AGAIN.
3100     */
3101
3102    sshc->sftp_recv_state = 0;
3103    *pnread = (size_t)nread;
3104    return CURLE_OK;
3105
3106  default:
3107    /* we never reach here */
3108    return CURLE_RECV_ERROR;
3109  }
3110}
3111
3112static CURLcode myssh_do_it(struct Curl_easy *data, bool *done)
3113{
3114  CURLcode result;
3115  bool connected = FALSE;
3116  struct connectdata *conn = data->conn;
3117  struct ssh_conn *sshc = Curl_conn_meta_get(conn, CURL_META_SSH_CONN);
3118
3119  *done = FALSE;                /* default to false */
3120  if(!sshc)
3121    return CURLE_FAILED_INIT;
3122
3123  data->req.size = -1;          /* make sure this is unknown at this point */
3124
3125  sshc->actualcode = CURLE_OK;  /* reset error code */
3126  sshc->secondCreateDirs = 0;   /* reset the create directory attempt state
3127                                   variable */
3128
3129  Curl_pgrsReset(data);
3130
3131  if(conn->scheme->protocol & CURLPROTO_SCP)
3132    result = scp_perform(data, &connected, done);
3133  else
3134    result = sftp_perform(data, &connected, done);
3135
3136  return result;
3137}
3138
3139CURLcode Curl_ssh_init(void)
3140{
3141  if(ssh_init()) {
3142    DEBUGF(curl_mfprintf(stderr, "Error: libssh_init failed\n"));
3143    return CURLE_FAILED_INIT;
3144  }
3145  return CURLE_OK;
3146}
3147
3148void Curl_ssh_cleanup(void)
3149{
3150  (void)ssh_finalize();
3151}
3152
3153void Curl_ssh_version(char *buffer, size_t buflen)
3154{
3155  (void)curl_msnprintf(buffer, buflen, "libssh/%s", ssh_version(0));
3156}
3157
3158/*
3159 * SCP.
3160 */
3161const struct Curl_protocol Curl_protocol_scp = {
3162  myssh_setup_connection,       /* setup_connection */
3163  myssh_do_it,                  /* do_it */
3164  scp_done,                     /* done */
3165  ZERO_NULL,                    /* do_more */
3166  myssh_connect,                /* connect_it */
3167  myssh_multi_statemach,        /* connecting */
3168  scp_doing,                    /* doing */
3169  myssh_pollset,                /* proto_pollset */
3170  myssh_pollset,                /* doing_pollset */
3171  ZERO_NULL,                    /* domore_pollset */
3172  myssh_pollset,                /* perform_pollset */
3173  scp_disconnect,               /* disconnect */
3174  ZERO_NULL,                    /* write_resp */
3175  ZERO_NULL,                    /* write_resp_hd */
3176  ZERO_NULL,                    /* connection_is_dead */
3177  ZERO_NULL,                    /* attach connection */
3178  ZERO_NULL,                    /* follow */
3179};
3180
3181/*
3182 * SFTP.
3183 */
3184const struct Curl_protocol Curl_protocol_sftp = {
3185  myssh_setup_connection,               /* setup_connection */
3186  myssh_do_it,                          /* do_it */
3187  sftp_done,                            /* done */
3188  ZERO_NULL,                            /* do_more */
3189  myssh_connect,                        /* connect_it */
3190  myssh_multi_statemach,                /* connecting */
3191  sftp_doing,                           /* doing */
3192  myssh_pollset,                        /* proto_pollset */
3193  myssh_pollset,                        /* doing_pollset */
3194  ZERO_NULL,                            /* domore_pollset */
3195  myssh_pollset,                        /* perform_pollset */
3196  sftp_disconnect,                      /* disconnect */
3197  ZERO_NULL,                            /* write_resp */
3198  ZERO_NULL,                            /* write_resp_hd */
3199  ZERO_NULL,                            /* connection_is_dead */
3200  ZERO_NULL,                            /* attach connection */
3201  ZERO_NULL,                            /* follow */
3202};
3203
3204#endif /* USE_LIBSSH */