ssh.c

              if (attrs.permissions & LIBSSH2_SFTP_S_IWGRP) {
                line[5] = 'w';
              }
              if (attrs.permissions & LIBSSH2_SFTP_S_IXGRP) {
                line[6] = 'x';
              }
              if (attrs.permissions & LIBSSH2_SFTP_S_IROTH) {
                line[7] = 'r';
              }
              if (attrs.permissions & LIBSSH2_SFTP_S_IWOTH) {
                line[8] = 'w';
              }
              if (attrs.permissions & LIBSSH2_SFTP_S_IXOTH) {
                line[9] = 'x';
              }
            }
            if (attrs.flags & LIBSSH2_SFTP_ATTR_SIZE) {
              currLen += snprintf(line+currLen, totalLen-currLen, "%11lld",
                                  attrs.filesize);
            }
            if (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)attrs.mtime;
              nowParts = localtime(&remoteTime);

              if ((time_t)attrs.mtime > (now - (3600 * 24 * 180))) {
                currLen += snprintf(line+currLen, totalLen-currLen,
                                    " %s %2d %2d:%02d",
                                    months[nowParts->tm_mon],
                                    nowParts->tm_mday, nowParts->tm_hour,
                                    nowParts->tm_min);
              }
              else {
                currLen += snprintf(line+currLen, totalLen-currLen,
                                    " %s %2d %5d", months[nowParts->tm_mon],
                                    nowParts->tm_mday, 1900+nowParts->tm_year);
              }
            }
            currLen += snprintf(line+currLen, totalLen-currLen, " %s",
                                filename);
            if ((attrs.flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) &&
                ((attrs.permissions & LIBSSH2_SFTP_S_IFMT) ==
                 LIBSSH2_SFTP_S_IFLNK)) {
              char linkPath[PATH_MAX + 1];

              snprintf(linkPath, PATH_MAX, "%s%s", sftp->path, filename);
              len = libssh2_sftp_readlink(sftp->sftp_session, linkPath,
                                          filename, PATH_MAX);
              line = realloc(line, totalLen + 4 + len);
              if (!line)
                return CURLE_OUT_OF_MEMORY;

              currLen += snprintf(line+currLen, totalLen-currLen, " -> %s",
                                  filename);
            }

            currLen += snprintf(line+currLen, totalLen-currLen, "\n");
            res = Curl_client_write(conn, CLIENTWRITE_BODY, line, 0);
            free(line);
          }
        }
        else if (len <= 0) {
          break;
        }
      } while (1);
#if (LIBSSH2_APINO >= 200706012030)
      while (libssh2_sftp_closedir(sftp->sftp_handle) == LIBSSH2_ERROR_EAGAIN);
#else /* !(LIBSSH2_APINO >= 200706012030) */
      libssh2_sftp_closedir(sftp->sftp_handle);
