ssh.c

        err = libssh2_sftp_last_error(sftp_scp->sftp_session);
        Curl_safefree(sshc->quote_path1);
        sshc->quote_path1 = NULL;
        Curl_safefree(sshc->quote_path2);
        sshc->quote_path2 = NULL;
        failf(data, "symlink command failed: %s",
              sftp_libssh2_strerror(err));
        state(conn, SSH_SFTP_CLOSE);
        sshc->actualCode = CURLE_FTP_QUOTE_ERROR;
        break;
      }
      state(conn, SSH_SFTP_NEXT_QUOTE);
      break;

    case SSH_SFTP_QUOTE_MKDIR:
      rc = libssh2_sftp_mkdir(sftp_scp->sftp_session, sshc->quote_path1, 0755);
      if (rc == LIBSSH2_ERROR_EAGAIN) {
        break;
      }
      else if (rc != 0) {
        err = libssh2_sftp_last_error(sftp_scp->sftp_session);
        Curl_safefree(sshc->quote_path1);
        sshc->quote_path1 = NULL;
        failf(data, "mkdir command failed: %s", sftp_libssh2_strerror(err));
        state(conn, SSH_SFTP_CLOSE);
        sshc->actualCode = CURLE_FTP_QUOTE_ERROR;
        break;
      }
      state(conn, SSH_SFTP_NEXT_QUOTE);
      break;

    case SSH_SFTP_QUOTE_RENAME:
      rc = libssh2_sftp_rename(sftp_scp->sftp_session, sshc->quote_path1,
                               sshc->quote_path2);
      if (rc == LIBSSH2_ERROR_EAGAIN) {
        break;
      } else if (rc != 0) {
        err = libssh2_sftp_last_error(sftp_scp->sftp_session);
        Curl_safefree(sshc->quote_path1);
        sshc->quote_path1 = NULL;
        Curl_safefree(sshc->quote_path2);
        sshc->quote_path2 = NULL;
        failf(data, "rename command failed: %s", sftp_libssh2_strerror(err));
        state(conn, SSH_SFTP_CLOSE);
        sshc->actualCode = CURLE_FTP_QUOTE_ERROR;
        break;
      }
      state(conn, SSH_SFTP_NEXT_QUOTE);
      break;

    case SSH_SFTP_QUOTE_RMDIR:
      rc = libssh2_sftp_rmdir(sftp_scp->sftp_session, sshc->quote_path1);
      if (rc == LIBSSH2_ERROR_EAGAIN) {
        break;
      }
      else if (rc != 0) {
        err = libssh2_sftp_last_error(sftp_scp->sftp_session);
        Curl_safefree(sshc->quote_path1);
        sshc->quote_path1 = NULL;
        failf(data, "rmdir command failed: %s", sftp_libssh2_strerror(err));
        state(conn, SSH_SFTP_CLOSE);
        sshc->actualCode = CURLE_FTP_QUOTE_ERROR;
        break;
      }
      state(conn, SSH_SFTP_NEXT_QUOTE);
      break;

    case SSH_SFTP_QUOTE_UNLINK:
      rc = libssh2_sftp_unlink(sftp_scp->sftp_session, sshc->quote_path1);
      if (rc == LIBSSH2_ERROR_EAGAIN) {
        break;
      }
      else if (rc != 0) {
        err = libssh2_sftp_last_error(sftp_scp->sftp_session);
        Curl_safefree(sshc->quote_path1);
        sshc->quote_path1 = NULL;
        failf(data, "rm command failed: %s", sftp_libssh2_strerror(err));
        state(conn, SSH_SFTP_CLOSE);
        sshc->actualCode = CURLE_FTP_QUOTE_ERROR;
        break;
      }
      state(conn, SSH_SFTP_NEXT_QUOTE);
      break;

    case SSH_SFTP_TRANS_INIT:
      if (data->set.upload) {
        state(conn, SSH_SFTP_UPLOAD_INIT);
        break;
      } else {
        if (sftp_scp->path[strlen(sftp_scp->path)-1] == '/') {
          state(conn, SSH_SFTP_READDIR_INIT);
          break;
        } else {
          state(conn, SSH_SFTP_DOWNLOAD_INIT);
          break;
        }
      }
      break;

    case SSH_SFTP_UPLOAD_INIT:
      /*
       * NOTE!!!  libssh2 requires that the destination path is a full path
       *          that includes the destination file and name OR ends in a "/"
       *          If this is not done the destination file will be named the
       *          same name as the last directory in the path.
       */
      sftp_scp->sftp_handle =
      libssh2_sftp_open(sftp_scp->sftp_session, sftp_scp->path,
                        LIBSSH2_FXF_WRITE|LIBSSH2_FXF_CREAT|LIBSSH2_FXF_TRUNC,
                        data->set.new_file_perms);
      if (!sftp_scp->sftp_handle) {
        if (libssh2_session_last_errno(sftp_scp->ssh_session) ==
            LIBSSH2_ERROR_EAGAIN) {
          break;
        } else {
          err = libssh2_sftp_last_error(sftp_scp->sftp_session);
          if (sshc->secondCreateDirs) {
            state(conn, SSH_SFTP_CLOSE);
            sshc->actualCode = err;
            break;
          }
          else if (((err == LIBSSH2_FX_NO_SUCH_FILE) ||
                    (err == LIBSSH2_FX_FAILURE) ||
                    (err == LIBSSH2_FX_NO_SUCH_PATH)) &&
                   (data->set.ftp_create_missing_dirs &&
                    (strlen(sftp_scp->path) > 1))) {
            /* try to create the path remotely */
            sshc->secondCreateDirs = 1;
            state(conn, SSH_SFTP_CREATE_DIRS_INIT);
            break;
          }
          state(conn, SSH_SFTP_CLOSE);
          sshc->actualCode = sftp_libssh2_error_to_CURLE(err);
          break;
        }
      }

      /* upload data */
      result = Curl_setup_transfer(conn, -1, -1, FALSE, NULL,
                                   FIRSTSOCKET, NULL);

      if (result) {
        state(conn, SSH_SFTP_CLOSE);
        sshc->actualCode = result;
      } else {
        state(conn, SSH_STOP);
      }
      break;

    case SSH_SFTP_CREATE_DIRS_INIT:
      if (strlen(sftp_scp->path) > 1) {
        sshc->slash_pos = sftp_scp->path + 1; /* ignore the leading '/' */
        state(conn, SSH_SFTP_CREATE_DIRS);
      } else {
        state(conn, SSH_SFTP_UPLOAD_INIT);
      }
      break;

    case SSH_SFTP_CREATE_DIRS:
      if ((sshc->slash_pos = strchr(sshc->slash_pos, '/')) != NULL) {
        *sshc->slash_pos = 0;

        infof(data, "Creating directory '%s'\n", sftp_scp->path);
        state(conn, SSH_SFTP_CREATE_DIRS_MKDIR);
        break;
      } else {
        state(conn, SSH_SFTP_UPLOAD_INIT);
      }
      break;

    case SSH_SFTP_CREATE_DIRS_MKDIR:
      /* 'mode' - parameter is preliminary - default to 0644 */
      rc = libssh2_sftp_mkdir(sftp_scp->sftp_session, sftp_scp->path,
                              data->set.new_directory_perms);
      if (rc == LIBSSH2_ERROR_EAGAIN) {
        break;
      }
      *sshc->slash_pos = '/';
      ++sshc->slash_pos;
      if (rc == -1) {
        unsigned int sftp_err = 0;
        /*
         * abort if failure wasn't that the dir already exists or the
         * permission was denied (creation might succeed further
         * down the path) - retry on unspecific FAILURE also
         */
        sftp_err = libssh2_sftp_last_error(sftp_scp->sftp_session);
        if ((sftp_err != LIBSSH2_FX_FILE_ALREADY_EXISTS) &&
            (sftp_err != LIBSSH2_FX_FAILURE) &&
            (sftp_err != LIBSSH2_FX_PERMISSION_DENIED)) {
          result = sftp_libssh2_error_to_CURLE(sftp_err);
          state(conn, SSH_SFTP_CLOSE);
          sshc->actualCode = result;
          break;
        }
      }
      state(conn, SSH_SFTP_CREATE_DIRS);
      break;

    case SSH_SFTP_READDIR_INIT:
      /*
       * This is a directory that we are trying to get, so produce a
       * directory listing
       */
      sftp_scp->sftp_handle = libssh2_sftp_opendir(sftp_scp->sftp_session,
                                                   sftp_scp->path);
      if (!sftp_scp->sftp_handle) {
        if (libssh2_session_last_errno(sftp_scp->ssh_session) ==
            LIBSSH2_ERROR_EAGAIN) {
          break;
        } else {
          err = libssh2_sftp_last_error(sftp_scp->sftp_session);
          failf(data, "Could not open directory for reading: %s",
                sftp_libssh2_strerror(err));
          state(conn, SSH_SFTP_CLOSE);
          sshc->actualCode = sftp_libssh2_error_to_CURLE(err);
          break;
        }
      }
      if ((sshc->readdir_filename = (char *)malloc(PATH_MAX+1)) == NULL) {
        state(conn, SSH_SFTP_CLOSE);
        sshc->actualCode = CURLE_OUT_OF_MEMORY;
        break;
      }
      if ((sshc->readdir_longentry = (char *)malloc(PATH_MAX+1)) == NULL) {
        Curl_safefree(sshc->readdir_filename);
        sshc->readdir_filename = NULL;
        state(conn, SSH_SFTP_CLOSE);
        sshc->actualCode = CURLE_OUT_OF_MEMORY;
        break;
      }
      state(conn, SSH_SFTP_READDIR);
      break;

    case SSH_SFTP_READDIR:
