lib/ssh.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2013, Daniel Stenberg, <daniel@haxx.se>, et al.
   9  *
  10  * This software is licensed as described in the file COPYING, which
  11  * you should have received as part of this distribution. The terms
  12  * are also available at http://curl.haxx.se/docs/copyright.html.
  13  *
  14  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15  * copies of the Software, and permit persons to whom the Software is
  16  * furnished to do so, under the terms of the COPYING file.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ***************************************************************************/
  22
  23 /* #define CURL_LIBSSH2_DEBUG */
  24
  25 #include "curl_setup.h"
  26
  27 #ifdef USE_LIBSSH2
  28
  29 #ifdef HAVE_LIMITS_H
  30 #  include <limits.h>
  31 #endif
  32
  33 #include <libssh2.h>
  34 #include <libssh2_sftp.h>
  35
  36 #ifdef HAVE_FCNTL_H
  37 #include <fcntl.h>
  38 #endif
  39
  40 #ifdef HAVE_NETINET_IN_H
  41 #include <netinet/in.h>
  42 #endif
  43 #ifdef HAVE_ARPA_INET_H
  44 #include <arpa/inet.h>
  45 #endif
  46 #ifdef HAVE_UTSNAME_H
  47 #include <sys/utsname.h>
  48 #endif
  49 #ifdef HAVE_NETDB_H
  50 #include <netdb.h>
  51 #endif
  52 #ifdef __VMS
  53 #include <in.h>
  54 #include <inet.h>
  55 #endif
  56
  57 #if (defined(NETWARE) && defined(__NOVELL_LIBC__))
  58 #undef in_addr_t
  59 #define in_addr_t unsigned long
  60 #endif
  61
  62 #include <curl/curl.h>
  63 #include "urldata.h"
  64 #include "sendf.h"
  65 #include "hostip.h"
  66 #include "progress.h"
  67 #include "transfer.h"
  68 #include "escape.h"
  69 #include "http.h" /* for HTTP proxy tunnel stuff */
  70 #include "ssh.h"
  71 #include "url.h"
  72 #include "speedcheck.h"
  73 #include "getinfo.h"
  74
  75 #include "strequal.h"
  76 #include "sslgen.h"
  77 #include "connect.h"
  78 #include "strerror.h"
  79 #include "inet_ntop.h"
  80 #include "parsedate.h" /* for the week day and month names */
  81 #include "sockaddr.h" /* required for Curl_sockaddr_storage */
  82 #include "strtoofft.h"
  83 #include "multiif.h"
  84 #include "select.h"
  85 #include "warnless.h"
  86
  87 #define _MPRINTF_REPLACE /* use our functions only */
  88 #include <curl/mprintf.h>
  89
  90 #include "curl_memory.h"
  91 /* The last #include file should be: */
  92 #include "memdebug.h"
  93
  94 #ifdef WIN32
  95 #  undef  PATH_MAX
  96 #  define PATH_MAX MAX_PATH
  97 #endif
  98
  99 #ifndef PATH_MAX
 100 #define PATH_MAX 1024 /* just an extra precaution since there are systems that
 101                          have their definition hidden well */
 102 #endif
 103
 104 #define sftp_libssh2_last_error(s) curlx_ultosi(libssh2_sftp_last_error(s))
 105
 106 #define sftp_libssh2_realpath(s,p,t,m) \
 107         libssh2_sftp_symlink_ex((s), (p), curlx_uztoui(strlen(p)), \
 108                                 (t), (m), LIBSSH2_SFTP_REALPATH)
 109
 110 /* Local functions: */
 111 static const char *sftp_libssh2_strerror(int err);
 112 static LIBSSH2_ALLOC_FUNC(my_libssh2_malloc);
 113 static LIBSSH2_REALLOC_FUNC(my_libssh2_realloc);
 114 static LIBSSH2_FREE_FUNC(my_libssh2_free);
 115
 116 static CURLcode get_pathname(const char **cpp, char **path);
 117
 118 static CURLcode ssh_connect(struct connectdata *conn, bool *done);
 119 static CURLcode ssh_multi_statemach(struct connectdata *conn, bool *done);
 120 static CURLcode ssh_do(struct connectdata *conn, bool *done);
 121
 122 static CURLcode ssh_getworkingpath(struct connectdata *conn,
 123                                    char *homedir, /* when SFTP is used */
 124                                    char **path);
 125
 126 static CURLcode scp_done(struct connectdata *conn,
 127                          CURLcode, bool premature);
 128 static CURLcode scp_doing(struct connectdata *conn,
 129                           bool *dophase_done);
 130 static CURLcode scp_disconnect(struct connectdata *conn, bool dead_connection);
 131
 132 static CURLcode sftp_done(struct connectdata *conn,
 133                           CURLcode, bool premature);
 134 static CURLcode sftp_doing(struct connectdata *conn,
 135                            bool *dophase_done);
 136 static CURLcode sftp_disconnect(struct connectdata *conn, bool dead);
 137 static
 138 CURLcode sftp_perform(struct connectdata *conn,
 139                       bool *connected,
 140                       bool *dophase_done);
 141
 142 static int ssh_getsock(struct connectdata *conn,
 143                        curl_socket_t *sock, /* points to numsocks number
 144                                                of sockets */
 145                        int numsocks);
 146
 147 static int ssh_perform_getsock(const struct connectdata *conn,
 148                                curl_socket_t *sock, /* points to numsocks
 149                                                        number of sockets */
 150                                int numsocks);
 151
 152 static CURLcode ssh_setup_connection(struct connectdata *conn);
 153
 154 /*
 155  * SCP protocol handler.
 156  */
 157
 158 const struct Curl_handler Curl_handler_scp = {
 159   "SCP",                                /* scheme */
 160   ssh_setup_connection,                 /* setup_connection */
 161   ssh_do,                               /* do_it */
 162   scp_done,                             /* done */
 163   ZERO_NULL,                            /* do_more */
 164   ssh_connect,                          /* connect_it */
 165   ssh_multi_statemach,                  /* connecting */
 166   scp_doing,                            /* doing */
 167   ssh_getsock,                          /* proto_getsock */
 168   ssh_getsock,                          /* doing_getsock */
 169   ZERO_NULL,                            /* domore_getsock */
 170   ssh_perform_getsock,                  /* perform_getsock */
 171   scp_disconnect,                       /* disconnect */
 172   ZERO_NULL,                            /* readwrite */
 173   PORT_SSH,                             /* defport */
 174   CURLPROTO_SCP,                        /* protocol */
 175   PROTOPT_DIRLOCK | PROTOPT_CLOSEACTION
 176   | PROTOPT_NOURLQUERY                  /* flags */
 177 };
 178
 179
 180 /*
 181  * SFTP protocol handler.
 182  */
 183
 184 const struct Curl_handler Curl_handler_sftp = {
 185   "SFTP",                               /* scheme */
 186   ssh_setup_connection,                 /* setup_connection */
 187   ssh_do,                               /* do_it */
 188   sftp_done,                            /* done */
 189   ZERO_NULL,                            /* do_more */
 190   ssh_connect,                          /* connect_it */
 191   ssh_multi_statemach,                  /* connecting */
 192   sftp_doing,                           /* doing */
 193   ssh_getsock,                          /* proto_getsock */
 194   ssh_getsock,                          /* doing_getsock */
 195   ZERO_NULL,                            /* domore_getsock */
 196   ssh_perform_getsock,                  /* perform_getsock */
 197   sftp_disconnect,                      /* disconnect */
 198   ZERO_NULL,                            /* readwrite */
 199   PORT_SSH,                             /* defport */
 200   CURLPROTO_SFTP,                       /* protocol */
 201   PROTOPT_DIRLOCK | PROTOPT_CLOSEACTION
 202   | PROTOPT_NOURLQUERY                  /* flags */
 203 };
 204
 205 static void
 206 kbd_callback(const char *name, int name_len, const char *instruction,
 207              int instruction_len, int num_prompts,
 208              const LIBSSH2_USERAUTH_KBDINT_PROMPT *prompts,
 209              LIBSSH2_USERAUTH_KBDINT_RESPONSE *responses,
 210              void **abstract)
 211 {
 212   struct connectdata *conn = (struct connectdata *)*abstract;
 213
 214 #ifdef CURL_LIBSSH2_DEBUG
 215   fprintf(stderr, "name=%s\n", name);
 216   fprintf(stderr, "name_len=%d\n", name_len);
 217   fprintf(stderr, "instruction=%s\n", instruction);
 218   fprintf(stderr, "instruction_len=%d\n", instruction_len);
 219   fprintf(stderr, "num_prompts=%d\n", num_prompts);
 220 #else
 221   (void)name;
 222   (void)name_len;
 223   (void)instruction;
 224   (void)instruction_len;
 225 #endif  /* CURL_LIBSSH2_DEBUG */
 226   if(num_prompts == 1) {
 227     responses[0].text = strdup(conn->passwd);
 228     responses[0].length = curlx_uztoui(strlen(conn->passwd));
 229   }
 230   (void)prompts;
 231   (void)abstract;
 232 } /* kbd_callback */
 233
 234 static CURLcode sftp_libssh2_error_to_CURLE(int err)
 235 {
 236   switch (err) {
 237     case LIBSSH2_FX_OK:
 238       return CURLE_OK;
 239
 240     case LIBSSH2_FX_NO_SUCH_FILE:
 241     case LIBSSH2_FX_NO_SUCH_PATH:
 242       return CURLE_REMOTE_FILE_NOT_FOUND;
 243
 244     case LIBSSH2_FX_PERMISSION_DENIED:
 245     case LIBSSH2_FX_WRITE_PROTECT:
 246     case LIBSSH2_FX_LOCK_CONFlICT:
 247       return CURLE_REMOTE_ACCESS_DENIED;
 248
 249     case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:
 250     case LIBSSH2_FX_QUOTA_EXCEEDED:
 251       return CURLE_REMOTE_DISK_FULL;
 252
 253     case LIBSSH2_FX_FILE_ALREADY_EXISTS:
 254       return CURLE_REMOTE_FILE_EXISTS;
 255
 256     case LIBSSH2_FX_DIR_NOT_EMPTY:
 257       return CURLE_QUOTE_ERROR;
 258
 259     default:
 260       break;
 261   }
 262
 263   return CURLE_SSH;
 264 }
 265
 266 static CURLcode libssh2_session_error_to_CURLE(int err)
 267 {
 268   switch (err) {
 269     /* Ordered by order of appearance in libssh2.h */
 270     case LIBSSH2_ERROR_NONE:
 271       return CURLE_OK;
 272
 273     case LIBSSH2_ERROR_SOCKET_NONE:
 274       return CURLE_COULDNT_CONNECT;
 275
 276     case LIBSSH2_ERROR_ALLOC:
 277       return CURLE_OUT_OF_MEMORY;
 278
 279     case LIBSSH2_ERROR_SOCKET_SEND:
 280       return CURLE_SEND_ERROR;
 281
 282     case LIBSSH2_ERROR_HOSTKEY_INIT:
 283     case LIBSSH2_ERROR_HOSTKEY_SIGN:
 284     case LIBSSH2_ERROR_PUBLICKEY_UNRECOGNIZED:
 285     case LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED:
 286       return CURLE_PEER_FAILED_VERIFICATION;
 287
 288     case LIBSSH2_ERROR_PASSWORD_EXPIRED:
 289       return CURLE_LOGIN_DENIED;
 290
 291     case LIBSSH2_ERROR_SOCKET_TIMEOUT:
 292     case LIBSSH2_ERROR_TIMEOUT:
 293       return CURLE_OPERATION_TIMEDOUT;
 294
 295     case LIBSSH2_ERROR_EAGAIN:
 296       return CURLE_AGAIN;
 297   }
 298
 299   /* TODO: map some more of the libssh2 errors to the more appropriate CURLcode
 300      error code, and possibly add a few new SSH-related one. We must however
 301      not return or even depend on libssh2 errors in the public libcurl API */
 302
 303   return CURLE_SSH;
 304 }
 305
 306 static LIBSSH2_ALLOC_FUNC(my_libssh2_malloc)
 307 {
 308   (void)abstract; /* arg not used */
 309   return malloc(count);
 310 }
 311
 312 static LIBSSH2_REALLOC_FUNC(my_libssh2_realloc)
 313 {
 314   (void)abstract; /* arg not used */
 315   return realloc(ptr, count);
 316 }
 317
 318 static LIBSSH2_FREE_FUNC(my_libssh2_free)
 319 {
 320   (void)abstract; /* arg not used */
 321   if(ptr) /* ssh2 agent sometimes call free with null ptr */
 322     free(ptr);
 323 }
 324
 325 /*
 326  * SSH State machine related code
 327  */
 328 /* This is the ONLY way to change SSH state! */
 329 static void state(struct connectdata *conn, sshstate nowstate)
 330 {
 331 #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
 332   /* for debug purposes */
 333   static const char * const names[] = {
 334     "SSH_STOP",
 335     "SSH_INIT",
 336     "SSH_S_STARTUP",
 337     "SSH_HOSTKEY",
 338     "SSH_AUTHLIST",
 339     "SSH_AUTH_PKEY_INIT",
 340     "SSH_AUTH_PKEY",
 341     "SSH_AUTH_PASS_INIT",
 342     "SSH_AUTH_PASS",
 343     "SSH_AUTH_AGENT_INIT",
 344     "SSH_AUTH_AGENT_LIST",
 345     "SSH_AUTH_AGENT",
 346     "SSH_AUTH_HOST_INIT",
 347     "SSH_AUTH_HOST",
 348     "SSH_AUTH_KEY_INIT",
 349     "SSH_AUTH_KEY",
 350     "SSH_AUTH_DONE",
 351     "SSH_SFTP_INIT",
 352     "SSH_SFTP_REALPATH",
 353     "SSH_SFTP_QUOTE_INIT",
 354     "SSH_SFTP_POSTQUOTE_INIT",
 355     "SSH_SFTP_QUOTE",
 356     "SSH_SFTP_NEXT_QUOTE",
 357     "SSH_SFTP_QUOTE_STAT",
 358     "SSH_SFTP_QUOTE_SETSTAT",
 359     "SSH_SFTP_QUOTE_SYMLINK",
 360     "SSH_SFTP_QUOTE_MKDIR",
 361     "SSH_SFTP_QUOTE_RENAME",
 362     "SSH_SFTP_QUOTE_RMDIR",
 363     "SSH_SFTP_QUOTE_UNLINK",
 364     "SSH_SFTP_TRANS_INIT",
 365     "SSH_SFTP_UPLOAD_INIT",
 366     "SSH_SFTP_CREATE_DIRS_INIT",
 367     "SSH_SFTP_CREATE_DIRS",
 368     "SSH_SFTP_CREATE_DIRS_MKDIR",
 369     "SSH_SFTP_READDIR_INIT",
 370     "SSH_SFTP_READDIR",
 371     "SSH_SFTP_READDIR_LINK",
 372     "SSH_SFTP_READDIR_BOTTOM",
 373     "SSH_SFTP_READDIR_DONE",
 374     "SSH_SFTP_DOWNLOAD_INIT",
 375     "SSH_SFTP_DOWNLOAD_STAT",
 376     "SSH_SFTP_CLOSE",
 377     "SSH_SFTP_SHUTDOWN",
 378     "SSH_SCP_TRANS_INIT",
 379     "SSH_SCP_UPLOAD_INIT",
 380     "SSH_SCP_DOWNLOAD_INIT",
 381     "SSH_SCP_DONE",
 382     "SSH_SCP_SEND_EOF",
 383     "SSH_SCP_WAIT_EOF",
 384     "SSH_SCP_WAIT_CLOSE",
 385     "SSH_SCP_CHANNEL_FREE",
 386     "SSH_SESSION_DISCONNECT",
 387     "SSH_SESSION_FREE",
 388     "QUIT"
 389   };
 390 #endif
 391   struct ssh_conn *sshc = &conn->proto.sshc;
 392
 393 #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
 394   if(sshc->state != nowstate) {
 395     infof(conn->data, "SFTP %p state change from %s to %s\n",
 396           (void *)sshc, names[sshc->state], names[nowstate]);
 397   }
 398 #endif
 399
 400   sshc->state = nowstate;
 401 }
 402
 403 /* figure out the path to work with in this particular request */
 404 static CURLcode ssh_getworkingpath(struct connectdata *conn,
 405                                    char *homedir,  /* when SFTP is used */
 406                                    char **path) /* returns the  allocated
 407                                                    real path to work with */
 408 {
 409   struct SessionHandle *data = conn->data;
 410   char *real_path = NULL;
 411   char *working_path;
 412   int working_path_len;
 413
 414   working_path = curl_easy_unescape(data, data->state.path, 0,
 415                                     &working_path_len);
 416   if(!working_path)
 417     return CURLE_OUT_OF_MEMORY;
 418
 419   /* Check for /~/ , indicating relative to the user's home directory */
 420   if(conn->handler->protocol & CURLPROTO_SCP) {
 421     real_path = malloc(working_path_len+1);
 422     if(real_path == NULL) {
 423       free(working_path);
 424       return CURLE_OUT_OF_MEMORY;
 425     }
 426     if((working_path_len > 3) && (!memcmp(working_path, "/~/", 3)))
 427       /* It is referenced to the home directory, so strip the leading '/~/' */
 428       memcpy(real_path, working_path+3, 4 + working_path_len-3);
 429     else
 430       memcpy(real_path, working_path, 1 + working_path_len);
 431   }
 432   else if(conn->handler->protocol & CURLPROTO_SFTP) {
 433     if((working_path_len > 1) && (working_path[1] == '~')) {
 434       size_t homelen = strlen(homedir);
 435       real_path = malloc(homelen + working_path_len + 1);
 436       if(real_path == NULL) {
 437         free(working_path);
 438         return CURLE_OUT_OF_MEMORY;
 439       }
 440       /* It is referenced to the home directory, so strip the
 441          leading '/' */
 442       memcpy(real_path, homedir, homelen);
 443       real_path[homelen] = '/';
 444       real_path[homelen+1] = '\0';
 445       if(working_path_len > 3) {
 446         memcpy(real_path+homelen+1, working_path + 3,
 447                1 + working_path_len -3);
 448       }
 449     }
 450     else {
 451       real_path = malloc(working_path_len+1);
 452       if(real_path == NULL) {
 453         free(working_path);
 454         return CURLE_OUT_OF_MEMORY;
 455       }
 456       memcpy(real_path, working_path, 1+working_path_len);
 457     }
 458   }
 459
 460   free(working_path);
 461
 462   /* store the pointer for the caller to receive */
 463   *path = real_path;
 464
 465   return CURLE_OK;
 466 }
 467
 468 #ifdef HAVE_LIBSSH2_KNOWNHOST_API
 469 static int sshkeycallback(CURL *easy,
 470                           const struct curl_khkey *knownkey, /* known */
 471                           const struct curl_khkey *foundkey, /* found */
 472                           enum curl_khmatch match,
 473                           void *clientp)
 474 {
 475   (void)easy;
 476   (void)knownkey;
 477   (void)foundkey;
 478   (void)clientp;
 479
 480   /* we only allow perfect matches, and we reject everything else */
 481   return (match != CURLKHMATCH_OK)?CURLKHSTAT_REJECT:CURLKHSTAT_FINE;
 482 }
 483 #endif
 484
 485 /*
 486  * Earlier libssh2 versions didn't have the ability to seek to 64bit positions
 487  * with 32bit size_t.
 488  */
 489 #ifdef HAVE_LIBSSH2_SFTP_SEEK64
 490 #define SFTP_SEEK(x,y) libssh2_sftp_seek64(x, (libssh2_uint64_t)y)
 491 #else
 492 #define SFTP_SEEK(x,y) libssh2_sftp_seek(x, (size_t)y)
 493 #endif
 494
 495 /*
 496  * Earlier libssh2 versions didn't do SCP properly beyond 32bit sizes on 32bit
 497  * architectures so we check of the necessary function is present.
 498  */
 499 #ifndef HAVE_LIBSSH2_SCP_SEND64
 500 #define SCP_SEND(a,b,c,d) libssh2_scp_send_ex(a, b, (int)(c), (size_t)d, 0, 0)
 501 #else
 502 #define SCP_SEND(a,b,c,d) libssh2_scp_send64(a, b, (int)(c),            \
 503                                              (libssh2_uint64_t)d, 0, 0)
 504 #endif
 505
 506 /*
 507  * libssh2 1.2.8 fixed the problem with 32bit ints used for sockets on win64.
 508  */
 509 #ifdef HAVE_LIBSSH2_SESSION_HANDSHAKE
 510 #define libssh2_session_startup(x,y) libssh2_session_handshake(x,y)
 511 #endif
 512
 513 static CURLcode ssh_knownhost(struct connectdata *conn)
 514 {
 515   CURLcode result = CURLE_OK;
 516
 517 #ifdef HAVE_LIBSSH2_KNOWNHOST_API
 518   struct SessionHandle *data = conn->data;
 519
 520   if(data->set.str[STRING_SSH_KNOWNHOSTS]) {
 521     /* we're asked to verify the host against a file */
 522     struct ssh_conn *sshc = &conn->proto.sshc;
 523     int rc;
 524     int keytype;
 525     size_t keylen;
 526     const char *remotekey = libssh2_session_hostkey(sshc->ssh_session,
 527                                                     &keylen, &keytype);
 528     int keycheck = LIBSSH2_KNOWNHOST_CHECK_FAILURE;
 529     int keybit = 0;
 530
 531     if(remotekey) {
 532       /*
 533        * A subject to figure out is what host name we need to pass in here.
 534        * What host name does OpenSSH store in its file if an IDN name is
 535        * used?
 536        */
 537       struct libssh2_knownhost *host;
 538       enum curl_khmatch keymatch;
 539       curl_sshkeycallback func =
 540         data->set.ssh_keyfunc?data->set.ssh_keyfunc:sshkeycallback;
 541       struct curl_khkey knownkey;
 542       struct curl_khkey *knownkeyp = NULL;
 543       struct curl_khkey foundkey;
 544
 545       keybit = (keytype == LIBSSH2_HOSTKEY_TYPE_RSA)?
 546         LIBSSH2_KNOWNHOST_KEY_SSHRSA:LIBSSH2_KNOWNHOST_KEY_SSHDSS;
 547
 548       keycheck = libssh2_knownhost_check(sshc->kh,
 549                                          conn->host.name,
 550                                          remotekey, keylen,
 551                                          LIBSSH2_KNOWNHOST_TYPE_PLAIN|
 552                                          LIBSSH2_KNOWNHOST_KEYENC_RAW|
 553                                          keybit,
 554                                          &host);
 555
 556       infof(data, "SSH host check: %d, key: %s\n", keycheck,
 557             (keycheck <= LIBSSH2_KNOWNHOST_CHECK_MISMATCH)?
 558             host->key:"<none>");
 559
 560       /* setup 'knownkey' */
 561       if(keycheck <= LIBSSH2_KNOWNHOST_CHECK_MISMATCH) {
 562         knownkey.key = host->key;
 563         knownkey.len = 0;
 564         knownkey.keytype = (keytype == LIBSSH2_HOSTKEY_TYPE_RSA)?
 565           CURLKHTYPE_RSA : CURLKHTYPE_DSS;
 566         knownkeyp = &knownkey;
 567       }
 568
 569       /* setup 'foundkey' */
 570       foundkey.key = remotekey;
 571       foundkey.len = keylen;
 572       foundkey.keytype = (keytype == LIBSSH2_HOSTKEY_TYPE_RSA)?
 573         CURLKHTYPE_RSA : CURLKHTYPE_DSS;
 574
 575       /*
 576        * if any of the LIBSSH2_KNOWNHOST_CHECK_* defines and the
 577        * curl_khmatch enum are ever modified, we need to introduce a
 578        * translation table here!
 579        */
 580       keymatch = (enum curl_khmatch)keycheck;
 581
 582       /* Ask the callback how to behave */
 583       rc = func(data, knownkeyp, /* from the knownhosts file */
 584                 &foundkey, /* from the remote host */
 585                 keymatch, data->set.ssh_keyfunc_userp);
 586     }
 587     else
 588       /* no remotekey means failure! */
 589       rc = CURLKHSTAT_REJECT;
 590
 591     switch(rc) {
 592     default: /* unknown return codes will equal reject */
 593     case CURLKHSTAT_REJECT:
 594       state(conn, SSH_SESSION_FREE);
 595     case CURLKHSTAT_DEFER:
 596       /* DEFER means bail out but keep the SSH_HOSTKEY state */
 597       result = sshc->actualcode = CURLE_PEER_FAILED_VERIFICATION;
 598       break;
 599     case CURLKHSTAT_FINE:
 600     case CURLKHSTAT_FINE_ADD_TO_FILE:
 601       /* proceed */
 602       if(keycheck != LIBSSH2_KNOWNHOST_CHECK_MATCH) {
 603         /* the found host+key didn't match but has been told to be fine
 604            anyway so we add it in memory */
 605         int addrc = libssh2_knownhost_add(sshc->kh,
 606                                           conn->host.name, NULL,
 607                                           remotekey, keylen,
 608                                           LIBSSH2_KNOWNHOST_TYPE_PLAIN|
 609                                           LIBSSH2_KNOWNHOST_KEYENC_RAW|
 610                                           keybit, NULL);
 611         if(addrc)
 612           infof(data, "Warning adding the known host %s failed!\n",
 613                 conn->host.name);
 614         else if(rc == CURLKHSTAT_FINE_ADD_TO_FILE) {
 615           /* now we write the entire in-memory list of known hosts to the
 616              known_hosts file */
 617           int wrc =
 618             libssh2_knownhost_writefile(sshc->kh,
 619                                         data->set.str[STRING_SSH_KNOWNHOSTS],
 620                                         LIBSSH2_KNOWNHOST_FILE_OPENSSH);
 621           if(wrc) {
 622             infof(data, "Warning, writing %s failed!\n",
 623                   data->set.str[STRING_SSH_KNOWNHOSTS]);
 624           }
 625         }
 626       }
 627       break;
 628     }
 629   }
 630 #else /* HAVE_LIBSSH2_KNOWNHOST_API */
 631   (void)conn;
 632 #endif
 633   return result;
 634 }
 635
 636 static CURLcode ssh_check_fingerprint(struct connectdata *conn)
 637 {
 638   struct ssh_conn *sshc = &conn->proto.sshc;
 639   struct SessionHandle *data = conn->data;
 640   const char *pubkey_md5 = data->set.str[STRING_SSH_HOST_PUBLIC_KEY_MD5];
 641   char md5buffer[33];
 642   int i;
 643
 644   const char *fingerprint = libssh2_hostkey_hash(sshc->ssh_session,
 645       LIBSSH2_HOSTKEY_HASH_MD5);
 646
 647   if(fingerprint) {
 648     /* The fingerprint points to static storage (!), don't free() it. */
 649     for(i = 0; i < 16; i++)
 650       snprintf(&md5buffer[i*2], 3, "%02x", (unsigned char) fingerprint[i]);
 651     infof(data, "SSH MD5 fingerprint: %s\n", md5buffer);
 652   }
 653
 654   /* Before we authenticate we check the hostkey's MD5 fingerprint
 655    * against a known fingerprint, if available.
 656    */
 657   if(pubkey_md5 && strlen(pubkey_md5) == 32) {
 658     if(!fingerprint || !strequal(md5buffer, pubkey_md5)) {
 659       if(fingerprint)
 660         failf(data,
 661             "Denied establishing ssh session: mismatch md5 fingerprint. "
 662             "Remote %s is not equal to %s", md5buffer, pubkey_md5);
 663       else
 664         failf(data,
 665             "Denied establishing ssh session: md5 fingerprint not available");
 666       state(conn, SSH_SESSION_FREE);
 667       sshc->actualcode = CURLE_PEER_FAILED_VERIFICATION;
 668       return sshc->actualcode;
 669     }
 670     else {
 671       infof(data, "MD5 checksum match!\n");
 672       /* as we already matched, we skip the check for known hosts */
 673       return CURLE_OK;
 674     }
 675   }
 676   else
 677     return ssh_knownhost(conn);
 678 }
 679
 680 /*
 681  * ssh_statemach_act() runs the SSH state machine as far as it can without
 682  * blocking and without reaching the end.  The data the pointer 'block' points
 683  * to will be set to TRUE if the libssh2 function returns LIBSSH2_ERROR_EAGAIN
 684  * meaning it wants to be called again when the socket is ready
 685  */
 686
 687 static CURLcode ssh_statemach_act(struct connectdata *conn, bool *block)
 688 {
 689   CURLcode result = CURLE_OK;
 690   struct SessionHandle *data = conn->data;
 691   struct SSHPROTO *sftp_scp = data->req.protop;
 692   struct ssh_conn *sshc = &conn->proto.sshc;
 693   curl_socket_t sock = conn->sock[FIRSTSOCKET];
 694   char *new_readdir_line;
 695   int rc = LIBSSH2_ERROR_NONE;
 696   int err;
 697   int seekerr = CURL_SEEKFUNC_OK;
 698   *block = 0; /* we're not blocking by default */
 699
 700   do {
 701
 702     switch(sshc->state) {
 703     case SSH_INIT:
 704       sshc->secondCreateDirs = 0;
 705       sshc->nextstate = SSH_NO_STATE;
 706       sshc->actualcode = CURLE_OK;
 707
 708       /* Set libssh2 to non-blocking, since everything internally is
 709          non-blocking */
 710       libssh2_session_set_blocking(sshc->ssh_session, 0);
 711
 712       state(conn, SSH_S_STARTUP);
 713       /* fall-through */
 714
 715     case SSH_S_STARTUP:
 716       rc = libssh2_session_startup(sshc->ssh_session, (int)sock);
 717       if(rc == LIBSSH2_ERROR_EAGAIN) {
 718         break;
 719       }
 720       else if(rc) {
 721         failf(data, "Failure establishing ssh session");
 722         state(conn, SSH_SESSION_FREE);
 723         sshc->actualcode = CURLE_FAILED_INIT;
 724         break;
 725       }
 726
 727       state(conn, SSH_HOSTKEY);
 728
 729       /* fall-through */
 730     case SSH_HOSTKEY:
 731       /*
 732        * Before we authenticate we should check the hostkey's fingerprint
 733        * against our known hosts. How that is handled (reading from file,
 734        * whatever) is up to us.
 735        */
 736       result = ssh_check_fingerprint(conn);
 737       if(result == CURLE_OK)
 738         state(conn, SSH_AUTHLIST);
 739       break;
 740
 741     case SSH_AUTHLIST:
 742       /*
 743        * Figure out authentication methods
 744        * NB: As soon as we have provided a username to an openssh server we
 745        * must never change it later. Thus, always specify the correct username
 746        * here, even though the libssh2 docs kind of indicate that it should be
 747        * possible to get a 'generic' list (not user-specific) of authentication
 748        * methods, presumably with a blank username. That won't work in my
 749        * experience.
 750        * So always specify it here.
 751        */
 752       sshc->authlist = libssh2_userauth_list(sshc->ssh_session,
 753                                              conn->user,
 754                                              curlx_uztoui(strlen(conn->user)));
 755
 756       if(!sshc->authlist) {
 757         if(libssh2_userauth_authenticated(sshc->ssh_session)) {
 758           sshc->authed = TRUE;
 759           infof(data, "SSH user accepted with no authentication\n");
 760           state(conn, SSH_AUTH_DONE);
 761           break;
 762         }
 763         else if((err = libssh2_session_last_errno(sshc->ssh_session)) ==
 764            LIBSSH2_ERROR_EAGAIN) {
 765           rc = LIBSSH2_ERROR_EAGAIN;
 766           break;
 767         }
 768         else {
 769           state(conn, SSH_SESSION_FREE);
 770           sshc->actualcode = libssh2_session_error_to_CURLE(err);
 771           break;
 772         }
 773       }
 774       infof(data, "SSH authentication methods available: %s\n",
 775             sshc->authlist);
 776
 777       state(conn, SSH_AUTH_PKEY_INIT);
 778       break;
 779
 780     case SSH_AUTH_PKEY_INIT:
 781       /*
 782        * Check the supported auth types in the order I feel is most secure
 783        * with the requested type of authentication
 784        */
 785       sshc->authed = FALSE;
 786
 787       if((data->set.ssh_auth_types & CURLSSH_AUTH_PUBLICKEY) &&
 788          (strstr(sshc->authlist, "publickey") != NULL)) {
 789         char *home = NULL;
 790         bool rsa_pub_empty_but_ok = FALSE;
 791
 792         sshc->rsa_pub = sshc->rsa = NULL;
 793
 794         /* To ponder about: should really the lib be messing about with the
 795            HOME environment variable etc? */
 796         home = curl_getenv("HOME");
 797
 798         if(data->set.str[STRING_SSH_PUBLIC_KEY] &&
 799            !*data->set.str[STRING_SSH_PUBLIC_KEY])
 800            rsa_pub_empty_but_ok = true;
 801         else if(data->set.str[STRING_SSH_PUBLIC_KEY])
 802           sshc->rsa_pub = aprintf("%s", data->set.str[STRING_SSH_PUBLIC_KEY]);
 803         else if(home)
 804           sshc->rsa_pub = aprintf("%s/.ssh/id_dsa.pub", home);
 805         else
 806           /* as a final resort, try current dir! */
 807           sshc->rsa_pub = strdup("id_dsa.pub");
 808
 809         if(!rsa_pub_empty_but_ok && (sshc->rsa_pub == NULL)) {
 810           Curl_safefree(home);
 811           state(conn, SSH_SESSION_FREE);
 812           sshc->actualcode = CURLE_OUT_OF_MEMORY;
 813           break;
 814         }
 815
 816         if(data->set.str[STRING_SSH_PRIVATE_KEY])
 817           sshc->rsa = aprintf("%s", data->set.str[STRING_SSH_PRIVATE_KEY]);
 818         else if(home)
 819           sshc->rsa = aprintf("%s/.ssh/id_dsa", home);
 820         else
 821           /* as a final resort, try current dir! */
 822           sshc->rsa = strdup("id_dsa");
 823
 824         if(sshc->rsa == NULL) {
 825           Curl_safefree(home);
 826           Curl_safefree(sshc->rsa_pub);
 827           state(conn, SSH_SESSION_FREE);
 828           sshc->actualcode = CURLE_OUT_OF_MEMORY;
 829           break;
 830         }
 831
 832         sshc->passphrase = data->set.str[STRING_KEY_PASSWD];
 833         if(!sshc->passphrase)
 834           sshc->passphrase = "";
 835
 836         Curl_safefree(home);
 837
 838         infof(data, "Using ssh public key file %s\n", sshc->rsa_pub);
 839         infof(data, "Using ssh private key file %s\n", sshc->rsa);
 840
 841         state(conn, SSH_AUTH_PKEY);
 842       }
 843       else {
 844         state(conn, SSH_AUTH_PASS_INIT);
 845       }
 846       break;
 847
 848     case SSH_AUTH_PKEY:
 849       /* The function below checks if the files exists, no need to stat() here.
 850        */
 851       rc = libssh2_userauth_publickey_fromfile_ex(sshc->ssh_session,
 852                                                   conn->user,
 853                                                   curlx_uztoui(
 854                                                     strlen(conn->user)),
 855                                                   sshc->rsa_pub,
 856                                                   sshc->rsa, sshc->passphrase);
 857       if(rc == LIBSSH2_ERROR_EAGAIN) {
 858         break;
 859       }
 860
 861       Curl_safefree(sshc->rsa_pub);
 862       Curl_safefree(sshc->rsa);
 863
 864       if(rc == 0) {
 865         sshc->authed = TRUE;
 866         infof(data, "Initialized SSH public key authentication\n");
 867         state(conn, SSH_AUTH_DONE);
 868       }
 869       else {
 870         char *err_msg;
 871         (void)libssh2_session_last_error(sshc->ssh_session,
 872                                          &err_msg, NULL, 0);
 873         infof(data, "SSH public key authentication failed: %s\n", err_msg);
 874         state(conn, SSH_AUTH_PASS_INIT);
 875       }
 876       break;
 877
 878     case SSH_AUTH_PASS_INIT:
 879       if((data->set.ssh_auth_types & CURLSSH_AUTH_PASSWORD) &&
 880          (strstr(sshc->authlist, "password") != NULL)) {
 881         state(conn, SSH_AUTH_PASS);
 882       }
 883       else {
 884         state(conn, SSH_AUTH_HOST_INIT);
 885       }
 886       break;
 887
 888     case SSH_AUTH_PASS:
 889       rc = libssh2_userauth_password_ex(sshc->ssh_session, conn->user,
 890                                         curlx_uztoui(strlen(conn->user)),
 891                                         conn->passwd,
 892                                         curlx_uztoui(strlen(conn->passwd)),
 893                                         NULL);
 894       if(rc == LIBSSH2_ERROR_EAGAIN) {
 895         break;
 896       }
 897       else if(rc == 0) {
 898         sshc->authed = TRUE;
 899         infof(data, "Initialized password authentication\n");
 900         state(conn, SSH_AUTH_DONE);
 901       }
 902       else {
 903         state(conn, SSH_AUTH_HOST_INIT);
 904       }
 905       break;
 906
 907     case SSH_AUTH_HOST_INIT:
 908       if((data->set.ssh_auth_types & CURLSSH_AUTH_HOST) &&
 909          (strstr(sshc->authlist, "hostbased") != NULL)) {
 910         state(conn, SSH_AUTH_HOST);
 911       }
 912       else {
 913         state(conn, SSH_AUTH_AGENT_INIT);
 914       }
 915       break;
 916
 917     case SSH_AUTH_HOST:
 918       state(conn, SSH_AUTH_AGENT_INIT);
 919       break;
 920
 921     case SSH_AUTH_AGENT_INIT:
 922 #ifdef HAVE_LIBSSH2_AGENT_API
 923       if((data->set.ssh_auth_types & CURLSSH_AUTH_AGENT)
 924          && (strstr(sshc->authlist, "publickey") != NULL)) {
 925
 926         /* Connect to the ssh-agent */
 927         /* The agent could be shared by a curl thread i believe
 928            but nothing obvious as keys can be added/removed at any time */
 929         if(!sshc->ssh_agent) {
 930           sshc->ssh_agent = libssh2_agent_init(sshc->ssh_session);
 931           if(!sshc->ssh_agent) {
 932             infof(data, "Could not create agent object\n");
 933
 934             state(conn, SSH_AUTH_KEY_INIT);
 935           }
 936         }
 937
 938         rc = libssh2_agent_connect(sshc->ssh_agent);
 939         if(rc == LIBSSH2_ERROR_EAGAIN)
 940           break;
 941         if(rc < 0) {
 942           infof(data, "Failure connecting to agent\n");
 943           state(conn, SSH_AUTH_KEY_INIT);
 944         }
 945         else {
 946           state(conn, SSH_AUTH_AGENT_LIST);
 947         }
 948       }
 949       else
 950 #endif /* HAVE_LIBSSH2_AGENT_API */
 951         state(conn, SSH_AUTH_KEY_INIT);
 952       break;
 953
 954     case SSH_AUTH_AGENT_LIST:
 955 #ifdef HAVE_LIBSSH2_AGENT_API
 956       rc = libssh2_agent_list_identities(sshc->ssh_agent);
 957
 958       if(rc == LIBSSH2_ERROR_EAGAIN)
 959         break;
 960       if(rc < 0) {
 961         infof(data, "Failure requesting identities to agent\n");
 962         state(conn, SSH_AUTH_KEY_INIT);
 963       }
 964       else {
 965         state(conn, SSH_AUTH_AGENT);
 966         sshc->sshagent_prev_identity = NULL;
 967       }
 968 #endif
 969       break;
 970
 971     case SSH_AUTH_AGENT:
 972 #ifdef HAVE_LIBSSH2_AGENT_API
 973       /* as prev_identity evolves only after an identity user auth finished we
 974          can safely request it again as long as EAGAIN is returned here or by
 975          libssh2_agent_userauth */
 976       rc = libssh2_agent_get_identity(sshc->ssh_agent,
 977                                       &sshc->sshagent_identity,
 978                                       sshc->sshagent_prev_identity);
 979       if(rc == LIBSSH2_ERROR_EAGAIN)
 980         break;
 981
 982       if(rc == 0) {
 983         rc = libssh2_agent_userauth(sshc->ssh_agent, conn->user,
 984                                     sshc->sshagent_identity);
 985
 986         if(rc < 0) {
 987           if(rc != LIBSSH2_ERROR_EAGAIN) {
 988             /* tried and failed? go to next identity */
 989             sshc->sshagent_prev_identity = sshc->sshagent_identity;
 990           }
 991           break;
 992         }
 993       }
 994
 995       if(rc < 0)
 996         infof(data, "Failure requesting identities to agent\n");
 997       else if(rc == 1)
 998         infof(data, "No identity would match\n");
 999
1000       if(rc == LIBSSH2_ERROR_NONE) {
1001         sshc->authed = TRUE;
1002         infof(data, "Agent based authentication successful\n");
1003         state(conn, SSH_AUTH_DONE);
1004       }
1005       else
1006         state(conn, SSH_AUTH_KEY_INIT);
1007 #endif
1008       break;
1009
1010     case SSH_AUTH_KEY_INIT:
1011       if((data->set.ssh_auth_types & CURLSSH_AUTH_KEYBOARD)
1012          && (strstr(sshc->authlist, "keyboard-interactive") != NULL)) {
1013         state(conn, SSH_AUTH_KEY);
1014       }
1015       else {
1016         state(conn, SSH_AUTH_DONE);
1017       }
1018       break;
1019
1020     case SSH_AUTH_KEY:
1021       /* Authentication failed. Continue with keyboard-interactive now. */
1022       rc = libssh2_userauth_keyboard_interactive_ex(sshc->ssh_session,
1023                                                     conn->user,
1024                                                     curlx_uztoui(
1025                                                       strlen(conn->user)),
1026                                                     &kbd_callback);
1027       if(rc == LIBSSH2_ERROR_EAGAIN) {
1028         break;
1029       }
1030       else if(rc == 0) {
1031         sshc->authed = TRUE;
1032         infof(data, "Initialized keyboard interactive authentication\n");
1033       }
1034       state(conn, SSH_AUTH_DONE);
1035       break;
1036
1037     case SSH_AUTH_DONE:
1038       if(!sshc->authed) {
1039         failf(data, "Authentication failure");
1040         state(conn, SSH_SESSION_FREE);
1041         sshc->actualcode = CURLE_LOGIN_DENIED;
1042         break;
1043       }
1044
1045       /*
1046        * At this point we have an authenticated ssh session.
1047        */
1048       infof(data, "Authentication complete\n");
1049
1050       Curl_pgrsTime(conn->data, TIMER_APPCONNECT); /* SSH is connected */
1051
1052       conn->sockfd = sock;
1053       conn->writesockfd = CURL_SOCKET_BAD;
1054
1055       if(conn->handler->protocol == CURLPROTO_SFTP) {
1056         state(conn, SSH_SFTP_INIT);
1057         break;
1058       }
1059       infof(data, "SSH CONNECT phase done\n");
1060       state(conn, SSH_STOP);
1061       break;
1062
1063     case SSH_SFTP_INIT:
1064       /*
1065        * Start the libssh2 sftp session
1066        */
1067       sshc->sftp_session = libssh2_sftp_init(sshc->ssh_session);
1068       if(!sshc->sftp_session) {
1069         if(libssh2_session_last_errno(sshc->ssh_session) ==
1070            LIBSSH2_ERROR_EAGAIN) {
1071           rc = LIBSSH2_ERROR_EAGAIN;
1072           break;
1073         }
1074         else {
1075           char *err_msg;
1076
1077           (void)libssh2_session_last_error(sshc->ssh_session,
1078                                            &err_msg, NULL, 0);
1079           failf(data, "Failure initializing sftp session: %s", err_msg);
1080           state(conn, SSH_SESSION_FREE);
1081           sshc->actualcode = CURLE_FAILED_INIT;
1082           break;
1083         }
1084       }
1085       state(conn, SSH_SFTP_REALPATH);
1086       break;
1087
1088     case SSH_SFTP_REALPATH:
1089     {
1090       char tempHome[PATH_MAX];
1091
1092       /*
1093        * Get the "home" directory
1094        */
1095       rc = sftp_libssh2_realpath(sshc->sftp_session, ".",
1096                                  tempHome, PATH_MAX-1);
1097       if(rc == LIBSSH2_ERROR_EAGAIN) {
1098         break;
1099       }
1100       else if(rc > 0) {
1101         /* It seems that this string is not always NULL terminated */
1102         tempHome[rc] = '\0';
1103         sshc->homedir = strdup(tempHome);
1104         if(!sshc->homedir) {
1105           state(conn, SSH_SFTP_CLOSE);
1106           sshc->actualcode = CURLE_OUT_OF_MEMORY;
1107           break;
1108         }
1109         conn->data->state.most_recent_ftp_entrypath = sshc->homedir;
1110       }
1111       else {
1112         /* Return the error type */
1113         err = sftp_libssh2_last_error(sshc->sftp_session);
1114         result = sftp_libssh2_error_to_CURLE(err);
1115         sshc->actualcode = result?result:CURLE_SSH;
1116         DEBUGF(infof(data, "error = %d makes libcurl = %d\n",
1117                      err, (int)result));
1118         state(conn, SSH_STOP);
1119         break;
1120       }
1121     }
1122     /* This is the last step in the SFTP connect phase. Do note that while
1123        we get the homedir here, we get the "workingpath" in the DO action
1124        since the homedir will remain the same between request but the
1125        working path will not. */
1126     DEBUGF(infof(data, "SSH CONNECT phase done\n"));
1127     state(conn, SSH_STOP);
1128     break;
1129
1130     case SSH_SFTP_QUOTE_INIT:
1131
1132       result = ssh_getworkingpath(conn, sshc->homedir, &sftp_scp->path);
1133       if(result) {
1134         sshc->actualcode = result;
1135         state(conn, SSH_STOP);
1136         break;
1137       }
1138
1139       if(data->set.quote) {
1140         infof(data, "Sending quote commands\n");
1141         sshc->quote_item = data->set.quote;
1142         state(conn, SSH_SFTP_QUOTE);
1143       }
1144       else {
1145         state(conn, SSH_SFTP_TRANS_INIT);
1146       }
1147       break;
1148
1149     case SSH_SFTP_POSTQUOTE_INIT:
1150       if(data->set.postquote) {
1151         infof(data, "Sending quote commands\n");
1152         sshc->quote_item = data->set.postquote;
1153         state(conn, SSH_SFTP_QUOTE);
1154       }
1155       else {
1156         state(conn, SSH_STOP);
1157       }
1158       break;
1159
1160     case SSH_SFTP_QUOTE:
1161       /* Send any quote commands */
1162     {
1163       const char *cp;
1164
1165       /*
1166        * Support some of the "FTP" commands
1167        */
1168       char *cmd = sshc->quote_item->data;
1169       sshc->acceptfail = FALSE;
1170
1171       /* if a command starts with an asterisk, which a legal SFTP command never
1172          can, the command will be allowed to fail without it causing any
1173          aborts or cancels etc. It will cause libcurl to act as if the command
1174          is successful, whatever the server reponds. */
1175
1176       if(cmd[0] == '*') {
1177         cmd++;
1178         sshc->acceptfail = TRUE;
1179       }
1180
1181       if(curl_strequal("pwd", cmd)) {
1182         /* output debug output if that is requested */
1183         char *tmp = aprintf("257 \"%s\" is current directory.\n",
1184                             sftp_scp->path);
1185         if(!tmp) {
1186           result = CURLE_OUT_OF_MEMORY;
1187           state(conn, SSH_SFTP_CLOSE);
1188           sshc->nextstate = SSH_NO_STATE;
1189           break;
1190         }
1191         if(data->set.verbose) {
1192           Curl_debug(data, CURLINFO_HEADER_OUT, (char *)"PWD\n", 4, conn);
1193           Curl_debug(data, CURLINFO_HEADER_IN, tmp, strlen(tmp), conn);
1194         }
1195         /* this sends an FTP-like "header" to the header callback so that the
1196            current directory can be read very similar to how it is read when
1197            using ordinary FTP. */
1198         result = Curl_client_write(conn, CLIENTWRITE_HEADER, tmp, strlen(tmp));
1199         free(tmp);
1200         state(conn, SSH_SFTP_NEXT_QUOTE);
1201         break;
1202       }
1203       else if(cmd) {
1204         /*
1205          * the arguments following the command must be separated from the
1206          * command with a space so we can check for it unconditionally
1207          */
1208         cp = strchr(cmd, ' ');
1209         if(cp == NULL) {
1210           failf(data, "Syntax error in SFTP command. Supply parameter(s)!");
1211           state(conn, SSH_SFTP_CLOSE);
1212           sshc->nextstate = SSH_NO_STATE;
1213           sshc->actualcode = CURLE_QUOTE_ERROR;
1214           break;
1215         }
1216
1217         /*
1218          * also, every command takes at least one argument so we get that
1219          * first argument right now
1220          */
1221         result = get_pathname(&cp, &sshc->quote_path1);
1222         if(result) {
1223           if(result == CURLE_OUT_OF_MEMORY)
1224             failf(data, "Out of memory");
1225           else
1226             failf(data, "Syntax error: Bad first parameter");
1227           state(conn, SSH_SFTP_CLOSE);
1228           sshc->nextstate = SSH_NO_STATE;
1229           sshc->actualcode = result;
1230           break;
1231         }
1232
1233         /*
1234          * SFTP is a binary protocol, so we don't send text commands to
1235          * the server. Instead, we scan for commands for commands used by
1236          * OpenSSH's sftp program and call the appropriate libssh2
1237          * functions.
1238          */
1239         if(curl_strnequal(cmd, "chgrp ", 6) ||
1240            curl_strnequal(cmd, "chmod ", 6) ||
1241            curl_strnequal(cmd, "chown ", 6) ) {
1242           /* attribute change */
1243
1244           /* sshc->quote_path1 contains the mode to set */
1245           /* get the destination */
1246           result = get_pathname(&cp, &sshc->quote_path2);
1247           if(result) {
1248             if(result == CURLE_OUT_OF_MEMORY)
1249               failf(data, "Out of memory");
1250             else
1251               failf(data, "Syntax error in chgrp/chmod/chown: "
1252                     "Bad second parameter");
1253             Curl_safefree(sshc->quote_path1);
1254             state(conn, SSH_SFTP_CLOSE);
1255             sshc->nextstate = SSH_NO_STATE;
1256             sshc->actualcode = result;
1257             break;
1258           }
1259           memset(&sshc->quote_attrs, 0, sizeof(LIBSSH2_SFTP_ATTRIBUTES));
1260           state(conn, SSH_SFTP_QUOTE_STAT);
1261           break;
1262         }
1263         else if(curl_strnequal(cmd, "ln ", 3) ||
1264                 curl_strnequal(cmd, "symlink ", 8)) {
1265           /* symbolic linking */
1266           /* sshc->quote_path1 is the source */
1267           /* get the destination */
1268           result = get_pathname(&cp, &sshc->quote_path2);
1269           if(result) {
1270             if(result == CURLE_OUT_OF_MEMORY)
1271               failf(data, "Out of memory");
1272             else
1273               failf(data,
1274                     "Syntax error in ln/symlink: Bad second parameter");
1275             Curl_safefree(sshc->quote_path1);
1276             state(conn, SSH_SFTP_CLOSE);
1277             sshc->nextstate = SSH_NO_STATE;
1278             sshc->actualcode = result;
1279             break;
1280           }
1281           state(conn, SSH_SFTP_QUOTE_SYMLINK);
1282           break;
1283         }
1284         else if(curl_strnequal(cmd, "mkdir ", 6)) {
1285           /* create dir */
1286           state(conn, SSH_SFTP_QUOTE_MKDIR);
1287           break;
1288         }
1289         else if(curl_strnequal(cmd, "rename ", 7)) {
1290           /* rename file */
1291           /* first param is the source path */
1292           /* second param is the dest. path */
1293           result = get_pathname(&cp, &sshc->quote_path2);
1294           if(result) {
1295             if(result == CURLE_OUT_OF_MEMORY)
1296               failf(data, "Out of memory");
1297             else
1298               failf(data, "Syntax error in rename: Bad second parameter");
1299             Curl_safefree(sshc->quote_path1);
1300             state(conn, SSH_SFTP_CLOSE);
1301             sshc->nextstate = SSH_NO_STATE;
1302             sshc->actualcode = result;
1303             break;
1304           }
1305           state(conn, SSH_SFTP_QUOTE_RENAME);
1306           break;
1307         }
1308         else if(curl_strnequal(cmd, "rmdir ", 6)) {
1309           /* delete dir */
1310           state(conn, SSH_SFTP_QUOTE_RMDIR);
1311           break;
1312         }
1313         else if(curl_strnequal(cmd, "rm ", 3)) {
1314           state(conn, SSH_SFTP_QUOTE_UNLINK);
1315           break;
1316         }
1317
1318         failf(data, "Unknown SFTP command");
1319         Curl_safefree(sshc->quote_path1);
1320         Curl_safefree(sshc->quote_path2);
1321         state(conn, SSH_SFTP_CLOSE);
1322         sshc->nextstate = SSH_NO_STATE;
1323         sshc->actualcode = CURLE_QUOTE_ERROR;
1324         break;
1325       }
1326     }
1327     if(!sshc->quote_item) {
1328       state(conn, SSH_SFTP_TRANS_INIT);
1329     }
1330     break;
1331
1332     case SSH_SFTP_NEXT_QUOTE:
1333       Curl_safefree(sshc->quote_path1);
1334       Curl_safefree(sshc->quote_path2);
1335
1336       sshc->quote_item = sshc->quote_item->next;
1337
1338       if(sshc->quote_item) {
1339         state(conn, SSH_SFTP_QUOTE);
1340       }
1341       else {
1342         if(sshc->nextstate != SSH_NO_STATE) {
1343           state(conn, sshc->nextstate);
1344           sshc->nextstate = SSH_NO_STATE;
1345         }
1346         else {
1347           state(conn, SSH_SFTP_TRANS_INIT);
1348         }
1349       }
1350       break;
1351
1352     case SSH_SFTP_QUOTE_STAT:
1353     {
1354       char *cmd = sshc->quote_item->data;
1355       sshc->acceptfail = FALSE;
1356
1357       /* if a command starts with an asterisk, which a legal SFTP command never
1358          can, the command will be allowed to fail without it causing any
1359          aborts or cancels etc. It will cause libcurl to act as if the command
1360          is successful, whatever the server reponds. */
1361
1362       if(cmd[0] == '*') {
1363         cmd++;
1364         sshc->acceptfail = TRUE;
1365       }
1366
1367       if(!curl_strnequal(cmd, "chmod", 5)) {
1368         /* Since chown and chgrp only set owner OR group but libssh2 wants to
1369          * set them both at once, we need to obtain the current ownership
1370          * first.  This takes an extra protocol round trip.
1371          */
1372         rc = libssh2_sftp_stat_ex(sshc->sftp_session, sshc->quote_path2,
1373                                   curlx_uztoui(strlen(sshc->quote_path2)),
1374                                   LIBSSH2_SFTP_STAT,
1375                                   &sshc->quote_attrs);
1376         if(rc == LIBSSH2_ERROR_EAGAIN) {
1377           break;
1378         }
1379         else if(rc != 0 && !sshc->acceptfail) { /* get those attributes */
1380           err = sftp_libssh2_last_error(sshc->sftp_session);
1381           Curl_safefree(sshc->quote_path1);
1382           Curl_safefree(sshc->quote_path2);
1383           failf(data, "Attempt to get SFTP stats failed: %s",
1384                 sftp_libssh2_strerror(err));
1385           state(conn, SSH_SFTP_CLOSE);
1386           sshc->nextstate = SSH_NO_STATE;
1387           sshc->actualcode = CURLE_QUOTE_ERROR;
1388           break;
1389         }
1390       }
1391
1392       /* Now set the new attributes... */
1393       if(curl_strnequal(cmd, "chgrp", 5)) {
1394         sshc->quote_attrs.gid = strtoul(sshc->quote_path1, NULL, 10);
1395         sshc->quote_attrs.flags = LIBSSH2_SFTP_ATTR_UIDGID;
1396         if(sshc->quote_attrs.gid == 0 && !ISDIGIT(sshc->quote_path1[0]) &&
1397            !sshc->acceptfail) {
1398           Curl_safefree(sshc->quote_path1);
1399           Curl_safefree(sshc->quote_path2);
1400           failf(data, "Syntax error: chgrp gid not a number");
1401           state(conn, SSH_SFTP_CLOSE);
1402           sshc->nextstate = SSH_NO_STATE;
1403           sshc->actualcode = CURLE_QUOTE_ERROR;
1404           break;
1405         }
1406       }
1407       else if(curl_strnequal(cmd, "chmod", 5)) {
1408         sshc->quote_attrs.permissions = strtoul(sshc->quote_path1, NULL, 8);
1409         sshc->quote_attrs.flags = LIBSSH2_SFTP_ATTR_PERMISSIONS;
1410         /* permissions are octal */
1411         if(sshc->quote_attrs.permissions == 0 &&
1412            !ISDIGIT(sshc->quote_path1[0])) {
1413           Curl_safefree(sshc->quote_path1);
1414           Curl_safefree(sshc->quote_path2);
1415           failf(data, "Syntax error: chmod permissions not a number");
1416           state(conn, SSH_SFTP_CLOSE);
1417           sshc->nextstate = SSH_NO_STATE;
1418           sshc->actualcode = CURLE_QUOTE_ERROR;
1419           break;
1420         }
1421       }
1422       else if(curl_strnequal(cmd, "chown", 5)) {
1423         sshc->quote_attrs.uid = strtoul(sshc->quote_path1, NULL, 10);
1424         sshc->quote_attrs.flags = LIBSSH2_SFTP_ATTR_UIDGID;
1425         if(sshc->quote_attrs.uid == 0 && !ISDIGIT(sshc->quote_path1[0]) &&
1426            !sshc->acceptfail) {
1427           Curl_safefree(sshc->quote_path1);
1428           Curl_safefree(sshc->quote_path2);
1429           failf(data, "Syntax error: chown uid not a number");
1430           state(conn, SSH_SFTP_CLOSE);
1431           sshc->nextstate = SSH_NO_STATE;
1432           sshc->actualcode = CURLE_QUOTE_ERROR;
1433           break;
1434         }
1435       }
1436
1437       /* Now send the completed structure... */
1438       state(conn, SSH_SFTP_QUOTE_SETSTAT);
1439       break;
1440     }
1441
1442     case SSH_SFTP_QUOTE_SETSTAT:
1443       rc = libssh2_sftp_stat_ex(sshc->sftp_session, sshc->quote_path2,
1444                                 curlx_uztoui(strlen(sshc->quote_path2)),
1445                                 LIBSSH2_SFTP_SETSTAT,
1446                                 &sshc->quote_attrs);
1447       if(rc == LIBSSH2_ERROR_EAGAIN) {
1448         break;
1449       }
1450       else if(rc != 0 && !sshc->acceptfail) {
1451         err = sftp_libssh2_last_error(sshc->sftp_session);
1452         Curl_safefree(sshc->quote_path1);
1453         Curl_safefree(sshc->quote_path2);
1454         failf(data, "Attempt to set SFTP stats failed: %s",
1455               sftp_libssh2_strerror(err));
1456         state(conn, SSH_SFTP_CLOSE);
1457         sshc->nextstate = SSH_NO_STATE;
1458         sshc->actualcode = CURLE_QUOTE_ERROR;
1459         break;
1460       }
1461       state(conn, SSH_SFTP_NEXT_QUOTE);
1462       break;
1463
1464     case SSH_SFTP_QUOTE_SYMLINK:
1465       rc = libssh2_sftp_symlink_ex(sshc->sftp_session, sshc->quote_path1,
1466                                    curlx_uztoui(strlen(sshc->quote_path1)),
1467                                    sshc->quote_path2,
1468                                    curlx_uztoui(strlen(sshc->quote_path2)),
1469                                    LIBSSH2_SFTP_SYMLINK);
1470       if(rc == LIBSSH2_ERROR_EAGAIN) {
1471         break;
1472       }
1473       else if(rc != 0 && !sshc->acceptfail) {
1474         err = sftp_libssh2_last_error(sshc->sftp_session);
1475         Curl_safefree(sshc->quote_path1);
1476         Curl_safefree(sshc->quote_path2);
1477         failf(data, "symlink command failed: %s",
1478               sftp_libssh2_strerror(err));
1479         state(conn, SSH_SFTP_CLOSE);
1480         sshc->nextstate = SSH_NO_STATE;
1481         sshc->actualcode = CURLE_QUOTE_ERROR;
1482         break;
1483       }
1484       state(conn, SSH_SFTP_NEXT_QUOTE);
1485       break;
1486
1487     case SSH_SFTP_QUOTE_MKDIR:
1488       rc = libssh2_sftp_mkdir_ex(sshc->sftp_session, sshc->quote_path1,
1489                                  curlx_uztoui(strlen(sshc->quote_path1)),
1490                                  data->set.new_directory_perms);
1491       if(rc == LIBSSH2_ERROR_EAGAIN) {
1492         break;
1493       }
1494       else if(rc != 0 && !sshc->acceptfail) {
1495         err = sftp_libssh2_last_error(sshc->sftp_session);
1496         Curl_safefree(sshc->quote_path1);
1497         failf(data, "mkdir command failed: %s", sftp_libssh2_strerror(err));
1498         state(conn, SSH_SFTP_CLOSE);
1499         sshc->nextstate = SSH_NO_STATE;
1500         sshc->actualcode = CURLE_QUOTE_ERROR;
1501         break;
1502       }
1503       state(conn, SSH_SFTP_NEXT_QUOTE);
1504       break;
1505
1506     case SSH_SFTP_QUOTE_RENAME:
1507       rc = libssh2_sftp_rename_ex(sshc->sftp_session, sshc->quote_path1,
1508                                   curlx_uztoui(strlen(sshc->quote_path1)),
1509                                   sshc->quote_path2,
1510                                   curlx_uztoui(strlen(sshc->quote_path2)),
1511                                   LIBSSH2_SFTP_RENAME_OVERWRITE |
1512                                   LIBSSH2_SFTP_RENAME_ATOMIC |
1513                                   LIBSSH2_SFTP_RENAME_NATIVE);
1514
1515       if(rc == LIBSSH2_ERROR_EAGAIN) {
1516         break;
1517       }
1518       else if(rc != 0 && !sshc->acceptfail) {
1519         err = sftp_libssh2_last_error(sshc->sftp_session);
1520         Curl_safefree(sshc->quote_path1);
1521         Curl_safefree(sshc->quote_path2);
1522         failf(data, "rename command failed: %s", sftp_libssh2_strerror(err));
1523         state(conn, SSH_SFTP_CLOSE);
1524         sshc->nextstate = SSH_NO_STATE;
1525         sshc->actualcode = CURLE_QUOTE_ERROR;
1526         break;
1527       }
1528       state(conn, SSH_SFTP_NEXT_QUOTE);
1529       break;
1530
1531     case SSH_SFTP_QUOTE_RMDIR:
1532       rc = libssh2_sftp_rmdir_ex(sshc->sftp_session, sshc->quote_path1,
1533                                  curlx_uztoui(strlen(sshc->quote_path1)));
1534       if(rc == LIBSSH2_ERROR_EAGAIN) {
1535         break;
1536       }
1537       else if(rc != 0 && !sshc->acceptfail) {
1538         err = sftp_libssh2_last_error(sshc->sftp_session);
1539         Curl_safefree(sshc->quote_path1);
1540         failf(data, "rmdir command failed: %s", sftp_libssh2_strerror(err));
1541         state(conn, SSH_SFTP_CLOSE);
1542         sshc->nextstate = SSH_NO_STATE;
1543         sshc->actualcode = CURLE_QUOTE_ERROR;
1544         break;
1545       }
1546       state(conn, SSH_SFTP_NEXT_QUOTE);
1547       break;
1548
1549     case SSH_SFTP_QUOTE_UNLINK:
1550       rc = libssh2_sftp_unlink_ex(sshc->sftp_session, sshc->quote_path1,
1551                                   curlx_uztoui(strlen(sshc->quote_path1)));
1552       if(rc == LIBSSH2_ERROR_EAGAIN) {
1553         break;
1554       }
1555       else if(rc != 0 && !sshc->acceptfail) {
1556         err = sftp_libssh2_last_error(sshc->sftp_session);
1557         Curl_safefree(sshc->quote_path1);
1558         failf(data, "rm command failed: %s", sftp_libssh2_strerror(err));
1559         state(conn, SSH_SFTP_CLOSE);
1560         sshc->nextstate = SSH_NO_STATE;
1561         sshc->actualcode = CURLE_QUOTE_ERROR;
1562         break;
1563       }
1564       state(conn, SSH_SFTP_NEXT_QUOTE);
1565       break;
1566
1567     case SSH_SFTP_TRANS_INIT:
1568       if(data->set.upload)
1569         state(conn, SSH_SFTP_UPLOAD_INIT);
1570       else {
1571         if(data->set.opt_no_body)
1572           state(conn, SSH_STOP);
1573         else if(sftp_scp->path[strlen(sftp_scp->path)-1] == '/')
1574           state(conn, SSH_SFTP_READDIR_INIT);
1575         else
1576           state(conn, SSH_SFTP_DOWNLOAD_INIT);
1577       }
1578       break;
1579
1580     case SSH_SFTP_UPLOAD_INIT:
1581     {
1582       unsigned long flags;
1583       /*
1584        * NOTE!!!  libssh2 requires that the destination path is a full path
1585        *          that includes the destination file and name OR ends in a "/"
1586        *          If this is not done the destination file will be named the
1587        *          same name as the last directory in the path.
1588        */
1589
1590       if(data->state.resume_from != 0) {
1591         LIBSSH2_SFTP_ATTRIBUTES attrs;
1592         if(data->state.resume_from < 0) {
1593           rc = libssh2_sftp_stat_ex(sshc->sftp_session, sftp_scp->path,
1594                                     curlx_uztoui(strlen(sftp_scp->path)),
1595                                     LIBSSH2_SFTP_STAT, &attrs);
1596           if(rc == LIBSSH2_ERROR_EAGAIN) {
1597             break;
1598           }
1599           else if(rc) {
1600             data->state.resume_from = 0;
1601           }
1602           else {
1603             curl_off_t size = attrs.filesize;
1604             if(size < 0) {
1605               failf(data, "Bad file size (%" FORMAT_OFF_T ")", size);
1606               return CURLE_BAD_DOWNLOAD_RESUME;
1607             }
1608             data->state.resume_from = attrs.filesize;
1609           }
1610         }
1611       }
1612
1613       if(data->set.ftp_append)
1614         /* Try to open for append, but create if nonexisting */
1615         flags = LIBSSH2_FXF_WRITE|LIBSSH2_FXF_CREAT|LIBSSH2_FXF_APPEND;
1616       else if(data->state.resume_from > 0)
1617         /* If we have restart position then open for append */
1618         flags = LIBSSH2_FXF_WRITE|LIBSSH2_FXF_APPEND;
1619       else
1620         /* Clear file before writing (normal behaviour) */
1621         flags = LIBSSH2_FXF_WRITE|LIBSSH2_FXF_CREAT|LIBSSH2_FXF_TRUNC;
1622
1623       sshc->sftp_handle =
1624         libssh2_sftp_open_ex(sshc->sftp_session, sftp_scp->path,
1625                              curlx_uztoui(strlen(sftp_scp->path)),
1626                              flags, data->set.new_file_perms,
1627                              LIBSSH2_SFTP_OPENFILE);
1628
1629       if(!sshc->sftp_handle) {
1630         rc = libssh2_session_last_errno(sshc->ssh_session);
1631
1632         if(LIBSSH2_ERROR_EAGAIN == rc)
1633           break;
1634         else {
1635           if(LIBSSH2_ERROR_SFTP_PROTOCOL == rc)
1636             /* only when there was an SFTP protocol error can we extract
1637                the sftp error! */
1638             err = sftp_libssh2_last_error(sshc->sftp_session);
1639           else
1640             err = -1; /* not an sftp error at all */
1641
1642           if(sshc->secondCreateDirs) {
1643             state(conn, SSH_SFTP_CLOSE);
1644             sshc->actualcode = err>= LIBSSH2_FX_OK?
1645               sftp_libssh2_error_to_CURLE(err):CURLE_SSH;
1646             failf(data, "Creating the dir/file failed: %s",
1647                   sftp_libssh2_strerror(err));
1648             break;
1649           }
1650           else if(((err == LIBSSH2_FX_NO_SUCH_FILE) ||
1651                    (err == LIBSSH2_FX_FAILURE) ||
1652                    (err == LIBSSH2_FX_NO_SUCH_PATH)) &&
1653                   (data->set.ftp_create_missing_dirs &&
1654                    (strlen(sftp_scp->path) > 1))) {
1655             /* try to create the path remotely */
1656             sshc->secondCreateDirs = 1;
1657             state(conn, SSH_SFTP_CREATE_DIRS_INIT);
1658             break;
1659           }
1660           state(conn, SSH_SFTP_CLOSE);
1661           sshc->actualcode = err>= LIBSSH2_FX_OK?
1662             sftp_libssh2_error_to_CURLE(err):CURLE_SSH;
1663           if(!sshc->actualcode) {
1664             /* Sometimes, for some reason libssh2_sftp_last_error() returns
1665                zero even though libssh2_sftp_open() failed previously! We need
1666                to work around that! */
1667             sshc->actualcode = CURLE_SSH;
1668             err=-1;
1669           }
1670           failf(data, "Upload failed: %s (%d/%d)",
1671                 err>= LIBSSH2_FX_OK?sftp_libssh2_strerror(err):"ssh error",
1672                 err, rc);
1673           break;
1674         }
1675       }
1676
1677       /* If we have restart point then we need to seek to the correct
1678          position. */
1679       if(data->state.resume_from > 0) {
1680         /* Let's read off the proper amount of bytes from the input. */
1681         if(conn->seek_func) {
1682           seekerr = conn->seek_func(conn->seek_client, data->state.resume_from,
1683                                     SEEK_SET);
1684         }
1685
1686         if(seekerr != CURL_SEEKFUNC_OK) {
1687
1688           if(seekerr != CURL_SEEKFUNC_CANTSEEK) {
1689             failf(data, "Could not seek stream");
1690             return CURLE_FTP_COULDNT_USE_REST;
1691           }
1692           /* seekerr == CURL_SEEKFUNC_CANTSEEK (can't seek to offset) */
1693           else {
1694             curl_off_t passed=0;
1695             do {
1696               size_t readthisamountnow =
1697                 (data->state.resume_from - passed > CURL_OFF_T_C(BUFSIZE)) ?
1698                 BUFSIZE : curlx_sotouz(data->state.resume_from - passed);
1699
1700               size_t actuallyread =
1701                 conn->fread_func(data->state.buffer, 1, readthisamountnow,
1702                                  conn->fread_in);
1703
1704               passed += actuallyread;
1705               if((actuallyread == 0) || (actuallyread > readthisamountnow)) {
1706                 /* this checks for greater-than only to make sure that the
1707                    CURL_READFUNC_ABORT return code still aborts */
1708                 failf(data, "Failed to read data");
1709                 return CURLE_FTP_COULDNT_USE_REST;
1710               }
1711             } while(passed < data->state.resume_from);
1712           }
1713         }
1714
1715         /* now, decrease the size of the read */
1716         if(data->set.infilesize > 0) {
1717           data->set.infilesize -= data->state.resume_from;
1718           data->req.size = data->set.infilesize;
1719           Curl_pgrsSetUploadSize(data, data->set.infilesize);
1720         }
1721
1722         SFTP_SEEK(sshc->sftp_handle, data->state.resume_from);
1723       }
1724       if(data->set.infilesize > 0) {
1725         data->req.size = data->set.infilesize;
1726         Curl_pgrsSetUploadSize(data, data->set.infilesize);
1727       }
1728       /* upload data */
1729       Curl_setup_transfer(conn, -1, -1, FALSE, NULL, FIRSTSOCKET, NULL);
1730
1731       /* not set by Curl_setup_transfer to preserve keepon bits */
1732       conn->sockfd = conn->writesockfd;
1733
1734       if(result) {
1735         state(conn, SSH_SFTP_CLOSE);
1736         sshc->actualcode = result;
1737       }
1738       else {
1739         /* store this original bitmask setup to use later on if we can't
1740            figure out a "real" bitmask */
1741         sshc->orig_waitfor = data->req.keepon;
1742
1743         /* we want to use the _sending_ function even when the socket turns
1744            out readable as the underlying libssh2 sftp send function will deal
1745            with both accordingly */
1746         conn->cselect_bits = CURL_CSELECT_OUT;
1747
1748         /* since we don't really wait for anything at this point, we want the
1749            state machine to move on as soon as possible so we set a very short
1750            timeout here */
1751         Curl_expire(data, 1);
1752
1753         state(conn, SSH_STOP);
1754       }
1755       break;
1756     }
1757
1758     case SSH_SFTP_CREATE_DIRS_INIT:
1759       if(strlen(sftp_scp->path) > 1) {
1760         sshc->slash_pos = sftp_scp->path + 1; /* ignore the leading '/' */
1761         state(conn, SSH_SFTP_CREATE_DIRS);
1762       }
1763       else {
1764         state(conn, SSH_SFTP_UPLOAD_INIT);
1765       }
1766       break;
1767
1768     case SSH_SFTP_CREATE_DIRS:
1769       if((sshc->slash_pos = strchr(sshc->slash_pos, '/')) != NULL) {
1770         *sshc->slash_pos = 0;
1771
1772         infof(data, "Creating directory '%s'\n", sftp_scp->path);
1773         state(conn, SSH_SFTP_CREATE_DIRS_MKDIR);
1774         break;
1775       }
1776       else {
1777         state(conn, SSH_SFTP_UPLOAD_INIT);
1778       }
1779       break;
1780
1781     case SSH_SFTP_CREATE_DIRS_MKDIR:
1782       /* 'mode' - parameter is preliminary - default to 0644 */
1783       rc = libssh2_sftp_mkdir_ex(sshc->sftp_session, sftp_scp->path,
1784                                  curlx_uztoui(strlen(sftp_scp->path)),
1785                                  data->set.new_directory_perms);
1786       if(rc == LIBSSH2_ERROR_EAGAIN) {
1787         break;
1788       }
1789       *sshc->slash_pos = '/';
1790       ++sshc->slash_pos;
1791       if(rc == -1) {
1792         /*
1793          * Abort if failure wasn't that the dir already exists or the
1794          * permission was denied (creation might succeed further down the
1795          * path) - retry on unspecific FAILURE also
1796          */
1797         err = sftp_libssh2_last_error(sshc->sftp_session);
1798         if((err != LIBSSH2_FX_FILE_ALREADY_EXISTS) &&
1799            (err != LIBSSH2_FX_FAILURE) &&
1800            (err != LIBSSH2_FX_PERMISSION_DENIED)) {
1801           result = sftp_libssh2_error_to_CURLE(err);
1802           state(conn, SSH_SFTP_CLOSE);
1803           sshc->actualcode = result?result:CURLE_SSH;
1804           break;
1805         }
1806       }
1807       state(conn, SSH_SFTP_CREATE_DIRS);
1808       break;
1809
1810     case SSH_SFTP_READDIR_INIT:
1811       /*
1812        * This is a directory that we are trying to get, so produce a directory
1813        * listing
1814        */
1815       sshc->sftp_handle = libssh2_sftp_open_ex(sshc->sftp_session,
1816                                                sftp_scp->path,
1817                                                curlx_uztoui(
1818                                                  strlen(sftp_scp->path)),
1819                                                0, 0, LIBSSH2_SFTP_OPENDIR);
1820       if(!sshc->sftp_handle) {
1821         if(libssh2_session_last_errno(sshc->ssh_session) ==
1822            LIBSSH2_ERROR_EAGAIN) {
1823           rc = LIBSSH2_ERROR_EAGAIN;
1824           break;
1825         }
1826         else {
1827           err = sftp_libssh2_last_error(sshc->sftp_session);
1828           failf(data, "Could not open directory for reading: %s",
1829                 sftp_libssh2_strerror(err));
1830           state(conn, SSH_SFTP_CLOSE);
1831           result = sftp_libssh2_error_to_CURLE(err);
1832           sshc->actualcode = result?result:CURLE_SSH;
1833           break;
1834         }
1835       }
1836       if((sshc->readdir_filename = malloc(PATH_MAX+1)) == NULL) {
1837         state(conn, SSH_SFTP_CLOSE);
1838         sshc->actualcode = CURLE_OUT_OF_MEMORY;
1839         break;
1840       }
1841       if((sshc->readdir_longentry = malloc(PATH_MAX+1)) == NULL) {
1842         Curl_safefree(sshc->readdir_filename);
1843         state(conn, SSH_SFTP_CLOSE);
1844         sshc->actualcode = CURLE_OUT_OF_MEMORY;
1845         break;
1846       }
1847       state(conn, SSH_SFTP_READDIR);
1848       break;
1849
1850     case SSH_SFTP_READDIR:
1851       sshc->readdir_len = libssh2_sftp_readdir_ex(sshc->sftp_handle,
1852                                                   sshc->readdir_filename,
1853                                                   PATH_MAX,
1854                                                   sshc->readdir_longentry,
1855                                                   PATH_MAX,
1856                                                   &sshc->readdir_attrs);
1857       if(sshc->readdir_len == LIBSSH2_ERROR_EAGAIN) {
1858         rc = LIBSSH2_ERROR_EAGAIN;
1859         break;
1860       }
1861       if(sshc->readdir_len > 0) {
1862         sshc->readdir_filename[sshc->readdir_len] = '\0';
1863
1864         if(data->set.ftp_list_only) {
1865           char *tmpLine;
1866
1867           tmpLine = aprintf("%s\n", sshc->readdir_filename);
1868           if(tmpLine == NULL) {
1869             state(conn, SSH_SFTP_CLOSE);
1870             sshc->actualcode = CURLE_OUT_OF_MEMORY;
1871             break;
1872           }
1873           result = Curl_client_write(conn, CLIENTWRITE_BODY,
1874                                      tmpLine, sshc->readdir_len+1);
1875           Curl_safefree(tmpLine);
1876
1877           if(result) {
1878             state(conn, SSH_STOP);
1879             break;
1880           }
1881           /* since this counts what we send to the client, we include the
1882              newline in this counter */
1883           data->req.bytecount += sshc->readdir_len+1;
1884
1885           /* output debug output if that is requested */
1886           if(data->set.verbose) {
1887             Curl_debug(data, CURLINFO_DATA_OUT, sshc->readdir_filename,
1888                        sshc->readdir_len, conn);
1889           }
1890         }
1891         else {
1892           sshc->readdir_currLen = (int)strlen(sshc->readdir_longentry);
1893           sshc->readdir_totalLen = 80 + sshc->readdir_currLen;
1894           sshc->readdir_line = calloc(sshc->readdir_totalLen, 1);
1895           if(!sshc->readdir_line) {
1896             Curl_safefree(sshc->readdir_filename);
1897             Curl_safefree(sshc->readdir_longentry);
1898             state(conn, SSH_SFTP_CLOSE);
1899             sshc->actualcode = CURLE_OUT_OF_MEMORY;
1900             break;
1901           }
1902
1903           memcpy(sshc->readdir_line, sshc->readdir_longentry,
1904                  sshc->readdir_currLen);
1905           if((sshc->readdir_attrs.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) &&
1906              ((sshc->readdir_attrs.permissions & LIBSSH2_SFTP_S_IFMT) ==
1907               LIBSSH2_SFTP_S_IFLNK)) {
1908             sshc->readdir_linkPath = malloc(PATH_MAX + 1);
1909             if(sshc->readdir_linkPath == NULL) {
1910               Curl_safefree(sshc->readdir_filename);
1911               Curl_safefree(sshc->readdir_longentry);
1912               state(conn, SSH_SFTP_CLOSE);
1913               sshc->actualcode = CURLE_OUT_OF_MEMORY;
1914               break;
1915             }
1916
1917             snprintf(sshc->readdir_linkPath, PATH_MAX, "%s%s", sftp_scp->path,
1918                      sshc->readdir_filename);
1919             state(conn, SSH_SFTP_READDIR_LINK);
1920             break;
1921           }
1922           state(conn, SSH_SFTP_READDIR_BOTTOM);
1923           break;
1924         }
1925       }
1926       else if(sshc->readdir_len == 0) {
1927         Curl_safefree(sshc->readdir_filename);
1928         Curl_safefree(sshc->readdir_longentry);
1929         state(conn, SSH_SFTP_READDIR_DONE);
1930         break;
1931       }
1932       else if(sshc->readdir_len <= 0) {
1933         err = sftp_libssh2_last_error(sshc->sftp_session);
1934         result = sftp_libssh2_error_to_CURLE(err);
1935         sshc->actualcode = result?result:CURLE_SSH;
1936         failf(data, "Could not open remote file for reading: %s :: %d",
1937               sftp_libssh2_strerror(err),
1938               libssh2_session_last_errno(sshc->ssh_session));
1939         Curl_safefree(sshc->readdir_filename);
1940         Curl_safefree(sshc->readdir_longentry);
1941         state(conn, SSH_SFTP_CLOSE);
1942         break;
1943       }
1944       break;
1945
1946     case SSH_SFTP_READDIR_LINK:
1947       sshc->readdir_len =
1948         libssh2_sftp_symlink_ex(sshc->sftp_session,
1949                                 sshc->readdir_linkPath,
1950                                 curlx_uztoui(strlen(sshc->readdir_linkPath)),
1951                                 sshc->readdir_filename,
1952                                 PATH_MAX, LIBSSH2_SFTP_READLINK);
1953       if(sshc->readdir_len == LIBSSH2_ERROR_EAGAIN) {
1954         rc = LIBSSH2_ERROR_EAGAIN;
1955         break;
1956       }
1957       Curl_safefree(sshc->readdir_linkPath);
1958
1959       /* get room for the filename and extra output */
1960       sshc->readdir_totalLen += 4 + sshc->readdir_len;
1961       new_readdir_line = realloc(sshc->readdir_line, sshc->readdir_totalLen);
1962       if(!new_readdir_line) {
1963         Curl_safefree(sshc->readdir_line);
1964         Curl_safefree(sshc->readdir_filename);
1965         Curl_safefree(sshc->readdir_longentry);
1966         state(conn, SSH_SFTP_CLOSE);
1967         sshc->actualcode = CURLE_OUT_OF_MEMORY;
1968         break;
1969       }
1970       sshc->readdir_line = new_readdir_line;
1971
1972       sshc->readdir_currLen += snprintf(sshc->readdir_line +
1973                                         sshc->readdir_currLen,
1974                                         sshc->readdir_totalLen -
1975                                         sshc->readdir_currLen,
1976                                         " -> %s",
1977                                         sshc->readdir_filename);
1978
1979       state(conn, SSH_SFTP_READDIR_BOTTOM);
1980       break;
1981
1982     case SSH_SFTP_READDIR_BOTTOM:
1983       sshc->readdir_currLen += snprintf(sshc->readdir_line +
1984                                         sshc->readdir_currLen,
1985                                         sshc->readdir_totalLen -
1986                                         sshc->readdir_currLen, "\n");
1987       result = Curl_client_write(conn, CLIENTWRITE_BODY,
1988                                  sshc->readdir_line,
1989                                  sshc->readdir_currLen);
1990
1991       if(result == CURLE_OK) {
1992
1993         /* output debug output if that is requested */
1994         if(data->set.verbose) {
1995           Curl_debug(data, CURLINFO_DATA_OUT, sshc->readdir_line,
1996                      sshc->readdir_currLen, conn);
1997         }
1998         data->req.bytecount += sshc->readdir_currLen;
1999       }
2000       Curl_safefree(sshc->readdir_line);
2001       if(result) {
2002         state(conn, SSH_STOP);
2003       }
2004       else
2005         state(conn, SSH_SFTP_READDIR);
2006       break;
2007
2008     case SSH_SFTP_READDIR_DONE:
2009       if(libssh2_sftp_closedir(sshc->sftp_handle) ==
2010          LIBSSH2_ERROR_EAGAIN) {
2011         rc = LIBSSH2_ERROR_EAGAIN;
2012         break;
2013       }
2014       sshc->sftp_handle = NULL;
2015       Curl_safefree(sshc->readdir_filename);
2016       Curl_safefree(sshc->readdir_longentry);
2017
2018       /* no data to transfer */
2019       Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
2020       state(conn, SSH_STOP);
2021       break;
2022
2023     case SSH_SFTP_DOWNLOAD_INIT:
2024       /*
2025        * Work on getting the specified file
2026        */
2027       sshc->sftp_handle =
2028         libssh2_sftp_open_ex(sshc->sftp_session, sftp_scp->path,
2029                              curlx_uztoui(strlen(sftp_scp->path)),
2030                              LIBSSH2_FXF_READ, data->set.new_file_perms,
2031                              LIBSSH2_SFTP_OPENFILE);
2032       if(!sshc->sftp_handle) {
2033         if(libssh2_session_last_errno(sshc->ssh_session) ==
2034            LIBSSH2_ERROR_EAGAIN) {
2035           rc = LIBSSH2_ERROR_EAGAIN;
2036           break;
2037         }
2038         else {
2039           err = sftp_libssh2_last_error(sshc->sftp_session);
2040           failf(data, "Could not open remote file for reading: %s",
2041                 sftp_libssh2_strerror(err));
2042           state(conn, SSH_SFTP_CLOSE);
2043           result = sftp_libssh2_error_to_CURLE(err);
2044           sshc->actualcode = result?result:CURLE_SSH;
2045           break;
2046         }
2047       }
2048       state(conn, SSH_SFTP_DOWNLOAD_STAT);
2049       break;
2050
2051     case SSH_SFTP_DOWNLOAD_STAT:
2052     {
2053       LIBSSH2_SFTP_ATTRIBUTES attrs;
2054
2055       rc = libssh2_sftp_stat_ex(sshc->sftp_session, sftp_scp->path,
2056                                 curlx_uztoui(strlen(sftp_scp->path)),
2057                                 LIBSSH2_SFTP_STAT, &attrs);
2058       if(rc == LIBSSH2_ERROR_EAGAIN) {
2059         break;
2060       }
2061       else if(rc) {
2062         /*
2063          * libssh2_sftp_open() didn't return an error, so maybe the server
2064          * just doesn't support stat()
2065          */
2066         data->req.size = -1;
2067         data->req.maxdownload = -1;
2068       }
2069       else {
2070         curl_off_t size = attrs.filesize;
2071
2072         if(size < 0) {
2073           failf(data, "Bad file size (%" FORMAT_OFF_T ")", size);
2074           return CURLE_BAD_DOWNLOAD_RESUME;
2075         }
2076         if(conn->data->state.use_range) {
2077           curl_off_t from, to;
2078           char *ptr;
2079           char *ptr2;
2080
2081           from=curlx_strtoofft(conn->data->state.range, &ptr, 0);
2082           while(*ptr && (ISSPACE(*ptr) || (*ptr=='-')))
2083             ptr++;
2084           to=curlx_strtoofft(ptr, &ptr2, 0);
2085           if((ptr == ptr2) /* no "to" value given */
2086              || (to >= size)) {
2087             to = size - 1;
2088           }
2089           if(from < 0) {
2090             /* from is relative to end of file */
2091             from += size;
2092           }
2093           if(from >= size) {
2094             failf(data, "Offset (%"
2095                   FORMAT_OFF_T ") was beyond file size (%" FORMAT_OFF_T ")",
2096                   from, attrs.filesize);
2097             return CURLE_BAD_DOWNLOAD_RESUME;
2098           }
2099           if(from > to) {
2100             from = to;
2101             size = 0;
2102           }
2103           else {
2104             size = to - from + 1;
2105           }
2106
2107           SFTP_SEEK(conn->proto.sshc.sftp_handle, from);
2108         }
2109         data->req.size = size;
2110         data->req.maxdownload = size;
2111         Curl_pgrsSetDownloadSize(data, size);
2112       }
2113
2114       /* We can resume if we can seek to the resume position */
2115       if(data->state.resume_from) {
2116         if(data->state.resume_from < 0) {
2117           /* We're supposed to download the last abs(from) bytes */
2118           if((curl_off_t)attrs.filesize < -data->state.resume_from) {
2119             failf(data, "Offset (%"
2120                   FORMAT_OFF_T ") was beyond file size (%" FORMAT_OFF_T ")",
2121                   data->state.resume_from, attrs.filesize);
2122             return CURLE_BAD_DOWNLOAD_RESUME;
2123           }
2124           /* download from where? */
2125           data->state.resume_from += attrs.filesize;
2126         }
2127         else {
2128           if((curl_off_t)attrs.filesize < data->state.resume_from) {
2129             failf(data, "Offset (%" FORMAT_OFF_T
2130                   ") was beyond file size (%" FORMAT_OFF_T ")",
2131                   data->state.resume_from, attrs.filesize);
2132             return CURLE_BAD_DOWNLOAD_RESUME;
2133           }
2134         }
2135         /* Does a completed file need to be seeked and started or closed ? */
2136         /* Now store the number of bytes we are expected to download */
2137         data->req.size = attrs.filesize - data->state.resume_from;
2138         data->req.maxdownload = attrs.filesize - data->state.resume_from;
2139         Curl_pgrsSetDownloadSize(data,
2140                                  attrs.filesize - data->state.resume_from);
2141         SFTP_SEEK(sshc->sftp_handle, data->state.resume_from);
2142       }
2143     }
2144     /* Setup the actual download */
2145     if(data->req.size == 0) {
2146       /* no data to transfer */
2147       Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
2148       infof(data, "File already completely downloaded\n");
2149       state(conn, SSH_STOP);
2150       break;
2151     }
2152     else {
2153       Curl_setup_transfer(conn, FIRSTSOCKET, data->req.size,
2154                           FALSE, NULL, -1, NULL);
2155
2156       /* not set by Curl_setup_transfer to preserve keepon bits */
2157       conn->writesockfd = conn->sockfd;
2158
2159       /* we want to use the _receiving_ function even when the socket turns
2160          out writableable as the underlying libssh2 recv function will deal
2161          with both accordingly */
2162       conn->cselect_bits = CURL_CSELECT_IN;
2163     }
2164     if(result) {
2165       state(conn, SSH_SFTP_CLOSE);
2166       sshc->actualcode = result;
2167     }
2168     else {
2169       state(conn, SSH_STOP);
2170     }
2171     break;
2172
2173     case SSH_SFTP_CLOSE:
2174       if(sshc->sftp_handle) {
2175         rc = libssh2_sftp_close(sshc->sftp_handle);
2176         if(rc == LIBSSH2_ERROR_EAGAIN) {
2177           break;
2178         }
2179         else if(rc < 0) {
2180           infof(data, "Failed to close libssh2 file\n");
2181         }
2182         sshc->sftp_handle = NULL;
2183       }
2184       if(sftp_scp)
2185         Curl_safefree(sftp_scp->path);
2186
2187       DEBUGF(infof(data, "SFTP DONE done\n"));
2188
2189       /* Check if nextstate is set and move .nextstate could be POSTQUOTE_INIT
2190          After nextstate is executed,the control should come back to
2191          SSH_SFTP_CLOSE to pass the correct result back  */
2192       if(sshc->nextstate != SSH_NO_STATE) {
2193         state(conn, sshc->nextstate);
2194         sshc->nextstate = SSH_SFTP_CLOSE;
2195       }
2196       else {
2197         state(conn, SSH_STOP);
2198         result = sshc->actualcode;
2199       }
2200       break;
2201
2202     case SSH_SFTP_SHUTDOWN:
2203       /* during times we get here due to a broken transfer and then the
2204          sftp_handle might not have been taken down so make sure that is done
2205          before we proceed */
2206
2207       if(sshc->sftp_handle) {
2208         rc = libssh2_sftp_close(sshc->sftp_handle);
2209         if(rc == LIBSSH2_ERROR_EAGAIN) {
2210           break;
2211         }
2212         else if(rc < 0) {
2213           infof(data, "Failed to close libssh2 file\n");
2214         }
2215         sshc->sftp_handle = NULL;
2216       }
2217       if(sshc->sftp_session) {
2218         rc = libssh2_sftp_shutdown(sshc->sftp_session);
2219         if(rc == LIBSSH2_ERROR_EAGAIN) {
2220           break;
2221         }
2222         else if(rc < 0) {
2223           infof(data, "Failed to stop libssh2 sftp subsystem\n");
2224         }
2225         sshc->sftp_session = NULL;
2226       }
2227
2228       Curl_safefree(sshc->homedir);
2229       conn->data->state.most_recent_ftp_entrypath = NULL;
2230
2231       state(conn, SSH_SESSION_DISCONNECT);
2232       break;
2233
2234     case SSH_SCP_TRANS_INIT:
2235       result = ssh_getworkingpath(conn, sshc->homedir, &sftp_scp->path);
2236       if(result) {
2237         sshc->actualcode = result;
2238         state(conn, SSH_STOP);
2239         break;
2240       }
2241
2242       if(data->set.upload) {
2243         if(data->set.infilesize < 0) {
2244           failf(data, "SCP requires a known file size for upload");
2245           sshc->actualcode = CURLE_UPLOAD_FAILED;
2246           state(conn, SSH_SCP_CHANNEL_FREE);
2247           break;
2248         }
2249         state(conn, SSH_SCP_UPLOAD_INIT);
2250       }
2251       else {
2252         state(conn, SSH_SCP_DOWNLOAD_INIT);
2253       }
2254       break;
2255
2256     case SSH_SCP_UPLOAD_INIT:
2257       /*
2258        * libssh2 requires that the destination path is a full path that
2259        * includes the destination file and name OR ends in a "/" .  If this is
2260        * not done the destination file will be named the same name as the last
2261        * directory in the path.
2262        */
2263       sshc->ssh_channel =
2264         SCP_SEND(sshc->ssh_session, sftp_scp->path, data->set.new_file_perms,
2265                  data->set.infilesize);
2266       if(!sshc->ssh_channel) {
2267         if(libssh2_session_last_errno(sshc->ssh_session) ==
2268            LIBSSH2_ERROR_EAGAIN) {
2269           rc = LIBSSH2_ERROR_EAGAIN;
2270           break;
2271         }
2272         else {
2273           int ssh_err;
2274           char *err_msg;
2275
2276           ssh_err = (int)(libssh2_session_last_error(sshc->ssh_session,
2277                                                      &err_msg, NULL, 0));
2278           failf(conn->data, "%s", err_msg);
2279           state(conn, SSH_SCP_CHANNEL_FREE);
2280           sshc->actualcode = libssh2_session_error_to_CURLE(ssh_err);
2281           break;
2282         }
2283       }
2284
2285       /* upload data */
2286       Curl_setup_transfer(conn, -1, data->req.size, FALSE, NULL,
2287                           FIRSTSOCKET, NULL);
2288
2289       /* not set by Curl_setup_transfer to preserve keepon bits */
2290       conn->sockfd = conn->writesockfd;
2291
2292       if(result) {
2293         state(conn, SSH_SCP_CHANNEL_FREE);
2294         sshc->actualcode = result;
2295       }
2296       else {
2297         /* store this original bitmask setup to use later on if we can't
2298            figure out a "real" bitmask */
2299         sshc->orig_waitfor = data->req.keepon;
2300
2301         /* we want to use the _sending_ function even when the socket turns
2302            out readable as the underlying libssh2 scp send function will deal
2303            with both accordingly */
2304         conn->cselect_bits = CURL_CSELECT_OUT;
2305
2306         state(conn, SSH_STOP);
2307       }
2308       break;
2309
2310     case SSH_SCP_DOWNLOAD_INIT:
2311     {
2312       /*
2313        * We must check the remote file; if it is a directory no values will
2314        * be set in sb
2315        */
2316       struct stat sb;
2317       curl_off_t bytecount;
2318
2319       /* clear the struct scp recv will fill in */
2320       memset(&sb, 0, sizeof(struct stat));
2321
2322       /* get a fresh new channel from the ssh layer */
2323       sshc->ssh_channel = libssh2_scp_recv(sshc->ssh_session,
2324                                            sftp_scp->path, &sb);
2325       if(!sshc->ssh_channel) {
2326         if(libssh2_session_last_errno(sshc->ssh_session) ==
2327            LIBSSH2_ERROR_EAGAIN) {
2328           rc = LIBSSH2_ERROR_EAGAIN;
2329           break;
2330         }
2331         else {
2332           int ssh_err;
2333           char *err_msg;
2334
2335           ssh_err = (int)(libssh2_session_last_error(sshc->ssh_session,
2336                                                      &err_msg, NULL, 0));
2337           failf(conn->data, "%s", err_msg);
2338           state(conn, SSH_SCP_CHANNEL_FREE);
2339           sshc->actualcode = libssh2_session_error_to_CURLE(ssh_err);
2340           break;
2341         }
2342       }
2343
2344       /* download data */
2345       bytecount = (curl_off_t)sb.st_size;
2346       data->req.maxdownload =  (curl_off_t)sb.st_size;
2347       Curl_setup_transfer(conn, FIRSTSOCKET, bytecount, FALSE, NULL, -1, NULL);
2348
2349       /* not set by Curl_setup_transfer to preserve keepon bits */
2350       conn->writesockfd = conn->sockfd;
2351
2352       /* we want to use the _receiving_ function even when the socket turns
2353          out writableable as the underlying libssh2 recv function will deal
2354          with both accordingly */
2355       conn->cselect_bits = CURL_CSELECT_IN;
2356
2357       if(result) {
2358         state(conn, SSH_SCP_CHANNEL_FREE);
2359         sshc->actualcode = result;
2360       }
2361       else
2362         state(conn, SSH_STOP);
2363     }
2364     break;
2365
2366     case SSH_SCP_DONE:
2367       if(data->set.upload)
2368         state(conn, SSH_SCP_SEND_EOF);
2369       else
2370         state(conn, SSH_SCP_CHANNEL_FREE);
2371       break;
2372
2373     case SSH_SCP_SEND_EOF:
2374       if(sshc->ssh_channel) {
2375         rc = libssh2_channel_send_eof(sshc->ssh_channel);
2376         if(rc == LIBSSH2_ERROR_EAGAIN) {
2377           break;
2378         }
2379         else if(rc) {
2380           infof(data, "Failed to send libssh2 channel EOF\n");
2381         }
2382       }
2383       state(conn, SSH_SCP_WAIT_EOF);
2384       break;
2385
2386     case SSH_SCP_WAIT_EOF:
2387       if(sshc->ssh_channel) {
2388         rc = libssh2_channel_wait_eof(sshc->ssh_channel);
2389         if(rc == LIBSSH2_ERROR_EAGAIN) {
2390           break;
2391         }
2392         else if(rc) {
2393           infof(data, "Failed to get channel EOF: %d\n", rc);
2394         }
2395       }
2396       state(conn, SSH_SCP_WAIT_CLOSE);
2397       break;
2398
2399     case SSH_SCP_WAIT_CLOSE:
2400       if(sshc->ssh_channel) {
2401         rc = libssh2_channel_wait_closed(sshc->ssh_channel);
2402         if(rc == LIBSSH2_ERROR_EAGAIN) {
2403           break;
2404         }
2405         else if(rc) {
2406           infof(data, "Channel failed to close: %d\n", rc);
2407         }
2408       }
2409       state(conn, SSH_SCP_CHANNEL_FREE);
2410       break;
2411
2412     case SSH_SCP_CHANNEL_FREE:
2413       if(sshc->ssh_channel) {
2414         rc = libssh2_channel_free(sshc->ssh_channel);
2415         if(rc == LIBSSH2_ERROR_EAGAIN) {
2416           break;
2417         }
2418         else if(rc < 0) {
2419           infof(data, "Failed to free libssh2 scp subsystem\n");
2420         }
2421         sshc->ssh_channel = NULL;
2422       }
2423       DEBUGF(infof(data, "SCP DONE phase complete\n"));
2424 #if 0 /* PREV */
2425       state(conn, SSH_SESSION_DISCONNECT);
2426 #endif
2427       state(conn, SSH_STOP);
2428       result = sshc->actualcode;
2429       break;
2430
2431     case SSH_SESSION_DISCONNECT:
2432       /* during weird times when we've been prematurely aborted, the channel
2433          is still alive when we reach this state and we MUST kill the channel
2434          properly first */
2435       if(sshc->ssh_channel) {
2436         rc = libssh2_channel_free(sshc->ssh_channel);
2437         if(rc == LIBSSH2_ERROR_EAGAIN) {
2438           break;
2439         }
2440         else if(rc < 0) {
2441           infof(data, "Failed to free libssh2 scp subsystem\n");
2442         }
2443         sshc->ssh_channel = NULL;
2444       }
2445
2446       if(sshc->ssh_session) {
2447         rc = libssh2_session_disconnect(sshc->ssh_session, "Shutdown");
2448         if(rc == LIBSSH2_ERROR_EAGAIN) {
2449           break;
2450         }
2451         else if(rc < 0) {
2452           infof(data, "Failed to disconnect libssh2 session\n");
2453         }
2454       }
2455
2456       Curl_safefree(sshc->homedir);
2457       conn->data->state.most_recent_ftp_entrypath = NULL;
2458
2459       state(conn, SSH_SESSION_FREE);
2460       break;
2461
2462     case SSH_SESSION_FREE:
2463 #ifdef HAVE_LIBSSH2_KNOWNHOST_API
2464       if(sshc->kh) {
2465         libssh2_knownhost_free(sshc->kh);
2466         sshc->kh = NULL;
2467       }
2468 #endif
2469
2470 #ifdef HAVE_LIBSSH2_AGENT_API
2471       if(sshc->ssh_agent) {
2472         rc = libssh2_agent_disconnect(sshc->ssh_agent);
2473         if(rc == LIBSSH2_ERROR_EAGAIN) {
2474           break;
2475         }
2476         else if(rc < 0) {
2477           infof(data, "Failed to disconnect from libssh2 agent\n");
2478         }
2479         libssh2_agent_free (sshc->ssh_agent);
2480         sshc->ssh_agent = NULL;
2481
2482         /* NB: there is no need to free identities, they are part of internal
2483            agent stuff */
2484         sshc->sshagent_identity = NULL;
2485         sshc->sshagent_prev_identity = NULL;
2486       }
2487 #endif
2488
2489       if(sshc->ssh_session) {
2490         rc = libssh2_session_free(sshc->ssh_session);
2491         if(rc == LIBSSH2_ERROR_EAGAIN) {
2492           break;
2493         }
2494         else if(rc < 0) {
2495           infof(data, "Failed to free libssh2 session\n");
2496         }
2497         sshc->ssh_session = NULL;
2498       }
2499
2500       /* worst-case scenario cleanup */
2501
2502       DEBUGASSERT(sshc->ssh_session == NULL);
2503       DEBUGASSERT(sshc->ssh_channel == NULL);
2504       DEBUGASSERT(sshc->sftp_session == NULL);
2505       DEBUGASSERT(sshc->sftp_handle == NULL);
2506 #ifdef HAVE_LIBSSH2_KNOWNHOST_API
2507       DEBUGASSERT(sshc->kh == NULL);
2508 #endif
2509 #ifdef HAVE_LIBSSH2_AGENT_API
2510       DEBUGASSERT(sshc->ssh_agent == NULL);
2511 #endif
2512
2513       Curl_safefree(sshc->rsa_pub);
2514       Curl_safefree(sshc->rsa);
2515
2516       Curl_safefree(sshc->quote_path1);
2517       Curl_safefree(sshc->quote_path2);
2518
2519       Curl_safefree(sshc->homedir);
2520
2521       Curl_safefree(sshc->readdir_filename);
2522       Curl_safefree(sshc->readdir_longentry);
2523       Curl_safefree(sshc->readdir_line);
2524       Curl_safefree(sshc->readdir_linkPath);
2525
2526       /* the code we are about to return */
2527       result = sshc->actualcode;
2528
2529       memset(sshc, 0, sizeof(struct ssh_conn));
2530
2531       conn->bits.close = TRUE;
2532       sshc->state = SSH_SESSION_FREE; /* current */
2533       sshc->nextstate = SSH_NO_STATE;
2534       state(conn, SSH_STOP);
2535       break;
2536
2537     case SSH_QUIT:
2538       /* fallthrough, just stop! */
2539     default:
2540       /* internal error */
2541       sshc->nextstate = SSH_NO_STATE;
2542       state(conn, SSH_STOP);
2543       break;
2544     }
2545
2546   } while(!rc && (sshc->state != SSH_STOP));
2547
2548   if(rc == LIBSSH2_ERROR_EAGAIN) {
2549     /* we would block, we need to wait for the socket to be ready (in the
2550        right direction too)! */
2551     *block = TRUE;
2552   }
2553
2554   return result;
2555 }
2556
2557 /* called by the multi interface to figure out what socket(s) to wait for and
2558    for what actions in the DO_DONE, PERFORM and WAITPERFORM states */
2559 static int ssh_perform_getsock(const struct connectdata *conn,
2560                                curl_socket_t *sock, /* points to numsocks
2561                                                        number of sockets */
2562                                int numsocks)
2563 {
2564 #ifdef HAVE_LIBSSH2_SESSION_BLOCK_DIRECTION
2565   int bitmap = GETSOCK_BLANK;
2566   (void)numsocks;
2567
2568   sock[0] = conn->sock[FIRSTSOCKET];
2569
2570   if(conn->waitfor & KEEP_RECV)
2571     bitmap |= GETSOCK_READSOCK(FIRSTSOCKET);
2572
2573   if(conn->waitfor & KEEP_SEND)
2574     bitmap |= GETSOCK_WRITESOCK(FIRSTSOCKET);
2575
2576   return bitmap;
2577 #else
2578   /* if we don't know the direction we can use the generic *_getsock()
2579      function even for the protocol_connect and doing states */
2580   return Curl_single_getsock(conn, sock, numsocks);
2581 #endif
2582 }
2583
2584 /* Generic function called by the multi interface to figure out what socket(s)
2585    to wait for and for what actions during the DOING and PROTOCONNECT states*/
2586 static int ssh_getsock(struct connectdata *conn,
2587                        curl_socket_t *sock, /* points to numsocks number
2588                                                of sockets */
2589                        int numsocks)
2590 {
2591 #ifndef HAVE_LIBSSH2_SESSION_BLOCK_DIRECTION
2592   (void)conn;
2593   (void)sock;
2594   (void)numsocks;
2595   /* if we don't know any direction we can just play along as we used to and
2596      not provide any sensible info */
2597   return GETSOCK_BLANK;
2598 #else
2599   /* if we know the direction we can use the generic *_getsock() function even
2600      for the protocol_connect and doing states */
2601   return ssh_perform_getsock(conn, sock, numsocks);
2602 #endif
2603 }
2604
2605 #ifdef HAVE_LIBSSH2_SESSION_BLOCK_DIRECTION
2606 /*
2607  * When one of the libssh2 functions has returned LIBSSH2_ERROR_EAGAIN this
2608  * function is used to figure out in what direction and stores this info so
2609  * that the multi interface can take advantage of it. Make sure to call this
2610  * function in all cases so that when it _doesn't_ return EAGAIN we can
2611  * restore the default wait bits.
2612  */
2613 static void ssh_block2waitfor(struct connectdata *conn, bool block)
2614 {
2615   struct ssh_conn *sshc = &conn->proto.sshc;
2616   int dir;
2617   if(block && (dir = libssh2_session_block_directions(sshc->ssh_session))) {
2618     /* translate the libssh2 define bits into our own bit defines */
2619     conn->waitfor = ((dir&LIBSSH2_SESSION_BLOCK_INBOUND)?KEEP_RECV:0) |
2620       ((dir&LIBSSH2_SESSION_BLOCK_OUTBOUND)?KEEP_SEND:0);
2621   }
2622   else
2623     /* It didn't block or libssh2 didn't reveal in which direction, put back
2624        the original set */
2625     conn->waitfor = sshc->orig_waitfor;
2626 }
2627 #else
2628   /* no libssh2 directional support so we simply don't know */
2629 #define ssh_block2waitfor(x,y) Curl_nop_stmt
2630 #endif
2631
2632 /* called repeatedly until done from multi.c */
2633 static CURLcode ssh_multi_statemach(struct connectdata *conn, bool *done)
2634 {
2635   struct ssh_conn *sshc = &conn->proto.sshc;
2636   CURLcode result = CURLE_OK;
2637   bool block; /* we store the status and use that to provide a ssh_getsock()
2638                  implementation */
2639
2640   result = ssh_statemach_act(conn, &block);
2641   *done = (sshc->state == SSH_STOP) ? TRUE : FALSE;
2642   ssh_block2waitfor(conn, block);
2643
2644   return result;
2645 }
2646
2647 static CURLcode ssh_block_statemach(struct connectdata *conn,
2648                                    bool duringconnect)
2649 {
2650   struct ssh_conn *sshc = &conn->proto.sshc;
2651   CURLcode result = CURLE_OK;
2652   struct SessionHandle *data = conn->data;
2653
2654   while((sshc->state != SSH_STOP) && !result) {
2655     bool block;
2656     long left;
2657
2658     result = ssh_statemach_act(conn, &block);
2659     if(result)
2660       break;
2661
2662     if(Curl_pgrsUpdate(conn))
2663       return CURLE_ABORTED_BY_CALLBACK;
2664     else {
2665       struct timeval now = Curl_tvnow();
2666       result = Curl_speedcheck(data, now);
2667       if(result)
2668         break;
2669     }
2670
2671     left = Curl_timeleft(data, NULL, duringconnect);
2672     if(left < 0) {
2673       failf(data, "Operation timed out");
2674       return CURLE_OPERATION_TIMEDOUT;
2675     }
2676
2677 #ifdef HAVE_LIBSSH2_SESSION_BLOCK_DIRECTION
2678     if((CURLE_OK == result) && block) {
2679       int dir = libssh2_session_block_directions(sshc->ssh_session);
2680       curl_socket_t sock = conn->sock[FIRSTSOCKET];
2681       curl_socket_t fd_read = CURL_SOCKET_BAD;
2682       curl_socket_t fd_write = CURL_SOCKET_BAD;
2683       if(LIBSSH2_SESSION_BLOCK_INBOUND & dir)
2684         fd_read = sock;
2685       if(LIBSSH2_SESSION_BLOCK_OUTBOUND & dir)
2686         fd_write = sock;
2687       /* wait for the socket to become ready */
2688       Curl_socket_ready(fd_read, fd_write,
2689                         left>1000?1000:left); /* ignore result */
2690     }
2691 #endif
2692
2693   }
2694
2695   return result;
2696 }
2697
2698 /*
2699  * SSH setup and connection
2700  */
2701 static CURLcode ssh_setup_connection(struct connectdata *conn)
2702 {
2703   struct SSHPROTO *ssh;
2704
2705   conn->data->req.protop = ssh = calloc(1, sizeof(struct SSHPROTO));
2706   if(!ssh)
2707     return CURLE_OUT_OF_MEMORY;
2708
2709   return CURLE_OK;
2710 }
2711
2712 static Curl_recv scp_recv, sftp_recv;
2713 static Curl_send scp_send, sftp_send;
2714
2715 /*
2716  * Curl_ssh_connect() gets called from Curl_protocol_connect() to allow us to
2717  * do protocol-specific actions at connect-time.
2718  */
2719 static CURLcode ssh_connect(struct connectdata *conn, bool *done)
2720 {
2721 #ifdef CURL_LIBSSH2_DEBUG
2722   curl_socket_t sock;
2723 #endif
2724   struct ssh_conn *ssh;
2725   CURLcode result;
2726   struct SessionHandle *data = conn->data;
2727
2728   /* We default to persistent connections. We set this already in this connect
2729      function to make the re-use checks properly be able to check this bit. */
2730   conn->bits.close = FALSE;
2731
2732   if(conn->handler->protocol & CURLPROTO_SCP) {
2733     conn->recv[FIRSTSOCKET] = scp_recv;
2734     conn->send[FIRSTSOCKET] = scp_send;
2735   }
2736   else {
2737     conn->recv[FIRSTSOCKET] = sftp_recv;
2738     conn->send[FIRSTSOCKET] = sftp_send;
2739   }
2740   ssh = &conn->proto.sshc;
2741
2742 #ifdef CURL_LIBSSH2_DEBUG
2743   if(conn->user) {
2744     infof(data, "User: %s\n", conn->user);
2745   }
2746   if(conn->passwd) {
2747     infof(data, "Password: %s\n", conn->passwd);
2748   }
2749   sock = conn->sock[FIRSTSOCKET];
2750 #endif /* CURL_LIBSSH2_DEBUG */
2751
2752   ssh->ssh_session = libssh2_session_init_ex(my_libssh2_malloc,
2753                                              my_libssh2_free,
2754                                              my_libssh2_realloc, conn);
2755   if(ssh->ssh_session == NULL) {
2756     failf(data, "Failure initialising ssh session");
2757     return CURLE_FAILED_INIT;
2758   }
2759
2760 #ifdef HAVE_LIBSSH2_KNOWNHOST_API
2761   if(data->set.str[STRING_SSH_KNOWNHOSTS]) {
2762     int rc;
2763     ssh->kh = libssh2_knownhost_init(ssh->ssh_session);
2764     if(!ssh->kh) {
2765       /* eeek. TODO: free the ssh_session! */
2766       return CURLE_FAILED_INIT;
2767     }
2768
2769     /* read all known hosts from there */
2770     rc = libssh2_knownhost_readfile(ssh->kh,
2771                                     data->set.str[STRING_SSH_KNOWNHOSTS],
2772                                     LIBSSH2_KNOWNHOST_FILE_OPENSSH);
2773     if(rc < 0)
2774       infof(data, "Failed to read known hosts from %s\n",
2775             data->set.str[STRING_SSH_KNOWNHOSTS]);
2776   }
2777 #endif /* HAVE_LIBSSH2_KNOWNHOST_API */
2778
2779 #ifdef CURL_LIBSSH2_DEBUG
2780   libssh2_trace(ssh->ssh_session, ~0);
2781   infof(data, "SSH socket: %d\n", (int)sock);
2782 #endif /* CURL_LIBSSH2_DEBUG */
2783
2784   state(conn, SSH_INIT);
2785
2786   result = ssh_multi_statemach(conn, done);
2787
2788   return result;
2789 }
2790
2791 /*
2792  ***********************************************************************
2793  *
2794  * scp_perform()
2795  *
2796  * This is the actual DO function for SCP. Get a file according to
2797  * the options previously setup.
2798  */
2799
2800 static
2801 CURLcode scp_perform(struct connectdata *conn,
2802                       bool *connected,
2803                       bool *dophase_done)
2804 {
2805   CURLcode result = CURLE_OK;
2806
2807   DEBUGF(infof(conn->data, "DO phase starts\n"));
2808
2809   *dophase_done = FALSE; /* not done yet */
2810
2811   /* start the first command in the DO phase */
2812   state(conn, SSH_SCP_TRANS_INIT);
2813
2814   /* run the state-machine */
2815   result = ssh_multi_statemach(conn, dophase_done);
2816
2817   *connected = conn->bits.tcpconnect[FIRSTSOCKET];
2818
2819   if(*dophase_done) {
2820     DEBUGF(infof(conn->data, "DO phase is complete\n"));
2821   }
2822
2823   return result;
2824 }
2825
2826 /* called from multi.c while DOing */
2827 static CURLcode scp_doing(struct connectdata *conn,
2828                                bool *dophase_done)
2829 {
2830   CURLcode result;
2831   result = ssh_multi_statemach(conn, dophase_done);
2832
2833   if(*dophase_done) {
2834     DEBUGF(infof(conn->data, "DO phase is complete\n"));
2835   }
2836   return result;
2837 }
2838
2839 /*
2840  * The DO function is generic for both protocols. There was previously two
2841  * separate ones but this way means less duplicated code.
2842  */
2843
2844 static CURLcode ssh_do(struct connectdata *conn, bool *done)
2845 {
2846   CURLcode res;
2847   bool connected = 0;
2848   struct SessionHandle *data = conn->data;
2849   struct ssh_conn *sshc = &conn->proto.sshc;
2850
2851   *done = FALSE; /* default to false */
2852
2853   data->req.size = -1; /* make sure this is unknown at this point */
2854
2855   sshc->actualcode = CURLE_OK; /* reset error code */
2856   sshc->secondCreateDirs =0;   /* reset the create dir attempt state
2857                                   variable */
2858
2859   Curl_pgrsSetUploadCounter(data, 0);
2860   Curl_pgrsSetDownloadCounter(data, 0);
2861   Curl_pgrsSetUploadSize(data, 0);
2862   Curl_pgrsSetDownloadSize(data, 0);
2863
2864   if(conn->handler->protocol & CURLPROTO_SCP)
2865     res = scp_perform(conn, &connected,  done);
2866   else
2867     res = sftp_perform(conn, &connected,  done);
2868
2869   return res;
2870 }
2871
2872 /* BLOCKING, but the function is using the state machine so the only reason
2873    this is still blocking is that the multi interface code has no support for
2874    disconnecting operations that takes a while */
2875 static CURLcode scp_disconnect(struct connectdata *conn, bool dead_connection)
2876 {
2877   CURLcode result = CURLE_OK;
2878   struct ssh_conn *ssh = &conn->proto.sshc;
2879   (void) dead_connection;
2880
2881   Curl_safefree(conn->data->req.protop);
2882
2883   if(ssh->ssh_session) {
2884     /* only if there's a session still around to use! */
2885
2886     state(conn, SSH_SESSION_DISCONNECT);
2887
2888     result = ssh_block_statemach(conn, FALSE);
2889   }
2890
2891   return result;
2892 }
2893
2894 /* generic done function for both SCP and SFTP called from their specific
2895    done functions */
2896 static CURLcode ssh_done(struct connectdata *conn, CURLcode status)
2897 {
2898   CURLcode result = CURLE_OK;
2899   struct SSHPROTO *sftp_scp = conn->data->req.protop;
2900
2901   if(status == CURLE_OK) {
2902     /* run the state-machine
2903
2904        TODO: when the multi interface is used, this _really_ should be using
2905        the ssh_multi_statemach function but we have no general support for
2906        non-blocking DONE operations, not in the multi state machine and with
2907        Curl_done() invokes on several places in the code!
2908     */
2909     result = ssh_block_statemach(conn, FALSE);
2910   }
2911   else
2912     result = status;
2913
2914   if(sftp_scp)
2915     Curl_safefree(sftp_scp->path);
2916   if(Curl_pgrsDone(conn))
2917     return CURLE_ABORTED_BY_CALLBACK;
2918
2919   conn->data->req.keepon = 0; /* clear all bits */
2920   return result;
2921 }
2922
2923
2924 static CURLcode scp_done(struct connectdata *conn, CURLcode status,
2925                          bool premature)
2926 {
2927   (void)premature; /* not used */
2928
2929   if(status == CURLE_OK)
2930     state(conn, SSH_SCP_DONE);
2931
2932   return ssh_done(conn, status);
2933
2934 }
2935
2936 /* return number of received (decrypted) bytes */
2937 static ssize_t scp_send(struct connectdata *conn, int sockindex,
2938                         const void *mem, size_t len, CURLcode *err)
2939 {
2940   ssize_t nwrite;
2941   (void)sockindex; /* we only support SCP on the fixed known primary socket */
2942
2943   /* libssh2_channel_write() returns int! */
2944   nwrite = (ssize_t)
2945     libssh2_channel_write(conn->proto.sshc.ssh_channel, mem, len);
2946
2947   ssh_block2waitfor(conn, (nwrite == LIBSSH2_ERROR_EAGAIN)?TRUE:FALSE);
2948
2949   if(nwrite == LIBSSH2_ERROR_EAGAIN) {
2950     *err = CURLE_AGAIN;
2951     nwrite = 0;
2952   }
2953   else if(nwrite < LIBSSH2_ERROR_NONE) {
2954     *err = libssh2_session_error_to_CURLE((int)nwrite);
2955     nwrite = -1;
2956   }
2957
2958   return nwrite;
2959 }
2960
2961 /*
2962  * If the read would block (EWOULDBLOCK) we return -1. Otherwise we return
2963  * a regular CURLcode value.
2964  */
2965 static ssize_t scp_recv(struct connectdata *conn, int sockindex,
2966                         char *mem, size_t len, CURLcode *err)
2967 {
2968   ssize_t nread;
2969   (void)sockindex; /* we only support SCP on the fixed known primary socket */
2970
2971   /* libssh2_channel_read() returns int */
2972   nread = (ssize_t)
2973     libssh2_channel_read(conn->proto.sshc.ssh_channel, mem, len);
2974
2975   ssh_block2waitfor(conn, (nread == LIBSSH2_ERROR_EAGAIN)?TRUE:FALSE);
2976   if(nread == LIBSSH2_ERROR_EAGAIN) {
2977     *err = CURLE_AGAIN;
2978     nread = -1;
2979   }
2980
2981   return nread;
2982 }
2983
2984 /*
2985  * =============== SFTP ===============
2986  */
2987
2988 /*
2989  ***********************************************************************
2990  *
2991  * sftp_perform()
2992  *
2993  * This is the actual DO function for SFTP. Get a file/directory according to
2994  * the options previously setup.
2995  */
2996
2997 static
2998 CURLcode sftp_perform(struct connectdata *conn,
2999                       bool *connected,
3000                       bool *dophase_done)
3001 {
3002   CURLcode result = CURLE_OK;
3003
3004   DEBUGF(infof(conn->data, "DO phase starts\n"));
3005
3006   *dophase_done = FALSE; /* not done yet */
3007
3008   /* start the first command in the DO phase */
3009   state(conn, SSH_SFTP_QUOTE_INIT);
3010
3011   /* run the state-machine */
3012   result = ssh_multi_statemach(conn, dophase_done);
3013
3014   *connected = conn->bits.tcpconnect[FIRSTSOCKET];
3015
3016   if(*dophase_done) {
3017     DEBUGF(infof(conn->data, "DO phase is complete\n"));
3018   }
3019
3020   return result;
3021 }
3022
3023 /* called from multi.c while DOing */
3024 static CURLcode sftp_doing(struct connectdata *conn,
3025                            bool *dophase_done)
3026 {
3027   CURLcode result;
3028   result = ssh_multi_statemach(conn, dophase_done);
3029
3030   if(*dophase_done) {
3031     DEBUGF(infof(conn->data, "DO phase is complete\n"));
3032   }
3033   return result;
3034 }
3035
3036 /* BLOCKING, but the function is using the state machine so the only reason
3037    this is still blocking is that the multi interface code has no support for
3038    disconnecting operations that takes a while */
3039 static CURLcode sftp_disconnect(struct connectdata *conn, bool dead_connection)
3040 {
3041   CURLcode result = CURLE_OK;
3042   (void) dead_connection;
3043
3044   DEBUGF(infof(conn->data, "SSH DISCONNECT starts now\n"));
3045
3046   Curl_safefree(conn->data->req.protop);
3047
3048   if(conn->proto.sshc.ssh_session) {
3049     /* only if there's a session still around to use! */
3050     state(conn, SSH_SFTP_SHUTDOWN);
3051     result = ssh_block_statemach(conn, FALSE);
3052   }
3053
3054   DEBUGF(infof(conn->data, "SSH DISCONNECT is done\n"));
3055
3056   return result;
3057
3058 }
3059
3060 static CURLcode sftp_done(struct connectdata *conn, CURLcode status,
3061                                bool premature)
3062 {
3063   struct ssh_conn *sshc = &conn->proto.sshc;
3064
3065   if(status == CURLE_OK) {
3066     /* Post quote commands are executed after the SFTP_CLOSE state to avoid
3067        errors that could happen due to open file handles during POSTQUOTE
3068        operation */
3069     if(!status && !premature && conn->data->set.postquote) {
3070       sshc->nextstate = SSH_SFTP_POSTQUOTE_INIT;
3071       state(conn, SSH_SFTP_CLOSE);
3072     }
3073     else
3074       state(conn, SSH_SFTP_CLOSE);
3075   }
3076   return ssh_done(conn, status);
3077 }
3078
3079 /* return number of sent bytes */
3080 static ssize_t sftp_send(struct connectdata *conn, int sockindex,
3081                          const void *mem, size_t len, CURLcode *err)
3082 {
3083   ssize_t nwrite;   /* libssh2_sftp_write() used to return size_t in 0.14
3084                        but is changed to ssize_t in 0.15. These days we don't
3085                        support libssh2 0.15*/
3086   (void)sockindex;
3087
3088   nwrite = libssh2_sftp_write(conn->proto.sshc.sftp_handle, mem, len);
3089
3090   ssh_block2waitfor(conn, (nwrite == LIBSSH2_ERROR_EAGAIN)?TRUE:FALSE);
3091
3092   if(nwrite == LIBSSH2_ERROR_EAGAIN) {
3093     *err = CURLE_AGAIN;
3094     nwrite = 0;
3095   }
3096   else if(nwrite < LIBSSH2_ERROR_NONE) {
3097     *err = libssh2_session_error_to_CURLE((int)nwrite);
3098     nwrite = -1;
3099   }
3100
3101   return nwrite;
3102 }
3103
3104 /*
3105  * Return number of received (decrypted) bytes
3106  */
3107 static ssize_t sftp_recv(struct connectdata *conn, int sockindex,
3108                          char *mem, size_t len, CURLcode *err)
3109 {
3110   ssize_t nread;
3111   (void)sockindex;
3112
3113   nread = libssh2_sftp_read(conn->proto.sshc.sftp_handle, mem, len);
3114
3115   ssh_block2waitfor(conn, (nread == LIBSSH2_ERROR_EAGAIN)?TRUE:FALSE);
3116
3117   if(nread == LIBSSH2_ERROR_EAGAIN) {
3118     *err = CURLE_AGAIN;
3119     nread = -1;
3120   }
3121   return nread;
3122 }
3123
3124 /* The get_pathname() function is being borrowed from OpenSSH sftp.c
3125    version 4.6p1. */
3126 /*
3127  * Copyright (c) 2001-2004 Damien Miller <djm@openbsd.org>
3128  *
3129  * Permission to use, copy, modify, and distribute this software for any
3130  * purpose with or without fee is hereby granted, provided that the above
3131  * copyright notice and this permission notice appear in all copies.
3132  *
3133  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
3134  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
3135  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
3136  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
3137  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
3138  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
3139  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
3140  */
3141 static CURLcode
3142 get_pathname(const char **cpp, char **path)
3143 {
3144   const char *cp = *cpp, *end;
3145   char quot;
3146   unsigned int i, j;
3147   static const char WHITESPACE[] = " \t\r\n";
3148
3149   cp += strspn(cp, WHITESPACE);
3150   if(!*cp) {
3151     *cpp = cp;
3152     *path = NULL;
3153     return CURLE_QUOTE_ERROR;
3154   }
3155
3156   *path = malloc(strlen(cp) + 1);
3157   if(*path == NULL)
3158     return CURLE_OUT_OF_MEMORY;
3159
3160   /* Check for quoted filenames */
3161   if(*cp == '\"' || *cp == '\'') {
3162     quot = *cp++;
3163
3164     /* Search for terminating quote, unescape some chars */
3165     for(i = j = 0; i <= strlen(cp); i++) {
3166       if(cp[i] == quot) {  /* Found quote */
3167         i++;
3168         (*path)[j] = '\0';
3169         break;
3170       }
3171       if(cp[i] == '\0') {  /* End of string */
3172         /*error("Unterminated quote");*/
3173         goto fail;
3174       }
3175       if(cp[i] == '\\') {  /* Escaped characters */
3176         i++;
3177         if(cp[i] != '\'' && cp[i] != '\"' &&
3178             cp[i] != '\\') {
3179           /*error("Bad escaped character '\\%c'",
3180               cp[i]);*/
3181           goto fail;
3182         }
3183       }
3184       (*path)[j++] = cp[i];
3185     }
3186
3187     if(j == 0) {
3188       /*error("Empty quotes");*/
3189       goto fail;
3190     }
3191     *cpp = cp + i + strspn(cp + i, WHITESPACE);
3192   }
3193   else {
3194     /* Read to end of filename */
3195     end = strpbrk(cp, WHITESPACE);
3196     if(end == NULL)
3197       end = strchr(cp, '\0');
3198     *cpp = end + strspn(end, WHITESPACE);
3199
3200     memcpy(*path, cp, end - cp);
3201     (*path)[end - cp] = '\0';
3202   }
3203   return CURLE_OK;
3204
3205   fail:
3206     Curl_safefree(*path);
3207     return CURLE_QUOTE_ERROR;
3208 }
3209
3210
3211 static const char *sftp_libssh2_strerror(int err)
3212 {
3213   switch (err) {
3214     case LIBSSH2_FX_NO_SUCH_FILE:
3215       return "No such file or directory";
3216
3217     case LIBSSH2_FX_PERMISSION_DENIED:
3218       return "Permission denied";
3219
3220     case LIBSSH2_FX_FAILURE:
3221       return "Operation failed";
3222
3223     case LIBSSH2_FX_BAD_MESSAGE:
3224       return "Bad message from SFTP server";
3225
3226     case LIBSSH2_FX_NO_CONNECTION:
3227       return "Not connected to SFTP server";
3228
3229     case LIBSSH2_FX_CONNECTION_LOST:
3230       return "Connection to SFTP server lost";
3231
3232     case LIBSSH2_FX_OP_UNSUPPORTED:
3233       return "Operation not supported by SFTP server";
3234
3235     case LIBSSH2_FX_INVALID_HANDLE:
3236       return "Invalid handle";
3237
3238     case LIBSSH2_FX_NO_SUCH_PATH:
3239       return "No such file or directory";
3240
3241     case LIBSSH2_FX_FILE_ALREADY_EXISTS:
3242       return "File already exists";
3243
3244     case LIBSSH2_FX_WRITE_PROTECT:
3245       return "File is write protected";
3246
3247     case LIBSSH2_FX_NO_MEDIA:
3248       return "No media";
3249
3250     case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:
3251       return "Disk full";
3252
3253     case LIBSSH2_FX_QUOTA_EXCEEDED:
3254       return "User quota exceeded";
3255
3256     case LIBSSH2_FX_UNKNOWN_PRINCIPLE:
3257       return "Unknown principle";
3258
3259     case LIBSSH2_FX_LOCK_CONFlICT:
3260       return "File lock conflict";
3261
3262     case LIBSSH2_FX_DIR_NOT_EMPTY:
3263       return "Directory not empty";
3264
3265     case LIBSSH2_FX_NOT_A_DIRECTORY:
3266       return "Not a directory";
3267
3268     case LIBSSH2_FX_INVALID_FILENAME:
3269       return "Invalid filename";
3270
3271     case LIBSSH2_FX_LINK_LOOP:
3272       return "Link points to itself";
3273   }
3274   return "Unknown error in libssh2";
3275 }
3276
3277 #endif /* USE_LIBSSH2 */