#endif /* !(LIBSSH2_APINO >= 200706012030) */
      sftp->sftp_handle = NULL;

      /* no data to transfer */
      res = Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
    }
    else {
      /*
       * Work on getting the specified file
       */
#if (LIBSSH2_APINO >= 200706012030)
      do {
        sftp->sftp_handle =
          libssh2_sftp_open(sftp->sftp_session, sftp->path, LIBSSH2_FXF_READ,
                          LIBSSH2_SFTP_S_IRUSR|LIBSSH2_SFTP_S_IWUSR|
                          LIBSSH2_SFTP_S_IRGRP|LIBSSH2_SFTP_S_IROTH);
        if (!sftp->sftp_handle &&
            (libssh2_session_last_errno(sftp->ssh_session) !=
                                   LIBSSH2_ERROR_EAGAIN)) {
          err = libssh2_sftp_last_error(sftp->sftp_session);
          failf(conn->data, "Could not open remote file for reading: %s",
                sftp_libssh2_strerror(err));
          return sftp_libssh2_error_to_CURLE(err);
        }
      } while (!sftp->sftp_handle);
#else /* !(LIBSSH2_APINO >= 200706012030) */
      sftp->sftp_handle =
        libssh2_sftp_open(sftp->sftp_session, sftp->path, LIBSSH2_FXF_READ,
                          LIBSSH2_SFTP_S_IRUSR|LIBSSH2_SFTP_S_IWUSR|
                          LIBSSH2_SFTP_S_IRGRP|LIBSSH2_SFTP_S_IROTH);
      if (!sftp->sftp_handle) {
        err = libssh2_sftp_last_error(sftp->sftp_session);
        failf(conn->data, "Could not open remote file for reading: %s",
            sftp_libssh2_strerror(err));
        return sftp_libssh2_error_to_CURLE(err);
      }
#endif /* !(LIBSSH2_APINO >= 200706012030) */

#if (LIBSSH2_APINO >= 200706012030)
      while ((rc = libssh2_sftp_stat(sftp->sftp_session, sftp->path, &attrs))
             == LIBSSH2_ERROR_EAGAIN);
#else /* !(LIBSSH2_APINO >= 200706012030) */
      rc = libssh2_sftp_stat(sftp->sftp_session, sftp->path, &attrs);
#endif /* !(LIBSSH2_APINO >= 200706012030) */
      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);
      }

      Curl_pgrsTime(data, TIMER_STARTTRANSFER);

      /* Now download data. The libssh2 0.14 doesn't offer any way to do this
         without using this BLOCKING approach, so here's room for improvement
         once libssh2 can return EWOULDBLOCK to us. */
#if 0
      /* code left here just because this is what this function will use the
         day libssh2 is improved */
      res = Curl_setup_transfer(conn, FIRSTSOCKET,
                                bytecount, FALSE, NULL, -1, NULL);
#endif
      while (res == CURLE_OK) {
#if (LIBSSH2_APINO >= 200706012030)
        ssize_t nread;
        
        while ((nread = libssh2_sftp_read(data->reqdata.proto.ssh->sftp_handle,
                                  buf, BUFSIZE-1)) == LIBSSH2_ERROR_EAGAIN);
#else /* !(LIBSSH2_APINO >= 200706012030) */
        size_t nread;
        /* NOTE: most *read() functions return ssize_t but this returns size_t
          which normally is unsigned! */
        nread = libssh2_sftp_read(data->reqdata.proto.ssh->sftp_handle,
                                  buf, BUFSIZE-1);
#endif /* !(LIBSSH2_APINO >= 200706012030) */

        if (nread > 0)
          buf[nread] = 0;

#if (LIBSSH2_APINO >= 200706012030)
        if (nread <= 0)
          break;
#else /* !(LIBSSH2_APINO >= 200706012030) */
        /* this check can be changed to a <= 0 when nread is changed to a
          signed variable type */
        if ((nread == 0) || (nread == (size_t)~0))
          break;
#endif /* !(LIBSSH2_APINO >= 200706012030) */

        bytecount += nread;

        res = Curl_client_write(conn, CLIENTWRITE_BODY, buf, nread);
        if(res)
          return res;

        Curl_pgrsSetDownloadCounter(data, bytecount);

        if(Curl_pgrsUpdate(conn))
          res = CURLE_ABORTED_BY_CALLBACK;
        else {
          struct timeval now = Curl_tvnow();
          res = Curl_speedcheck(data, now);
        }
      }
      if(Curl_pgrsUpdate(conn))
        res = CURLE_ABORTED_BY_CALLBACK;

      /* no (more) data to transfer */
      res = Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
    }
  }

  return res;
}