#if (LIBSSH2_APINO >= 200706151200L)
      sshc->readdir_len = libssh2_sftp_readdir_ex(sftp_scp->sftp_handle,
                                                  sshc->readdir_filename,
                                                  PATH_MAX,
                                                  sshc->readdir_longentry,
                                                  PATH_MAX,
                                                  &sshc->readdir_attrs);
#else /* !(LIBSSH2_APINO >= 200706151200L) */
      sshc->readdir_len = libssh2_sftp_readdir(sftp_scp->sftp_handle,
                                               sshc->readdir_filename,
                                               PATH_MAX,
                                               &sshc->readdir_attrs);
#endif /* !(LIBSSH2_APINO >= 200706151200L) */
      if (sshc->readdir_len == LIBSSH2_ERROR_EAGAIN) {
        break;
      }
      if (sshc->readdir_len > 0) {
        sshc->readdir_filename[sshc->readdir_len] = '\0';

        if (data->set.ftp_list_only) {
          char *tmpLine;

          tmpLine = aprintf("%s\n", sshc->readdir_filename);
          if (tmpLine == NULL) {
            state(conn, SSH_SFTP_CLOSE);
            sshc->actualCode = CURLE_OUT_OF_MEMORY;
            break;
          }
          result = Curl_client_write(conn, CLIENTWRITE_BODY, tmpLine, 0);
          Curl_safefree(tmpLine);

          /* output debug output if that is requested */
          if (data->set.verbose) {
            Curl_debug(data, CURLINFO_DATA_OUT, sshc->readdir_filename,
                       sshc->readdir_len, conn);
          }
        } else {
#if (LIBSSH2_APINO >= 200706151200L)
          sshc->readdir_currLen = strlen(sshc->readdir_longentry);
          sshc->readdir_totalLen = 80 + sshc->readdir_currLen;
          sshc->readdir_line = (char *)calloc(sshc->readdir_totalLen, 1);
          if (!sshc->readdir_line) {
            Curl_safefree(sshc->readdir_filename);
            sshc->readdir_filename = NULL;
            Curl_safefree(sshc->readdir_longentry);
            sshc->readdir_longentry = NULL;
            state(conn, SSH_SFTP_CLOSE);
            sshc->actualCode = CURLE_OUT_OF_MEMORY;
            break;
          }

          memcpy(sshc->readdir_line, sshc->readdir_longentry,
                 sshc->readdir_currLen);
#else /* !(LIBSSH2_APINO >= 200706151200L) */
          sshc->readdir_totalLen = 80 + sshc->readdir_len;
          sshc->readdir_line = (char *)malloc(sshc->readdir_totalLen);
          if (!sshc->readdir_line) {
            Curl_safefree(sshc->readdir_filename);
            sshc->readdir_filename = NULL;
            Curl_safefree(sshc->readdir_longentry);
            sshc->readdir_longentry = NULL;
            state(conn, SSH_SFTP_CLOSE);
            sshc->actualCode = CURLE_OUT_OF_MEMORY;
            break;
          }

          if (!(sshc->readdir_attrs.flags & LIBSSH2_SFTP_ATTR_UIDGID)) {
            sshc->readdir_attrs.uid = sshc->readdir_attrs.gid = 0;
          }

          sshc->readdir_currLen = snprintf(sshc->readdir_line,
                                           sshc->readdir_totalLen,
                                           "----------   1 %5d %5d",
                                           sshc->readdir_attrs.uid,
                                           sshc->readdir_attrs.gid);

          if (sshc->readdir_attrs.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) {
            if ((sshc->readdir_attrs.permissions & LIBSSH2_SFTP_S_IFMT) ==
                LIBSSH2_SFTP_S_IFDIR) {
              sshc->readdir_line[0] = 'd';
            }
            else if ((sshc->readdir_attrs.permissions & LIBSSH2_SFTP_S_IFMT) ==
                     LIBSSH2_SFTP_S_IFLNK) {
              sshc->readdir_line[0] = 'l';
            }
            else if ((sshc->readdir_attrs.permissions & LIBSSH2_SFTP_S_IFMT) ==
                     LIBSSH2_SFTP_S_IFSOCK) {
              sshc->readdir_line[0] = 's';
            }
            else if ((sshc->readdir_attrs.permissions & LIBSSH2_SFTP_S_IFMT) ==
                     LIBSSH2_SFTP_S_IFCHR) {
              sshc->readdir_line[0] = 'c';
            }
            else if ((sshc->readdir_attrs.permissions & LIBSSH2_SFTP_S_IFMT) ==
                     LIBSSH2_SFTP_S_IFBLK) {
              sshc->readdir_line[0] = 'b';
            }
            if (sshc->readdir_attrs.permissions & LIBSSH2_SFTP_S_IRUSR) {
              sshc->readdir_line[1] = 'r';
            }
            if (sshc->readdir_attrs.permissions & LIBSSH2_SFTP_S_IWUSR) {
              sshc->readdir_line[2] = 'w';
            }
            if (sshc->readdir_attrs.permissions & LIBSSH2_SFTP_S_IXUSR) {
              sshc->readdir_line[3] = 'x';
            }
            if (sshc->readdir_attrs.permissions & LIBSSH2_SFTP_S_IRGRP) {
              sshc->readdir_line[4] = 'r';
            }
            if (sshc->readdir_attrs.permissions & LIBSSH2_SFTP_S_IWGRP) {
              sshc->readdir_line[5] = 'w';
            }
            if (sshc->readdir_attrs.permissions & LIBSSH2_SFTP_S_IXGRP) {
              sshc->readdir_line[6] = 'x';
            }
            if (sshc->readdir_attrs.permissions & LIBSSH2_SFTP_S_IROTH) {
              sshc->readdir_line[7] = 'r';
            }
            if (sshc->readdir_attrs.permissions & LIBSSH2_SFTP_S_IWOTH) {
              sshc->readdir_line[8] = 'w';
            }
            if (sshc->readdir_attrs.permissions & LIBSSH2_SFTP_S_IXOTH) {
              sshc->readdir_line[9] = 'x';
            }
          }
          if (sshc->readdir_attrs.flags & LIBSSH2_SFTP_ATTR_SIZE) {
            sshc->readdir_currLen += snprintf(sshc->readdir_line +
                                              sshc->readdir_currLen,
                                              sshc->readdir_totalLen -
                                              sshc->readdir_currLen,
                                              "%11lld",
                                              sshc->readdir_attrs.filesize);
          }
          if (sshc->readdir_attrs.flags & LIBSSH2_SFTP_ATTR_ACMODTIME) {
            static const char * const months[12] = {
              "Jan", "Feb", "Mar", "Apr", "May", "Jun",
              "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
            struct tm *nowParts;
            time_t now, remoteTime;

            now = time(NULL);
            remoteTime = (time_t)sshc->readdir_attrs.mtime;
            nowParts = localtime(&remoteTime);

            if ((time_t)sshc->readdir_attrs.mtime > (now - (86400 * 180))) {
              sshc->readdir_currLen += snprintf(sshc->readdir_line +
                                                sshc->readdir_currLen,
                                                sshc->readdir_totalLen -
                                                sshc->readdir_currLen,
                                                " %s %2d %2d:%02d",
                                                months[nowParts->tm_mon],
                                                nowParts->tm_mday,
                                                nowParts->tm_hour,
                                                nowParts->tm_min);
            } else {
              sshc->readdir_currLen += snprintf(sshc->readdir_line +
                                                sshc->readdir_currLen,
                                                sshc->readdir_totalLen -
                                                sshc->readdir_currLen,
                                                " %s %2d %5d",
                                                months[nowParts->tm_mon],
                                                nowParts->tm_mday,
                                                1900+nowParts->tm_year);
            }
          }
          sshc->readdir_currLen += snprintf(sshc->readdir_line +
                                            sshc->readdir_currLen,
                                            sshc->readdir_totalLen -
                                            sshc->readdir_currLen, " %s",
                                            sshc->readdir_filename);
#endif /* !(LIBSSH2_APINO >= 200706151200L) */
          if ((sshc->readdir_attrs.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) &&
              ((sshc->readdir_attrs.permissions & LIBSSH2_SFTP_S_IFMT) ==
               LIBSSH2_SFTP_S_IFLNK)) {
            sshc->readdir_linkPath = (char *)malloc(PATH_MAX + 1);
            if (sshc->readdir_linkPath == NULL) {
              Curl_safefree(sshc->readdir_filename);
              sshc->readdir_filename = NULL;
              Curl_safefree(sshc->readdir_longentry);
              sshc->readdir_longentry = NULL;
              state(conn, SSH_SFTP_CLOSE);
              sshc->actualCode = CURLE_OUT_OF_MEMORY;
              break;
            }

            snprintf(sshc->readdir_linkPath, PATH_MAX, "%s%s", sftp_scp->path,
                     sshc->readdir_filename);
            state(conn, SSH_SFTP_READDIR_LINK);
            break;
          }
          state(conn, SSH_SFTP_READDIR_BOTTOM);
          break;
        }
      }
      else if (sshc->readdir_len == 0) {
        Curl_safefree(sshc->readdir_filename);
        sshc->readdir_filename = NULL;
        Curl_safefree(sshc->readdir_longentry);
        sshc->readdir_longentry = NULL;
        state(conn, SSH_SFTP_READDIR_DONE);
        break;
      }
      else if (sshc->readdir_len <= 0) {
        err = libssh2_sftp_last_error(sftp_scp->sftp_session);
        sshc->actualCode = err;
        failf(data, "Could not open remote file for reading: %s :: %d",
              sftp_libssh2_strerror(err),
              libssh2_session_last_errno(sftp_scp->ssh_session));
        Curl_safefree(sshc->readdir_filename);
        sshc->readdir_filename = NULL;
        Curl_safefree(sshc->readdir_longentry);
        sshc->readdir_longentry = NULL;
        state(conn, SSH_SFTP_CLOSE);
        break;
      }
      break;

    case SSH_SFTP_READDIR_LINK:
      sshc->readdir_len = libssh2_sftp_readlink(sftp_scp->sftp_session,
                                                sshc->readdir_linkPath,
                                                sshc->readdir_filename,
                                                PATH_MAX);
      if (sshc->readdir_len == LIBSSH2_ERROR_EAGAIN) {
        break;
      }
      Curl_safefree(sshc->readdir_linkPath);
      sshc->readdir_linkPath = NULL;
      sshc->readdir_line = realloc(sshc->readdir_line,
                                   sshc->readdir_totalLen + 4 +
                                   sshc->readdir_len);
      if (!sshc->readdir_line) {
        Curl_safefree(sshc->readdir_filename);
        sshc->readdir_filename = NULL;
        Curl_safefree(sshc->readdir_longentry);
        sshc->readdir_longentry = NULL;
        state(conn, SSH_SFTP_CLOSE);
        sshc->actualCode = CURLE_OUT_OF_MEMORY;
        break;
      }

      sshc->readdir_currLen += snprintf(sshc->readdir_line +
                                        sshc->readdir_currLen,
                                        sshc->readdir_totalLen -
                                        sshc->readdir_currLen,
                                        " -> %s",
                                        sshc->readdir_filename);

      state(conn, SSH_SFTP_READDIR_BOTTOM);
      break;

    case SSH_SFTP_READDIR_BOTTOM:
      sshc->readdir_currLen += snprintf(sshc->readdir_line +
                                        sshc->readdir_currLen,
                                        sshc->readdir_totalLen -
                                        sshc->readdir_currLen, "\n");
      result = Curl_client_write(conn, CLIENTWRITE_BODY,
                                 sshc->readdir_line, 0);

      /* output debug output if that is requested */
      if (data->set.verbose) {
        Curl_debug(data, CURLINFO_DATA_OUT, sshc->readdir_line,
                   sshc->readdir_currLen, conn);
      }
      Curl_safefree(sshc->readdir_line);
      sshc->readdir_line = NULL;
      state(conn, SSH_SFTP_READDIR);
      break;

    case SSH_SFTP_READDIR_DONE:
      if (libssh2_sftp_closedir(sftp_scp->sftp_handle) ==
          LIBSSH2_ERROR_EAGAIN) {
        break;
      }
      sftp_scp->sftp_handle = NULL;
      Curl_safefree(sshc->readdir_filename);
      sshc->readdir_filename = NULL;
      Curl_safefree(sshc->readdir_longentry);
      sshc->readdir_longentry = NULL;

      /* no data to transfer */
      result = Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
      state(conn, SSH_STOP);
      break;

    case SSH_SFTP_DOWNLOAD_INIT:
      /*
       * Work on getting the specified file
       */
      sftp_scp->sftp_handle =
        libssh2_sftp_open(sftp_scp->sftp_session, sftp_scp->path,
                          LIBSSH2_FXF_READ, data->set.new_file_perms);
      if (!sftp_scp->sftp_handle) {
        if (libssh2_session_last_errno(sftp_scp->ssh_session) ==
             LIBSSH2_ERROR_EAGAIN) {
          break;
        } else {
          err = libssh2_sftp_last_error(sftp_scp->sftp_session);
          failf(data, "Could not open remote file for reading: %s",
                sftp_libssh2_strerror(err));
          state(conn, SSH_SFTP_CLOSE);
          sshc->actualCode = sftp_libssh2_error_to_CURLE(err);
          break;
        }
      }
      state(conn, SSH_SFTP_DOWNLOAD_STAT);
      break;

    case SSH_SFTP_DOWNLOAD_STAT:
      {
        LIBSSH2_SFTP_ATTRIBUTES attrs;

        rc = libssh2_sftp_stat(sftp_scp->sftp_session, sftp_scp->path, &attrs);
        if (rc == LIBSSH2_ERROR_EAGAIN) {
          break;
        }
        else if (rc) {
          /*
           * libssh2_sftp_open() didn't return an error, so maybe the server
           * just doesn't support stat()
           */
          data->reqdata.size = -1;
          data->reqdata.maxdownload = -1;
        } else {
          data->reqdata.size = attrs.filesize;
          data->reqdata.maxdownload = attrs.filesize;
          Curl_pgrsSetDownloadSize(data, attrs.filesize);
        }
      }

      /* Setup the actual download */
      result = Curl_setup_transfer(conn, FIRSTSOCKET, data->reqdata.size,
                                   FALSE, NULL, -1, NULL);
      if (result) {
        state(conn, SSH_SFTP_CLOSE);
        sshc->actualCode = result;
      } else {
        state(conn, SSH_STOP);
      }
      break;

    case SSH_SFTP_CLOSE:
      if (sftp_scp->sftp_handle) {
        rc = libssh2_sftp_close(sftp_scp->sftp_handle);
        if (rc == LIBSSH2_ERROR_EAGAIN) {
          break;
        }
        else if (rc < 0) {
          infof(data, "Failed to close libssh2 file\n");
        }
        sftp_scp->sftp_handle = NULL;
      }
      state(conn, SSH_SFTP_SHUTDOWN);
      break;

    case SSH_SFTP_SHUTDOWN:
      if (sftp_scp->sftp_session) {
        rc = libssh2_sftp_shutdown(sftp_scp->sftp_session);
        if (rc == LIBSSH2_ERROR_EAGAIN) {
          break;
        }
        else if (rc < 0) {
          infof(data, "Failed to stop libssh2 sftp subsystem\n");
        }
        sftp_scp->sftp_session = NULL;
      }

      Curl_safefree(sftp_scp->path);
      sftp_scp->path = NULL;

      Curl_safefree(sftp_scp->homedir);
      sftp_scp->homedir = NULL;

      state(conn, SSH_CHANNEL_CLOSE);
      break;

    case SSH_SCP_TRANS_INIT:
      if (data->set.upload) {
        if (data->set.infilesize < 0) {
          failf(data, "SCP requires a known file size for upload");
          sshc->actualCode = CURLE_UPLOAD_FAILED;
          state(conn, SSH_SCP_CHANNEL_FREE);
          break;
        }
        state(conn, SSH_SCP_UPLOAD_INIT);
      } else {
        state(conn, SSH_SCP_DOWNLOAD_INIT);
      }
      break;

    case SSH_SCP_UPLOAD_INIT:
      /*
       * libssh2 requires that the destination path is a full path that
       * includes the destination file and name OR ends in a "/" .  If this is
       * not done the destination file will be named the same name as the last
       * directory in the path.
       */
      sftp_scp->ssh_channel =
                  libssh2_scp_send_ex(sftp_scp->ssh_session, sftp_scp->path,
                                      data->set.new_file_perms,
                                      data->set.infilesize, 0, 0);
      if (!sftp_scp->ssh_channel) {
        if (libssh2_session_last_errno(sftp_scp->ssh_session) ==
            LIBSSH2_ERROR_EAGAIN) {
          break;
        } else {
          int ssh_err;
          char *err_msg;
          
          ssh_err = libssh2_session_last_error(sftp_scp->ssh_session,
                                               &err_msg, NULL, 0);
          err = libssh2_session_error_to_CURLE(ssh_err);
          failf(conn->data, "%s", err_msg);
          state(conn, SSH_SCP_CHANNEL_FREE);
          sshc->actualCode = err;
          break;
        }
      }

      /* upload data */
      result = Curl_setup_transfer(conn, -1, data->reqdata.size, FALSE, NULL,
                                   FIRSTSOCKET, NULL);

      if (result) {
        state(conn, SSH_SCP_CHANNEL_FREE);
        sshc->actualCode = result;
      } else {
        state(conn, SSH_STOP);
      }
      break;

    case SSH_SCP_DOWNLOAD_INIT:
      {
        /*
         * We must check the remote file; if it is a directory no values will
         * be set in sb
         */
        struct stat sb;
        curl_off_t bytecount;

        memset(&sb, 0, sizeof(struct stat));
        sftp_scp->ssh_channel = libssh2_scp_recv(sftp_scp->ssh_session,
                                                 sftp_scp->path, &sb);
        if (!sftp_scp->ssh_channel) {
          if (libssh2_session_last_errno(sftp_scp->ssh_session) ==
             LIBSSH2_ERROR_EAGAIN) {
            break;
          } else {
            int ssh_err;
            char *err_msg;

            ssh_err = libssh2_session_last_error(sftp_scp->ssh_session,
                                                 &err_msg, NULL, 0);
            err = libssh2_session_error_to_CURLE(ssh_err);
            failf(conn->data, "%s", err_msg);
            state(conn, SSH_SCP_CHANNEL_FREE);
            sshc->actualCode = err;
            break;
          }
        }

        /* download data */
        bytecount = (curl_off_t)sb.st_size;
        data->reqdata.maxdownload =  (curl_off_t)sb.st_size;
        result = Curl_setup_transfer(conn, FIRSTSOCKET,
                                     bytecount, FALSE, NULL, -1, NULL);

        if (result) {
          state(conn, SSH_SCP_CHANNEL_FREE);
          sshc->actualCode = result;
        } else {
          state(conn, SSH_STOP);
        }
      }
      break;

    case SSH_SCP_DONE:
      if (data->set.upload) {
        state(conn, SSH_SCP_SEND_EOF);
      } else {
        state(conn, SSH_SCP_CHANNEL_FREE);
      }
      break;

    case SSH_SCP_SEND_EOF:
      if (sftp_scp->ssh_channel) {
        rc = libssh2_channel_send_eof(sftp_scp->ssh_channel);
        if (rc == LIBSSH2_ERROR_EAGAIN) {
          break;
        }
        else if (rc) {
          infof(data, "Failed to send libssh2 channel EOF\n");
        }
      }
      state(conn, SSH_SCP_WAIT_EOF);
      break;

    case SSH_SCP_WAIT_EOF:
      if (sftp_scp->ssh_channel) {
        rc = libssh2_channel_wait_eof(sftp_scp->ssh_channel);
        if (rc == LIBSSH2_ERROR_EAGAIN) {
          break;
        }
        else if (rc) {
          infof(data, "Failed to get channel EOF\n");
        }
      }
      state(conn, SSH_SCP_WAIT_CLOSE);
      break;

    case SSH_SCP_WAIT_CLOSE:
      if (sftp_scp->ssh_channel) {
        rc = libssh2_channel_wait_closed(sftp_scp->ssh_channel);
        if (rc == LIBSSH2_ERROR_EAGAIN) {
          break;
        }
        else if (rc) {
          infof(data, "Channel failed to close\n");
        }
      }
      state(conn, SSH_SCP_CHANNEL_FREE);
      break;

    case SSH_SCP_CHANNEL_FREE:
      if (sftp_scp->ssh_channel) {
        rc = libssh2_channel_free(sftp_scp->ssh_channel);
        if (rc == LIBSSH2_ERROR_EAGAIN) {
          break;
        }
        else if (rc < 0) {
          infof(data, "Failed to free libssh2 scp subsystem\n");
        }
        sftp_scp->ssh_channel = NULL;
      }
      state(conn, SSH_SESSION_DISCONECT);
      break;

    case SSH_CHANNEL_CLOSE:
      if (sftp_scp->ssh_channel) {
        rc = libssh2_channel_close(sftp_scp->ssh_channel);
        if (rc == LIBSSH2_ERROR_EAGAIN) {
          break;
        }
        else if (rc < 0) {
          infof(data, "Failed to stop libssh2 channel subsystem\n");
        }
        sftp_scp->ssh_channel = NULL;
      }
      state(conn, SSH_SESSION_DISCONECT);
      break;

    case SSH_SESSION_DISCONECT:
      if (sftp_scp->ssh_session) {
        rc = libssh2_session_disconnect(sftp_scp->ssh_session, "Shutdown");
        if (rc == LIBSSH2_ERROR_EAGAIN) {
          break;
        }
        else if (rc < 0) {
          infof(data, "Failed to disconnect libssh2 session\n");
        }
      }

      Curl_safefree(sftp_scp->path);
      sftp_scp->path = NULL;

      Curl_safefree(sftp_scp->homedir);
      sftp_scp->homedir = NULL;

      state(conn, SSH_SESSION_FREE);
      break;

    case SSH_SESSION_FREE:
      if (sftp_scp->ssh_session) {
        rc = libssh2_session_free(sftp_scp->ssh_session);
        if (rc == LIBSSH2_ERROR_EAGAIN) {
          break;
        }
        else if (rc < 0) {
          infof(data, "Failed to free libssh2 session\n");
        }
        sftp_scp->ssh_session = NULL;
      }
      sshc->nextState = SSH_NO_STATE;
      state(conn, SSH_STOP);
      result = sshc->actualCode;
      break;

    case SSH_QUIT:
      /* fallthrough, just stop! */
    default:
      /* internal error */
      sshc->nextState = SSH_NO_STATE;
      state(conn, SSH_STOP);
      break;
  }

  return result;
}

