diff --git a/include/libssh/sftp.h b/include/libssh/sftp.h
index a1aa783a..209973a8 100644
--- a/include/libssh/sftp.h
+++ b/include/libssh/sftp.h
@@ -78,6 +78,7 @@ typedef struct sftp_session_struct* sftp_session;
 typedef struct sftp_status_message_struct* sftp_status_message;
 typedef struct sftp_statvfs_struct* sftp_statvfs_t;
 typedef struct sftp_limits_struct* sftp_limits_t;
+typedef struct sftp_aio_struct* sftp_aio;
 
 struct sftp_session_struct {
     ssh_session session;
@@ -580,6 +581,216 @@ LIBSSH_API int sftp_async_read(sftp_file file, void *data, uint32_t len, uint32_
  */
 LIBSSH_API ssize_t sftp_write(sftp_file file, const void *buf, size_t count);
 
+/**
+ * @brief Deallocate memory corresponding to a sftp aio handle.
+ *
+ * This function deallocates memory corresponding to the aio handle returned
+ * by the sftp_aio_begin_*() functions. Users can use this function to free
+ * memory corresponding to an aio handle for an outstanding async i/o request
+ * on encountering some error.
+ *
+ * @param aio           sftp aio handle corresponding to which memory has
+ *                      to be deallocated.
+ *
+ * @see sftp_aio_begin_read()
+ * @see sftp_aio_wait_read()
+ * @see sftp_aio_begin_write()
+ * @see sftp_aio_wait_write()
+ */
+LIBSSH_API void sftp_aio_free(sftp_aio aio);
+#define SFTP_AIO_FREE(x) \
+    do { if(x != NULL) {sftp_aio_free(x); x = NULL;} } while(0)
+
+/**
+ * @brief Start an asynchronous read from a file using an opened sftp
+ * file handle.
+ *
+ * Its goal is to avoid the slowdowns related to the request/response pattern
+ * of a synchronous read. To do so, you must call 2 functions :
+ *
+ * sftp_aio_begin_read() and sftp_aio_wait_read().
+ *
+ * - The first step is to call sftp_aio_begin_read(). This function sends a
+ *   read request to the sftp server, dynamically allocates memory to store
+ *   information about the sent request and provides the caller an sftp aio
+ *   handle to that memory.
+ *
+ * - The second step is to call sftp_aio_wait_read() and pass it the address
+ *   of a location storing the sftp aio handle provided by
+ *   sftp_aio_begin_read().
+ *
+ * These two functions do not close the open sftp file handle passed to
+ * sftp_aio_begin_read() irrespective of whether they fail or not.
+ *
+ * It is the responsibility of the caller to ensure that the open sftp file
+ * handle passed to sftp_aio_begin_read() must not be closed before the
+ * corresponding call to sftp_aio_wait_read(). After sftp_aio_wait_read()
+ * returns, it is caller's decision whether to immediately close the file by
+ * calling sftp_close() or to keep it open and perform some more operations
+ * on it.
+ *
+ * @param file          The opened sftp file handle to be read from.
+ *
+ * @param len           Number of bytes to read.
+ *
+ * @param aio           Pointer to a location where the sftp aio handle
+ *                      (corresponding to the sent request) should be stored.
+ *
+ * @returns             SSH_OK on success, SSH_ERROR on error with sftp and ssh
+ *                      errors set.
+ *
+ * @warning             When calling this function, the internal offset is
+ *                      updated corresponding to the len parameter.
+ *
+ * @warning             A call to sftp_aio_begin_read() sends a request to
+ *                      the server. When the server answers, libssh allocates
+ *                      memory to store it until sftp_aio_wait_read() is called.
+ *                      Not calling sftp_aio_wait_read() will lead to memory
+ *                      leaks.
+ *
+ * @see                 sftp_aio_wait_read()
+ * @see                 sftp_aio_free()
+ * @see                 sftp_open()
+ * @see                 sftp_close()
+ * @see                 sftp_get_error()
+ * @see                 ssh_get_error()
+ */
+LIBSSH_API int sftp_aio_begin_read(sftp_file file,
+                                   size_t len,
+                                   sftp_aio *aio);
+
+/**
+ * @brief Wait for an asynchronous read to complete and store the read data
+ * in the supplied buffer.
+ *
+ * A pointer to an sftp aio handle should be passed while calling
+ * this function. Except when the return value is SSH_AGAIN,
+ * this function releases the memory corresponding to the supplied
+ * aio handle and assigns NULL to that aio handle using the passed
+ * pointer to that handle.
+ *
+ * If the file is opened in non-blocking mode and the request hasn't been
+ * executed yet, this function returns SSH_AGAIN and must be called again
+ * using the same sftp aio handle.
+ *
+ * @param aio           Pointer to the sftp aio handle returned by
+ *                      sftp_aio_begin_read().
+ *
+ * @param buf           Pointer to the buffer in which read data will be stored.
+ *
+ * @param buf_size      Size of the buffer in bytes. It should be bigger or
+ *                      equal to the length parameter of the
+ *                      sftp_aio_begin_read() call.
+ *
+ * @return              Number of bytes read, 0 on EOF, SSH_ERROR if an error
+ *                      occurred, SSH_AGAIN if the file is opened in nonblocking
+ *                      mode and the request hasn't been executed yet.
+ *
+ * @warning             A call to this function with an invalid sftp aio handle
+ *                      may never return.
+ *
+ * @see sftp_aio_begin_read()
+ * @see sftp_aio_free()
+ */
+LIBSSH_API ssize_t sftp_aio_wait_read(sftp_aio *aio,
+                                      void *buf,
+                                      size_t buf_size);
+
+/**
+ * @brief Start an asynchronous write to a file using an opened sftp
+ * file handle.
+ *
+ * Its goal is to avoid the slowdowns related to the request/response pattern
+ * of a synchronous write. To do so, you must call 2 functions :
+ *
+ * sftp_aio_begin_write() and sftp_aio_wait_write().
+ *
+ * - The first step is to call sftp_aio_begin_write(). This function sends a
+ *   write request to the sftp server, dynamically allocates memory to store
+ *   information about the sent request and provides the caller an sftp aio
+ *   handle to that memory.
+ *
+ * - The second step is to call sftp_aio_wait_write() and pass it the address
+ *   of a location storing the sftp aio handle provided by
+ *   sftp_aio_begin_write().
+ *
+ * These two functions do not close the open sftp file handle passed to
+ * sftp_aio_begin_write() irrespective of whether they fail or not.
+ *
+ * It is the responsibility of the caller to ensure that the open sftp file
+ * handle passed to sftp_aio_begin_write() must not be closed before the
+ * corresponding call to sftp_aio_wait_write(). After sftp_aio_wait_write()
+ * returns, it is caller's decision whether to immediately close the file by
+ * calling sftp_close() or to keep it open and perform some more operations
+ * on it.
+ *
+ * @param file          The opened sftp file handle to write to.
+ *
+ * @param buf           Pointer to the buffer containing data to write.
+ *
+ * @param len           Number of bytes to write.
+ *
+ * @param aio           Pointer to a location where the sftp aio handle
+ *                      (corresponding to the sent request) should be stored.
+ *
+ * @returns             SSH_OK on success, SSH_ERROR with sftp and ssh errors
+ *                      set.
+ *
+ * @warning             When calling this function, the internal offset is
+ *                      updated corresponding to the len parameter.
+ *
+ * @warning             A call to sftp_aio_begin_write() sends a request to
+ *                      the server. When the server answers, libssh allocates
+ *                      memory to store it until sftp_aio_wait_write() is
+ *                      called. Not calling sftp_aio_wait_write() will lead to
+ *                      memory leaks.
+ *
+ * @see                 sftp_aio_wait_write()
+ * @see                 sftp_aio_free()
+ * @see                 sftp_open()
+ * @see                 sftp_close()
+ * @see                 sftp_get_error()
+ * @see                 ssh_get_error()
+ */
+LIBSSH_API int sftp_aio_begin_write(sftp_file file,
+                                    const void *buf,
+                                    size_t len,
+                                    sftp_aio *aio);
+
+/**
+ * @brief Wait for an asynchronous write to complete.
+ *
+ * A pointer to an sftp aio handle should be passed while calling
+ * this function. Except when the return value is SSH_AGAIN,
+ * this function releases the memory corresponding to the supplied
+ * aio handle and assigns NULL to that aio handle using the passed
+ * pointer to that handle.
+ *
+ * If the file is opened in non-blocking mode and the request hasn't
+ * been executed yet, this function returns SSH_AGAIN and must be called
+ * again using the same sftp aio handle.
+ *
+ * On success, this function returns the number of bytes written.
+ * The SFTP protocol doesn't support partial writes to remote files,
+ * hence on success this returned value will always be equal to the
+ * len passed in the previous corresponding call to sftp_aio_begin_write().
+ *
+ * @param aio           Pointer to the sftp aio handle returned by
+ *                      sftp_aio_begin_write().
+ *
+ * @return              Number of bytes written on success, SSH_ERROR
+ *                      if an error occurred, SSH_AGAIN if the file is
+ *                      opened in nonblocking mode and the request hasn't
+ *                      been executed yet.
+ *
+ * @warning             A call to this function with an invalid sftp aio handle
+ *                      may never return.
+ *
+ * @see sftp_aio_begin_write()
+ * @see sftp_aio_free()
+ */
+LIBSSH_API ssize_t sftp_aio_wait_write(sftp_aio *aio);
+
 /**
  * @brief Seek to a specific location in a file.
  *
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 4c54824d..c06cf697 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -253,6 +253,7 @@ if (WITH_SFTP)
     ${libssh_SRCS}
     sftp.c
     sftp_common.c
+    sftp_aio.c
   )
 
   if (WITH_SERVER)
diff --git a/src/libssh.map b/src/libssh.map
index f81d8abe..5797261a 100644
--- a/src/libssh.map
+++ b/src/libssh.map
@@ -464,5 +464,10 @@ LIBSSH_AFTER_4_9_0
     global:
         sftp_channel_default_data_callback;
         sftp_channel_default_subsystem_request;
+        sftp_aio_begin_read;
+        sftp_aio_begin_write;
+        sftp_aio_free;
+        sftp_aio_wait_read;
+        sftp_aio_wait_write;
 } LIBSSH_4_9_0;
 
diff --git a/src/sftp_aio.c b/src/sftp_aio.c
new file mode 100644
index 00000000..d0c0d874
--- /dev/null
+++ b/src/sftp_aio.c
@@ -0,0 +1,490 @@
+/*
+ * sftp_aio.c - Secure FTP functions for asynchronous i/o
+ *
+ * This file is part of the SSH Library
+ *
+ * Copyright (c) 2005-2008 by Aris Adamantiadis
+ * Copyright (c) 2008-2018 by Andreas Schneider <asn@cryptomilk.org>
+ * Copyright (c) 2023 by Eshan Kelkar <eshankelkar@galorithm.com>
+ *
+ * The SSH Library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or (at your
+ * option) any later version.
+ *
+ * The SSH Library is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+ * License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with the SSH Library; see the file COPYING.  If not, write to
+ * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ */
+
+#include "config.h"
+
+#include "libssh/sftp.h"
+#include "libssh/sftp_priv.h"
+#include "libssh/buffer.h"
+#include "libssh/session.h"
+
+#ifdef WITH_SFTP
+
+struct sftp_aio_struct {
+    sftp_file file;
+    uint32_t id;
+    size_t len;
+};
+
+static sftp_aio sftp_aio_new(void)
+{
+    sftp_aio aio = NULL;
+    aio = calloc(1, sizeof(struct sftp_aio_struct));
+    return aio;
+}
+
+void sftp_aio_free(sftp_aio aio)
+{
+    SAFE_FREE(aio);
+}
+
+int sftp_aio_begin_read(sftp_file file, size_t len, sftp_aio *aio)
+{
+    sftp_session sftp = NULL;
+    ssh_buffer buffer = NULL;
+    sftp_aio aio_handle = NULL;
+    uint32_t id;
+    int rc;
+
+    if (file == NULL ||
+        file->sftp == NULL ||
+        file->sftp->session == NULL) {
+        return SSH_ERROR;
+    }
+
+    sftp = file->sftp;
+    if (len == 0) {
+        ssh_set_error(sftp->session, SSH_FATAL,
+                      "Invalid argument, 0 passed as the number of "
+                      "bytes to read");
+        sftp_set_error(sftp, SSH_FX_FAILURE);
+        return SSH_ERROR;
+    }
+
+    if (aio == NULL) {
+        ssh_set_error(sftp->session, SSH_FATAL,
+                      "Invalid argument, NULL passed instead of a pointer to "
+                      "a location to store an sftp aio handle");
+        sftp_set_error(sftp, SSH_FX_FAILURE);
+        return SSH_ERROR;
+    }
+
+    buffer = ssh_buffer_new();
+    if (buffer == NULL) {
+        ssh_set_error_oom(sftp->session);
+        sftp_set_error(sftp, SSH_FX_FAILURE);
+        return SSH_ERROR;
+    }
+
+    id = sftp_get_new_id(sftp);
+
+    rc = ssh_buffer_pack(buffer,
+                         "dSqd",
+                         id,
+                         file->handle,
+                         file->offset,
+                         len);
+
+    if (rc != SSH_OK) {
+        ssh_set_error_oom(sftp->session);
+        sftp_set_error(sftp, SSH_FX_FAILURE);
+        SSH_BUFFER_FREE(buffer);
+        return SSH_ERROR;
+    }
+
+    aio_handle = sftp_aio_new();
+    if (aio_handle == NULL) {
+        ssh_set_error_oom(sftp->session);
+        sftp_set_error(sftp, SSH_FX_FAILURE);
+        SSH_BUFFER_FREE(buffer);
+        return SSH_ERROR;
+    }
+
+    aio_handle->file = file;
+    aio_handle->id = id;
+    aio_handle->len = len;
+
+    rc = sftp_packet_write(sftp, SSH_FXP_READ, buffer);
+    SSH_BUFFER_FREE(buffer);
+    if (rc == SSH_ERROR) {
+        SFTP_AIO_FREE(aio_handle);
+        return SSH_ERROR;
+    }
+
+    /* Assume we read len bytes from the file */
+    file->offset += len;
+    *aio = aio_handle;
+    return SSH_OK;
+}
+
+ssize_t sftp_aio_wait_read(sftp_aio *aio,
+                           void *buf,
+                           size_t buf_size)
+{
+    sftp_file file = NULL;
+    size_t bytes_requested;
+    sftp_session sftp = NULL;
+    sftp_message msg = NULL;
+    sftp_status_message status = NULL;
+    uint32_t string_len, host_len;
+    int rc, err;
+
+    /*
+     * This function releases the memory of the structure
+     * that (*aio) points to in all cases except when the
+     * return value is SSH_AGAIN.
+     *
+     * If the return value is SSH_AGAIN, the user should call this
+     * function again to get the response for the request corresponding
+     * to the structure that (*aio) points to, hence we don't release the
+     * structure's memory when SSH_AGAIN is returned.
+     */
+
+    if (aio == NULL || *aio == NULL) {
+        return SSH_ERROR;
+    }
+
+    file = (*aio)->file;
+    bytes_requested = (*aio)->len;
+
+    if (file == NULL ||
+        file->sftp == NULL ||
+        file->sftp->session == NULL) {
+        SFTP_AIO_FREE(*aio);
+        return SSH_ERROR;
+    }
+
+    sftp = file->sftp;
+    if (bytes_requested == 0) {
+        /* should never happen */
+        ssh_set_error(sftp->session, SSH_FATAL,
+                      "Invalid sftp aio, len for requested i/o is 0");
+        sftp_set_error(sftp, SSH_FX_FAILURE);
+        SFTP_AIO_FREE(*aio);
+        return SSH_ERROR;
+    }
+
+    if (buf == NULL) {
+        ssh_set_error(sftp->session, SSH_FATAL,
+                      "Invalid argument, NULL passed "
+                      "instead of a buffer's address");
+        sftp_set_error(sftp, SSH_FX_FAILURE);
+        SFTP_AIO_FREE(*aio);
+        return SSH_ERROR;
+    }
+
+    if (buf_size < bytes_requested) {
+        ssh_set_error(sftp->session, SSH_FATAL,
+                      "Buffer size (%zu, passed by the caller) is "
+                      "smaller than the number of bytes requested "
+                      "to read (%zu, as per the supplied sftp aio)",
+                      buf_size, bytes_requested);
+        sftp_set_error(sftp, SSH_FX_FAILURE);
+        SFTP_AIO_FREE(*aio);
+        return SSH_ERROR;
+    }
+
+    /* handle an existing request */
+    while (msg == NULL) {
+        if (file->nonblocking) {
+            if (ssh_channel_poll(sftp->channel, 0) == 0) {
+                /* we cannot block */
+                return SSH_AGAIN;
+            }
+        }
+
+        if (sftp_read_and_dispatch(sftp) < 0) {
+            /* something nasty has happened */
+            SFTP_AIO_FREE(*aio);
+            return SSH_ERROR;
+        }
+
+        msg = sftp_dequeue(sftp, (*aio)->id);
+    }
+
+    /*
+     * Release memory for the structure that (*aio) points to
+     * as all further points of return are for success or
+     * failure.
+     */
+    SFTP_AIO_FREE(*aio);
+
+    switch (msg->packet_type) {
+    case SSH_FXP_STATUS:
+        status = parse_status_msg(msg);
+        sftp_message_free(msg);
+        if (status == NULL) {
+            return SSH_ERROR;
+        }
+
+        sftp_set_error(sftp, status->status);
+        if (status->status != SSH_FX_EOF) {
+            ssh_set_error(sftp->session, SSH_REQUEST_DENIED,
+                          "SFTP server : %s", status->errormsg);
+            err = SSH_ERROR;
+        } else {
+            file->eof = 1;
+            /* Update the offset correctly */
+            file->offset = file->offset - bytes_requested;
+            err = SSH_OK;
+        }
+
+        status_msg_free(status);
+        return err;
+
+    case SSH_FXP_DATA:
+        rc = ssh_buffer_get_u32(msg->payload, &string_len);
+        if (rc == 0) {
+            /* Insufficient data in the buffer */
+            ssh_set_error(sftp->session, SSH_FATAL,
+                          "Received invalid DATA packet from sftp server");
+            sftp_set_error(sftp, SSH_FX_BAD_MESSAGE);
+            sftp_message_free(msg);
+            return SSH_ERROR;
+        }
+
+        host_len = ntohl(string_len);
+        if (host_len > buf_size) {
+            /*
+             * This should never happen, as according to the
+             * SFTP protocol the server reads bytes less than
+             * or equal to the number of bytes requested to read.
+             *
+             * And we have checked before that the buffer size is
+             * greater than or equal to the number of bytes requested
+             * to read, hence code of this if block should never
+             * get executed.
+             */
+            ssh_set_error(sftp->session, SSH_FATAL,
+                          "DATA packet (%u bytes) received from sftp server "
+                          "cannot fit into the supplied buffer (%zu bytes)",
+                          host_len, buf_size);
+            sftp_set_error(sftp, SSH_FX_FAILURE);
+            sftp_message_free(msg);
+            return SSH_ERROR;
+        }
+
+        string_len = ssh_buffer_get_data(msg->payload, buf, host_len);
+        if (string_len != host_len) {
+            /* should never happen */
+            ssh_set_error(sftp->session, SSH_FATAL,
+                          "Received invalid DATA packet from sftp server");
+            sftp_set_error(sftp, SSH_FX_BAD_MESSAGE);
+            sftp_message_free(msg);
+            return SSH_ERROR;
+        }
+
+        /* Update the offset with the correct value */
+        file->offset = file->offset - (bytes_requested - string_len);
+        sftp_message_free(msg);
+        return string_len;
+
+    default:
+        ssh_set_error(sftp->session, SSH_FATAL,
+                      "Received message %d during read!", msg->packet_type);
+        sftp_set_error(sftp, SSH_FX_BAD_MESSAGE);
+        sftp_message_free(msg);
+        return SSH_ERROR;
+    }
+
+    return SSH_ERROR; /* not reached */
+}
+
+int sftp_aio_begin_write(sftp_file file,
+                         const void *buf,
+                         size_t len,
+                         sftp_aio *aio)
+{
+    sftp_session sftp = NULL;
+    ssh_buffer buffer = NULL;
+    sftp_aio aio_handle = NULL;
+    uint32_t id;
+    int rc;
+
+    if (file == NULL ||
+        file->sftp == NULL ||
+        file->sftp->session == NULL) {
+        return SSH_ERROR;
+    }
+
+    sftp = file->sftp;
+    if (buf == NULL) {
+        ssh_set_error(sftp->session, SSH_FATAL,
+                      "Invalid argument, NULL passed instead "
+                      "of a buffer's address");
+        sftp_set_error(sftp, SSH_FX_FAILURE);
+        return SSH_ERROR;
+    }
+
+    if (len == 0) {
+        ssh_set_error(sftp->session, SSH_FATAL,
+                      "Invalid argument, 0 passed as the number "
+                      "of bytes to write");
+        sftp_set_error(sftp, SSH_FX_FAILURE);
+        return SSH_ERROR;
+    }
+
+    if (aio == NULL) {
+        ssh_set_error(sftp->session, SSH_FATAL,
+                      "Invalid argument, NULL passed instead of a pointer to "
+                      "a location to store an sftp aio handle");
+        sftp_set_error(sftp, SSH_FX_FAILURE);
+        return SSH_ERROR;
+    }
+
+    buffer = ssh_buffer_new();
+    if (buffer == NULL) {
+        ssh_set_error_oom(sftp->session);
+        sftp_set_error(sftp, SSH_FX_FAILURE);
+        return SSH_ERROR;
+    }
+
+    id = sftp_get_new_id(sftp);
+    rc = ssh_buffer_pack(buffer,
+                         "dSqdP",
+                         id,
+                         file->handle,
+                         file->offset,
+                         len, /* len of datastring */
+                         len, buf);
+
+    if (rc != SSH_OK) {
+        ssh_set_error_oom(sftp->session);
+        sftp_set_error(sftp, SSH_FX_FAILURE);
+        SSH_BUFFER_FREE(buffer);
+        return SSH_ERROR;
+    }
+
+    aio_handle = sftp_aio_new();
+    if (aio_handle == NULL) {
+        ssh_set_error_oom(sftp->session);
+        sftp_set_error(sftp, SSH_FX_FAILURE);
+        SSH_BUFFER_FREE(buffer);
+        return SSH_ERROR;
+    }
+
+    aio_handle->file = file;
+    aio_handle->id = id;
+    aio_handle->len = len;
+
+    rc = sftp_packet_write(sftp, SSH_FXP_WRITE, buffer);
+    SSH_BUFFER_FREE(buffer);
+    if (rc == SSH_ERROR) {
+        SFTP_AIO_FREE(aio_handle);
+        return SSH_ERROR;
+    }
+
+    /* Assume we wrote len bytes to the file */
+    file->offset += len;
+    *aio = aio_handle;
+    return SSH_OK;
+}
+
+ssize_t sftp_aio_wait_write(sftp_aio *aio)
+{
+    sftp_file file = NULL;
+    size_t bytes_requested;
+
+    sftp_session sftp = NULL;
+    sftp_message msg = NULL;
+    sftp_status_message status = NULL;
+
+    /*
+     * This function releases the memory of the structure
+     * that (*aio) points to in all cases except when the
+     * return value is SSH_AGAIN.
+     *
+     * If the return value is SSH_AGAIN, the user should call this
+     * function again to get the response for the request corresponding
+     * to the structure that (*aio) points to, hence we don't release the
+     * structure's memory when SSH_AGAIN is returned.
+     */
+
+    if (aio == NULL || *aio == NULL) {
+        return SSH_ERROR;
+    }
+
+    file = (*aio)->file;
+    bytes_requested = (*aio)->len;
+
+    if (file == NULL ||
+        file->sftp == NULL ||
+        file->sftp->session == NULL) {
+        SFTP_AIO_FREE(*aio);
+        return SSH_ERROR;
+    }
+
+    sftp = file->sftp;
+    if (bytes_requested == 0) {
+        /* This should never happen */
+        ssh_set_error(sftp->session, SSH_FATAL,
+                      "Invalid sftp aio, len for requested i/o is 0");
+        sftp_set_error(sftp, SSH_FX_FAILURE);
+        SFTP_AIO_FREE(*aio);
+        return SSH_ERROR;
+    }
+
+    while (msg == NULL) {
+        if (file->nonblocking) {
+            if (ssh_channel_poll(sftp->channel, 0) == 0) {
+                /* we cannot block */
+                return SSH_AGAIN;
+            }
+        }
+
+        if (sftp_read_and_dispatch(sftp) < 0) {
+            /* something nasty has happened */
+            SFTP_AIO_FREE(*aio);
+            return SSH_ERROR;
+        }
+
+        msg = sftp_dequeue(sftp, (*aio)->id);
+    }
+
+    /*
+     * Release memory for the structure that (*aio) points to
+     * as all further points of return are for success or
+     * failure.
+     */
+    SFTP_AIO_FREE(*aio);
+
+    if (msg->packet_type == SSH_FXP_STATUS) {
+        status = parse_status_msg(msg);
+        sftp_message_free(msg);
+        if (status == NULL) {
+            return SSH_ERROR;
+        }
+
+        sftp_set_error(sftp, status->status);
+        if (status->status == SSH_FX_OK) {
+            status_msg_free(status);
+            return bytes_requested;
+        }
+
+        ssh_set_error(sftp->session, SSH_REQUEST_DENIED,
+                      "SFTP server: %s", status->errormsg);
+        status_msg_free(status);
+        return SSH_ERROR;
+    }
+
+    ssh_set_error(sftp->session, SSH_FATAL,
+                  "Received message %d during write!",
+                  msg->packet_type);
+    sftp_message_free(msg);
+    sftp_set_error(sftp, SSH_FX_BAD_MESSAGE);
+    return SSH_ERROR;
+}
+
+#endif /* WITH_SFTP */