CURLcode Curl_sftp_done(struct connectdata *conn, CURLcode status,
                        bool premature)
{
  struct SSHPROTO *sftp = conn->data->reqdata.proto.ssh;
  CURLcode rc = CURLE_OK;
  int ret;
  (void)premature; /* not used */

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

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

  if (sftp->sftp_handle) {
#if (LIBSSH2_APINO >= 200706012030)
    while ((ret = libssh2_sftp_close(sftp->sftp_handle)) ==
           LIBSSH2_ERROR_EAGAIN);
    if (ret < 0) {
      infof(conn->data, "Failed to close libssh2 file\n");
    }
#else /* !(LIBSSH2_APINO >= 200706012030) */
    if (libssh2_sftp_close(sftp->sftp_handle) < 0) {
      infof(conn->data, "Failed to close libssh2 file\n");
    }
#endif /* !(LIBSSH2_APINO >= 200706012030) */
  }

  /* Before we shut down, see if there are any post-quote commands to send: */
  if(!status && !premature && conn->data->set.postquote) {
    infof(conn->data, "Sending postquote commands\n");
    rc = sftp_sendquote(conn, conn->data->set.postquote);
  }

  if (sftp->sftp_session) {
    if (libssh2_sftp_shutdown(sftp->sftp_session) < 0) {
      infof(conn->data, "Failed to stop libssh2 sftp subsystem\n");
    }
  }

  if (sftp->ssh_channel) {
#if (LIBSSH2_APINO >= 200706012030)
    while ((ret = libssh2_channel_close(sftp->ssh_channel)) ==
           LIBSSH2_ERROR_EAGAIN);
    if (ret < 0) {
      infof(conn->data, "Failed to stop libssh2 channel subsystem\n");
    }
#else /* !(LIBSSH2_APINO >= 200706012030) */
    if (libssh2_channel_close(sftp->ssh_channel) < 0) {
      infof(conn->data, "Failed to stop libssh2 channel subsystem\n");
    }
#endif /* !(LIBSSH2_APINO >= 200706012030) */
  }

  if (sftp->ssh_session) {
#if (LIBSSH2_APINO >= 200706012030)
    while (libssh2_session_disconnect(sftp->ssh_session, "Shutdown") ==
           LIBSSH2_ERROR_EAGAIN);
#else /* !(LIBSSH2_APINO >= 200706012030) */
    libssh2_session_disconnect(sftp->ssh_session, "Shutdown");
#endif /* !(LIBSSH2_APINO >= 200706012030) */
    libssh2_session_free(sftp->ssh_session);
    sftp->ssh_session = NULL;
  }

  free(conn->data->reqdata.proto.ssh);
  conn->data->reqdata.proto.ssh = NULL;
  Curl_pgrsDone(conn);

  (void)status; /* unused */

  return rc;
}

/* return number of received (decrypted) bytes */
ssize_t Curl_sftp_send(struct connectdata *conn, int sockindex,
                       void *mem, size_t len)
{
  ssize_t nwrite;   /* libssh2_sftp_write() used to return size_t in 0.14
                       but is changed to ssize_t in 0.15! */

#if defined(LIBSSH2SFTP_EAGAIN) && (LIBSSH2_APINO < 200706012030)
  /* we prefer the non-blocking API but that didn't exist previously */
  nwrite = (ssize_t)
    libssh2_sftp_writenb(conn->data->reqdata.proto.ssh->sftp_handle, mem, len);
#else
  nwrite = (ssize_t)
    libssh2_sftp_write(conn->data->reqdata.proto.ssh->sftp_handle, mem, len);
#endif
  (void)sockindex;
  return nwrite;
}

/* The get_pathname() function is being borrowed from OpenSSH sftp.c
   version 4.6p1. */