/* called repeatedly until done from multi.c */
CURLcode Curl_ssh_multi_statemach(struct connectdata *conn,
                                  bool *done)
{
  struct ssh_conn *sshc = &conn->proto.sshc;
  CURLcode result = CURLE_OK;

  result = ssh_statemach_act(conn);
  *done = (bool)(sshc->state == SSH_STOP);

  return result;
}

static CURLcode ssh_easy_statemach(struct connectdata *conn)
{
  struct ssh_conn *sshc = &conn->proto.sshc;
  CURLcode result = CURLE_OK;

  while (sshc->state != SSH_STOP) {
    result = ssh_statemach_act(conn);
    if (result) {
      break;
    }
  }

  return result;
}
#endif /* (LIBSSH2_APINO >= 200706012030L) */

/*
 * SSH setup and connection
 */
static CURLcode ssh_init(struct connectdata *conn)
{
  struct SessionHandle *data = conn->data;
  struct SSHPROTO *ssh;
  if (data->reqdata.proto.ssh)
    return CURLE_OK;

  ssh = (struct SSHPROTO *)calloc(sizeof(struct SSHPROTO), 1);
  if (!ssh)
    return CURLE_OUT_OF_MEMORY;

  data->reqdata.proto.ssh = ssh;

  /* get some initial data into the ssh struct */
  ssh->bytecountp = &data->reqdata.keep.bytecount;

  /* no need to duplicate them, this connectdata struct won't change */
  ssh->user = conn->user;
  ssh->passwd = conn->passwd;

  ssh->errorstr = NULL;

  ssh->ssh_session = NULL;
  ssh->ssh_channel = NULL;
  ssh->sftp_session = NULL;
  ssh->sftp_handle = NULL;

  return CURLE_OK;
}