/*
 * Copyright (c) 2001-2004 Damien Miller <djm@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
static int
get_pathname(const char **cpp, char **path)
{
  const char *cp = *cpp, *end;
  char quot;
  u_int i, j;
  static const char * const WHITESPACE = " \t\r\n";

  cp += strspn(cp, WHITESPACE);
  if (!*cp) {
    *cpp = cp;
    *path = NULL;
    return CURLE_FTP_QUOTE_ERROR;
  }

  *path = malloc(strlen(cp) + 1);
  if (*path == NULL)
    return CURLE_OUT_OF_MEMORY;

  /* Check for quoted filenames */
  if (*cp == '\"' || *cp == '\'') {
    quot = *cp++;

    /* Search for terminating quote, unescape some chars */
    for (i = j = 0; i <= strlen(cp); i++) {
      if (cp[i] == quot) {  /* Found quote */
        i++;
        (*path)[j] = '\0';
        break;
      }
      if (cp[i] == '\0') {  /* End of string */
        /*error("Unterminated quote");*/
        goto fail;
      }
      if (cp[i] == '\\') {  /* Escaped characters */
        i++;
        if (cp[i] != '\'' && cp[i] != '\"' &&
            cp[i] != '\\') {
          /*error("Bad escaped character '\\%c'",
              cp[i]);*/
          goto fail;
        }
      }
      (*path)[j++] = cp[i];
    }

    if (j == 0) {
      /*error("Empty quotes");*/
      goto fail;
    }
    *cpp = cp + i + strspn(cp + i, WHITESPACE);
  }
  else {
    /* Read to end of filename */
    end = strpbrk(cp, WHITESPACE);
    if (end == NULL)
      end = strchr(cp, '\0');
    *cpp = end + strspn(end, WHITESPACE);

    memcpy(*path, cp, end - cp);
    (*path)[end - cp] = '\0';
  }
  return (0);

  fail:
    free(*path);
    *path = NULL;
    return CURLE_FTP_QUOTE_ERROR;
}


static const char *sftp_libssh2_strerror(unsigned long err)
{
  switch (err) {
  case LIBSSH2_FX_NO_SUCH_FILE:
    return "No such file or directory";
  case LIBSSH2_FX_PERMISSION_DENIED:
    return "Permission denied";
  case LIBSSH2_FX_FAILURE:
    return "Operation failed";
  case LIBSSH2_FX_BAD_MESSAGE:
    return "Bad message from SFTP server";
  case LIBSSH2_FX_NO_CONNECTION:
    return "Not connected to SFTP server";
  case LIBSSH2_FX_CONNECTION_LOST:
    return "Connection to SFTP server lost";
  case LIBSSH2_FX_OP_UNSUPPORTED:
    return "Operation not supported by SFTP server";
  case LIBSSH2_FX_INVALID_HANDLE:
    return "Invalid handle";
  case LIBSSH2_FX_NO_SUCH_PATH:
    return "No such file or directory";
  case LIBSSH2_FX_FILE_ALREADY_EXISTS:
    return "File already exists";
  case LIBSSH2_FX_WRITE_PROTECT:
    return "File is write protected";
  case LIBSSH2_FX_NO_MEDIA:
    return "No media";
  case LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM:
    return "Disk full";
  case LIBSSH2_FX_QUOTA_EXCEEDED:
    return "User quota exceeded";
  case LIBSSH2_FX_UNKNOWN_PRINCIPLE:
    return "Unknown principle";
  case LIBSSH2_FX_LOCK_CONFlICT:
    return "File lock conflict";
  case LIBSSH2_FX_DIR_NOT_EMPTY:
    return "Directory not empty";
  case LIBSSH2_FX_NOT_A_DIRECTORY:
    return "Not a directory";
  case LIBSSH2_FX_INVALID_FILENAME:
    return "Invalid filename";
  case LIBSSH2_FX_LINK_LOOP:
    return "Link points to itself";
  }
  return "Unknown error in libssh2";
}

/* BLOCKING */
static CURLcode sftp_sendquote(struct connectdata *conn,
                               struct curl_slist *quote)
{
  struct curl_slist *item=quote;
  const char *cp;
  long err;
  struct SessionHandle *data = conn->data;
  LIBSSH2_SFTP *sftp_session = data->reqdata.proto.ssh->sftp_session;
  int ret;

  while (item) {
    if (item->data) {
      char *path1 = NULL;
      char *path2 = NULL;

      /* the arguments following the command must be separated from the
         command with a space so we can check for it unconditionally */
      cp = strchr(item->data, ' ');
      if (cp == NULL) {
        failf(data, "Syntax error in SFTP command. Supply parameter(s)!");
        return CURLE_FTP_QUOTE_ERROR;
      }

      /* also, every command takes at least one argument so we get that first
         argument right now */
      err = get_pathname(&cp, &path1);
      if (err) {
        if (err == CURLE_OUT_OF_MEMORY)
          failf(data, "Out of memory");
        else
          failf(data, "Syntax error: Bad first parameter");
        return err;
      }

      /* SFTP is a binary protocol, so we don't send text commands to the
         server. Instead, we scan for commands for commands used by OpenSSH's
         sftp program and call the appropriate libssh2 functions. */
      if (curl_strnequal(item->data, "chgrp ", 6) ||
          curl_strnequal(item->data, "chmod ", 6) ||
          curl_strnequal(item->data, "chown ", 6) ) { /* attribute change */
        LIBSSH2_SFTP_ATTRIBUTES attrs;

        /* path1 contains the mode to set */
        err = get_pathname(&cp, &path2);  /* get the destination */
        if (err) {
          if (err == CURLE_OUT_OF_MEMORY)
            failf(data, "Out of memory");
          else
            failf(data,
                  "Syntax error in chgrp/chmod/chown: Bad second parameter");
          free(path1);
          return err;
        }
        memset(&attrs, 0, sizeof(LIBSSH2_SFTP_ATTRIBUTES));
        if (libssh2_sftp_stat(sftp_session,
                              path2, &attrs) != 0) { /* get those attributes */
          err = libssh2_sftp_last_error(sftp_session);
          free(path1);
          free(path2);
          failf(data, "Attempt to get SFTP stats failed: %s",
                sftp_libssh2_strerror(err));
          return CURLE_FTP_QUOTE_ERROR;
        }
#if (LIBSSH2_APINO >= 200706012030)
        while ((ret = libssh2_sftp_stat(sftp_session,
                                        path2, &attrs)) ==
               LIBSSH2_ERROR_EAGAIN);
        if (ret != 0) { /* get those attributes */
          err = libssh2_sftp_last_error(sftp_session);
          free(path1);
          free(path2);
          failf(data, "Attempt to get SFTP stats failed: %s",
                sftp_libssh2_strerror(err));
          return CURLE_FTP_QUOTE_ERROR;
        }
#else /* !(LIBSSH2_APINO >= 200706012030) */
        if (libssh2_sftp_stat(sftp_session,
                              path2, &attrs) != 0) { /* get those attributes */
          err = libssh2_sftp_last_error(sftp_session);
          free(path1);
          free(path2);
          failf(data, "Attempt to get SFTP stats failed: %s",
                sftp_libssh2_strerror(err));
          return CURLE_FTP_QUOTE_ERROR;
        }
#endif /* !(LIBSSH2_APINO >= 200706012030) */

        /* Now set the new attributes... */
        if (curl_strnequal(item->data, "chgrp", 5)) {
          attrs.gid = strtol(path1, NULL, 10);
          if (attrs.gid == 0 && !ISDIGIT(path1[0])) {
            free(path1);
            free(path2);
            failf(data, "Syntax error: chgrp gid not a number");
            return CURLE_FTP_QUOTE_ERROR;
          }
        }
        else if (curl_strnequal(item->data, "chmod", 5)) {
          attrs.permissions = strtol(path1, NULL, 8);/* permissions are octal */
          if (attrs.permissions == 0 && !ISDIGIT(path1[0])) {
            free(path1);
            free(path2);
            failf(data, "Syntax error: chmod permissions not a number");
            return CURLE_FTP_QUOTE_ERROR;
          }
        }
        else if (curl_strnequal(item->data, "chown", 5)) {
          attrs.uid = strtol(path1, NULL, 10);
          if (attrs.uid == 0 && !ISDIGIT(path1[0])) {
            free(path1);
            free(path2);
            failf(data, "Syntax error: chown uid not a number");
            return CURLE_FTP_QUOTE_ERROR;
          }
        }

        /* Now send the completed structure... */
#if (LIBSSH2_APINO >= 200706012030)
        while ((ret = libssh2_sftp_setstat(sftp_session, path2, &attrs)) ==
               LIBSSH2_ERROR_EAGAIN);
        if (ret != 0) {
          err = libssh2_sftp_last_error(sftp_session);
          free(path1);
          free(path2);
          failf(data, "Attempt to set SFTP stats failed: %s",
                sftp_libssh2_strerror(err));
          return CURLE_FTP_QUOTE_ERROR;
        }
#else /* !(LIBSSH2_APINO >= 200706012030) */
        if (libssh2_sftp_setstat(sftp_session, path2, &attrs) != 0) {
          err = libssh2_sftp_last_error(sftp_session);
          free(path1);
          free(path2);
          failf(data, "Attempt to set SFTP stats failed: %s",
                sftp_libssh2_strerror(err));
          return CURLE_FTP_QUOTE_ERROR;
        }
#endif /* !(LIBSSH2_APINO >= 200706012030) */
      }
      else if (curl_strnequal(item->data, "ln ", 3) ||
               curl_strnequal(item->data, "symlink ", 8)) {
        /* symbolic linking */
        /* path1 is the source */
        err = get_pathname(&cp, &path2);  /* get the destination */
        if (err) {
          if (err == CURLE_OUT_OF_MEMORY)
            failf(data, "Out of memory");
          else
            failf(data,
                  "Syntax error in ln/symlink: Bad second parameter");
          free(path1);
          return err;
        }
#if (LIBSSH2_APINO >= 200706012030)
        while ((ret = libssh2_sftp_symlink(sftp_session, path1, path2)) ==
               LIBSSH2_ERROR_EAGAIN);
        if (ret != 0) {
          err = libssh2_sftp_last_error(sftp_session);
          free(path1);
          free(path2);
          failf(data, "symlink command failed: %s",
                sftp_libssh2_strerror(err));
          return CURLE_FTP_QUOTE_ERROR;
        }
#else /* !(LIBSSH2_APINO >= 200706012030) */
        if (libssh2_sftp_symlink(sftp_session, path1, path2) != 0) {
          err = libssh2_sftp_last_error(sftp_session);
          free(path1);
          free(path2);
          failf(data, "symlink command failed: %s",
                sftp_libssh2_strerror(err));
          return CURLE_FTP_QUOTE_ERROR;
        }
#endif /* !(LIBSSH2_APINO >= 200706012030) */
      }
      else if (curl_strnequal(item->data, "mkdir ", 6)) { /* create dir */
#if (LIBSSH2_APINO >= 200706012030)
        while ((ret = libssh2_sftp_mkdir(sftp_session, path1, 0744)) ==
               LIBSSH2_ERROR_EAGAIN);
        if (ret != 0) {
          err = libssh2_sftp_last_error(sftp_session);
          free(path1);
          failf(data, "mkdir command failed: %s", sftp_libssh2_strerror(err));
          return CURLE_FTP_QUOTE_ERROR;
        }
#else /* !(LIBSSH2_APINO >= 200706012030) */
        if (libssh2_sftp_mkdir(sftp_session, path1, 0744) != 0) {
          err = libssh2_sftp_last_error(sftp_session);
          free(path1);
          failf(data, "mkdir command failed: %s",
                sftp_libssh2_strerror(err));
          return CURLE_FTP_QUOTE_ERROR;
        }
#endif /* !(LIBSSH2_APINO >= 200706012030) */
      }
      else if (curl_strnequal(item->data, "rename ", 7)) { /* rename file */
        /* first param is the source path */
        err = get_pathname(&cp, &path2);  /* second param is the dest. path */
        if (err) {
          if (err == CURLE_OUT_OF_MEMORY)
            failf(data, "Out of memory");
          else
            failf(data,
                  "Syntax error in rename: Bad second parameter");
          free(path1);
          return err;
        }
#if (LIBSSH2_APINO >= 200706012030)
        while ((ret = libssh2_sftp_rename(sftp_session, path1, path2)) ==
               LIBSSH2_ERROR_EAGAIN);
        if (ret != 0) {
          err = libssh2_sftp_last_error(sftp_session);
          free(path1);
          free(path2);
          failf(data, "rename command failed: %s", sftp_libssh2_strerror(err));
          return CURLE_FTP_QUOTE_ERROR;
        }
#else /* !(LIBSSH2_APINO >= 200706012030) */
        if (libssh2_sftp_rename(sftp_session,
                                path1, path2) != 0) {
          err = libssh2_sftp_last_error(sftp_session);
          free(path1);
          free(path2);
          failf(data, "rename command failed: %s",
                sftp_libssh2_strerror(err));
          return CURLE_FTP_QUOTE_ERROR;
        }
#endif /* !(LIBSSH2_APINO >= 200706012030) */
      }
      else if (curl_strnequal(item->data, "rmdir ", 6)) { /* delete dir */
#if (LIBSSH2_APINO >= 200706012030)
        while ((ret = libssh2_sftp_rmdir(sftp_session, path1)) ==
               LIBSSH2_ERROR_EAGAIN);
        if (ret != 0) {
          err = libssh2_sftp_last_error(sftp_session);
          free(path1);
          failf(data, "rmdir command failed: %s", sftp_libssh2_strerror(err));
          return CURLE_FTP_QUOTE_ERROR;
        }
#else /* !(LIBSSH2_APINO >= 200706012030) */
        if (libssh2_sftp_rmdir(sftp_session,
                               path1) != 0) {
          err = libssh2_sftp_last_error(sftp_session);
          free(path1);
          failf(data, "rmdir command failed: %s",
                sftp_libssh2_strerror(err));
          return CURLE_FTP_QUOTE_ERROR;
        }
#endif /* !(LIBSSH2_APINO >= 200706012030) */
      }
      else if (curl_strnequal(item->data, "rm ", 3)) { /* delete file */
#if (LIBSSH2_APINO >= 200706012030)
        while ((ret = libssh2_sftp_unlink(sftp_session, path1)) ==
               LIBSSH2_ERROR_EAGAIN);
        if (ret != 0) {
          err = libssh2_sftp_last_error(sftp_session);
          free(path1);
          failf(data, "rm command failed: %s", sftp_libssh2_strerror(err));
          return CURLE_FTP_QUOTE_ERROR;
        }
#else /* !(LIBSSH2_APINO >= 200706012030) */
        if (libssh2_sftp_unlink(sftp_session, path1) != 0) {
          err = libssh2_sftp_last_error(sftp_session);
          free(path1);
          failf(data, "rm command failed: %s",
                sftp_libssh2_strerror(err));
          return CURLE_FTP_QUOTE_ERROR;
        }
#endif /* !(LIBSSH2_APINO >= 200706012030) */
      }

      if (path1)
        free(path1);
      if (path2)
        free(path2);
    }
    item = item->next;
  }
  return CURLE_OK;
}


/*
 * If the read would block (EWOULDBLOCK) we return -1. Otherwise we return
 * a regular CURLcode value.
 */
ssize_t Curl_sftp_recv(struct connectdata *conn, int sockindex,
                       char *mem, size_t len)
{
  ssize_t nread;
  (void)sockindex;

  /* libssh2_sftp_read() returns size_t !*/

#if defined(LIBSSH2SFTP_EAGAIN) && (LIBSSH2_APINO < 200706012030)
  /* we prefer the non-blocking API but that didn't exist previously */
  nread = (ssize_t)
    libssh2_sftp_readnb(conn->data->reqdata.proto.ssh->sftp_handle, mem, len);
#else
  nread = (ssize_t)
    libssh2_sftp_read(conn->data->reqdata.proto.ssh->sftp_handle, mem, len);
#endif
  return nread;
}

#endif /* USE_LIBSSH2 */