/*
 * Curl_ssh_connect() gets called from Curl_protocol_connect() to allow us to
 * do protocol-specific actions at connect-time.
 */
CURLcode Curl_ssh_connect(struct connectdata *conn, bool *done)
{
  int i;
  struct SSHPROTO *ssh;
  const char *fingerprint;
  const char *authlist;
  char tempHome[PATH_MAX];
  curl_socket_t sock;
  char *real_path;
  char *working_path;
  int working_path_len;
  bool authed = FALSE;
  CURLcode result;
  struct SessionHandle *data = conn->data;

  result = ssh_init(conn);
  if (result)
    return result;

  ssh = data->reqdata.proto.ssh;

#ifdef CURL_LIBSSH2_DEBUG
  if (ssh->user) {
    infof(data, "User: %s\n", ssh->user);
  }
  if (ssh->passwd) {
    infof(data, "Password: %s\n", ssh->passwd);
  }
#endif /* CURL_LIBSSH2_DEBUG */
  sock = conn->sock[FIRSTSOCKET];
  ssh->ssh_session = libssh2_session_init_ex(libssh2_malloc, libssh2_free,
                                             libssh2_realloc, ssh);
  if (ssh->ssh_session == NULL) {
    failf(data, "Failure initialising ssh session");
    return CURLE_FAILED_INIT;
  }

#ifdef CURL_LIBSSH2_DEBUG
  libssh2_trace(ssh->ssh_session, LIBSSH2_TRACE_CONN|LIBSSH2_TRACE_TRANS|
                LIBSSH2_TRACE_KEX|LIBSSH2_TRACE_AUTH|LIBSSH2_TRACE_SCP|
                LIBSSH2_TRACE_SFTP|LIBSSH2_TRACE_ERROR|
                LIBSSH2_TRACE_PUBLICKEY);
  infof(data, "SSH socket: %d\n", sock);
#endif /* CURL_LIBSSH2_DEBUG */

#if (LIBSSH2_APINO >= 200706012030L)
  state(conn, SSH_S_STARTUP);

  if (data->state.used_interface == Curl_if_multi)
    result = Curl_ssh_multi_statemach(conn, done);
  else {
    result = ssh_easy_statemach(conn);
    if (!result)
      *done = TRUE;
  }

  return result;
  (void)authed; /* not used */
  (void)working_path; /* not used */
  (void)working_path_len; /* not used */
  (void)real_path; /* not used */
  (void)tempHome; /* not used */
  (void)authlist; /* not used */
  (void)fingerprint; /* not used */
  (void)i; /* not used */

#else /* !(LIBSSH2_APINO >= 200706012030L) */

  if (libssh2_session_startup(ssh->ssh_session, sock)) {
    failf(data, "Failure establishing ssh session");
    libssh2_session_free(ssh->ssh_session);
    ssh->ssh_session = NULL;
    return CURLE_FAILED_INIT;
  }

  /*
   * Before we authenticate we should check the hostkey's fingerprint against
   * our known hosts. How that is handled (reading from file, whatever) is
   * up to us. As for know not much is implemented, besides showing how to
   * get the fingerprint.
   */
  fingerprint = libssh2_hostkey_hash(ssh->ssh_session,
                                     LIBSSH2_HOSTKEY_HASH_MD5);

#ifdef CURL_LIBSSH2_DEBUG
  /* The fingerprint points to static storage (!), don't free() it. */
  infof(data, "Fingerprint: ");
  for (i = 0; i < 16; i++) {
    infof(data, "%02X ", (unsigned char) fingerprint[i]);
  }
  infof(data, "\n");
#endif /* CURL_LIBSSH2_DEBUG */

  /* TBD - methods to check the host keys need to be done */

  /*
   * Figure out authentication methods
   * NB: As soon as we have provided a username to an openssh server we must
   * never change it later. Thus, always specify the correct username here,
   * even though the libssh2 docs kind of indicate that it should be possible
   * to get a 'generic' list (not user-specific) of authentication methods,