/* Copyright (c) 2004-2007, Sara Golemon * All rights reserved. * * Redistribution and use in source and binary forms, * with or without modification, are permitted provided * that the following conditions are met: * * Redistributions of source code must retain the above * copyright notice, this list of conditions and the * following disclaimer. * * Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials * provided with the distribution. * * Neither the name of the copyright holder nor the names * of any other contributors may be used to endorse or * promote products derived from this software without * specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY * OF SUCH DAMAGE. */ #include "libssh2_priv.h" #include "libssh2_sftp.h" /* Note: Version 6 was documented at the time of writing * However it was marked as "DO NOT IMPLEMENT" due to pending changes * * This release of libssh2 implements Version 5 with automatic downgrade * based on server's declaration */ /* SFTP packet types */ #define SSH_FXP_INIT 1 #define SSH_FXP_VERSION 2 #define SSH_FXP_OPEN 3 #define SSH_FXP_CLOSE 4 #define SSH_FXP_READ 5 #define SSH_FXP_WRITE 6 #define SSH_FXP_LSTAT 7 #define SSH_FXP_FSTAT 8 #define SSH_FXP_SETSTAT 9 #define SSH_FXP_FSETSTAT 10 #define SSH_FXP_OPENDIR 11 #define SSH_FXP_READDIR 12 #define SSH_FXP_REMOVE 13 #define SSH_FXP_MKDIR 14 #define SSH_FXP_RMDIR 15 #define SSH_FXP_REALPATH 16 #define SSH_FXP_STAT 17 #define SSH_FXP_RENAME 18 #define SSH_FXP_READLINK 19 #define SSH_FXP_SYMLINK 20 #define SSH_FXP_STATUS 101 #define SSH_FXP_HANDLE 102 #define SSH_FXP_DATA 103 #define SSH_FXP_NAME 104 #define SSH_FXP_ATTRS 105 #define SSH_FXP_EXTENDED 200 #define SSH_FXP_EXTENDED_REPLY 201 #define LIBSSH2_SFTP_HANDLE_FILE 0 #define LIBSSH2_SFTP_HANDLE_DIR 1 /* S_IFREG */ #define LIBSSH2_SFTP_ATTR_PFILETYPE_FILE 0100000 /* S_IFDIR */ #define LIBSSH2_SFTP_ATTR_PFILETYPE_DIR 0040000 /* {{{ libssh2_sftp_packet_add * Add a packet to the SFTP packet brigade */ static int libssh2_sftp_packet_add(LIBSSH2_SFTP * sftp, unsigned char *data, unsigned long data_len) { LIBSSH2_SESSION *session = sftp->channel->session; LIBSSH2_PACKET *packet; _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Received packet %d", (int) data[0]); packet = LIBSSH2_ALLOC(session, sizeof(LIBSSH2_PACKET)); if (!packet) { libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate datablock for SFTP packet", 0); return -1; } memset(packet, 0, sizeof(LIBSSH2_PACKET)); packet->data = data; packet->data_len = data_len; packet->data_head = 5; packet->brigade = &sftp->packets; packet->next = NULL; packet->prev = sftp->packets.tail; if (packet->prev) { packet->prev->next = packet; } else { sftp->packets.head = packet; } sftp->packets.tail = packet; return 0; } /* }}} */ /* {{{ libssh2_sftp_packet_read * Frame an SFTP packet off the channel */ static int libssh2_sftp_packet_read(LIBSSH2_SFTP * sftp, int flush) { LIBSSH2_CHANNEL *channel = sftp->channel; LIBSSH2_SESSION *session = channel->session; unsigned char buffer[4]; /* To store the packet length */ unsigned char *packet; unsigned long packet_len, packet_received; ssize_t bytes_received; int rc; _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Waiting for packet"); if (flush && sftp->partial_packet) { /* When flushing, remove previous partial */ LIBSSH2_FREE(session, sftp->partial_packet); sftp->partial_packet = NULL; } /* If there was a previous partial, start using it */ if (sftp->partial_packet) { packet = sftp->partial_packet; packet_len = sftp->partial_len; packet_received = sftp->partial_received; sftp->partial_packet = NULL; } else { if (flush && session->socket_block && !libssh2_waitsocket(session, 0)) { /* While flushing in blocking mode, check before reading */ return -1; } rc = libssh2_channel_read_ex(channel, 0, (char *) buffer, 4); if (flush && (rc < 0)) { /* When flushing, exit quickly */ return -1; } else if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (4 != rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, "Timeout waiting for FXP packet", 0); return -1; } packet_len = libssh2_ntohu32(buffer); _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Data begin - Packet Length: %lu", packet_len); if (packet_len > LIBSSH2_SFTP_PACKET_MAXLEN) { libssh2_error(session, LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED, "SFTP packet too large", 0); return -1; } packet = LIBSSH2_ALLOC(session, packet_len); if (!packet) { libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate SFTP packet", 0); return -1; } packet_received = 0; } /* Read as much of the packet as we can */ while (packet_len > packet_received) { bytes_received = libssh2_channel_read_ex(channel, 0, (char *) packet + packet_received, packet_len - packet_received); if (flush && (bytes_received < 0)) { if (packet) { /* When flushing, remove packet if existing */ LIBSSH2_FREE(session, packet); } /* When flushing, exit quickly */ return -1; } else if (bytes_received == PACKET_EAGAIN) { /* * We received EAGAIN, save what we have and * return to EAGAIN to the caller */ sftp->partial_packet = packet; sftp->partial_len = packet_len; sftp->partial_received = packet_received; packet = NULL; return PACKET_EAGAIN; } else if (bytes_received < 0) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, "Receive error waiting for SFTP packet", 0); LIBSSH2_FREE(session, packet); return -1; } packet_received += bytes_received; } if (libssh2_sftp_packet_add(sftp, packet, packet_len)) { LIBSSH2_FREE(session, packet); return -1; } return packet[0]; } /* }}} */ /* {{{ libssh2_sftp_packet_ask * A la libssh2_packet_ask() */ static int libssh2_sftp_packet_ask(LIBSSH2_SFTP * sftp, unsigned char packet_type, unsigned long request_id, unsigned char **data, unsigned long *data_len, int poll_channel) { LIBSSH2_SESSION *session = sftp->channel->session; LIBSSH2_PACKET *packet = sftp->packets.head; unsigned char match_buf[5]; int match_len = 5; _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Asking for %d packet", (int) packet_type); if (poll_channel) { int ret = libssh2_sftp_packet_read(sftp, 0); if (ret == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (ret < 0) { return -1; } } match_buf[0] = packet_type; if (packet_type == SSH_FXP_VERSION) { /* Special consideration when matching VERSION packet */ match_len = 1; } else { libssh2_htonu32(match_buf + 1, request_id); } while (packet) { if (strncmp((char *) packet->data, (char *) match_buf, match_len) == 0) { *data = packet->data; *data_len = packet->data_len; if (packet->prev) { packet->prev->next = packet->next; } else { sftp->packets.head = packet->next; } if (packet->next) { packet->next->prev = packet->prev; } else { sftp->packets.tail = packet->prev; } LIBSSH2_FREE(session, packet); return 0; } packet = packet->next; } return -1; } /* }}} */ /* {{{ libssh2_sftp_packet_require * A la libssh2_packet_require */ static int libssh2_sftp_packet_require(LIBSSH2_SFTP * sftp, unsigned char packet_type, unsigned long request_id, unsigned char **data, unsigned long *data_len) { LIBSSH2_SESSION *session = sftp->channel->session; int ret; _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Requiring %d packet", (int) packet_type); if (libssh2_sftp_packet_ask (sftp, packet_type, request_id, data, data_len, 0) == 0) { /* The right packet was available in the packet brigade */ return 0; } while (session->socket_state == LIBSSH2_SOCKET_CONNECTED) { ret = libssh2_sftp_packet_read(sftp, 0); if (ret == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (ret <= 0) { return -1; } if (packet_type == ret) { /* Be lazy, let packet_ask pull it out of the brigade */ return libssh2_sftp_packet_ask(sftp, packet_type, request_id, data, data_len, 0); } } /* Only reached if the socket died */ return -1; } /* }}} */ /* {{{ libssh2_sftp_packet_requirev * Requie one of N possible reponses */ static int libssh2_sftp_packet_requirev(LIBSSH2_SFTP * sftp, int num_valid_responses, const unsigned char *valid_responses, unsigned long request_id, unsigned char **data, unsigned long *data_len) { int i; int ret; /* * If no timeout is active, start a new one and flush * any pending packets */ if (sftp->requirev_start == 0) { _libssh2_debug(sftp->channel->session, LIBSSH2_DBG_SFTP, "_requirev(): Initialize timeout"); sftp->requirev_start = time(NULL); /* Flush */ while (libssh2_sftp_packet_read(sftp, 1) > 0); } while (sftp->channel->session->socket_state == LIBSSH2_SOCKET_CONNECTED) { for(i = 0; i < num_valid_responses; i++) { if (libssh2_sftp_packet_ask (sftp, valid_responses[i], request_id, data, data_len, 0) == 0) { /* * Set to zero before all returns to say * the timeout is not active */ sftp->requirev_start = 0; return 0; } } ret = libssh2_sftp_packet_read(sftp, 0); if ((ret < 0) && (ret != PACKET_EAGAIN)) { sftp->requirev_start = 0; return -1; } else if (ret <= 0) { /* prevent busy-looping */ long left = LIBSSH2_READ_TIMEOUT - (time(NULL) - sftp->requirev_start); if (left <= 0) { sftp->requirev_start = 0; return PACKET_TIMEOUT; } else if (sftp->channel->session->socket_block && (libssh2_waitsocket(sftp->channel->session, left) <= 0)) { sftp->requirev_start = 0; return PACKET_TIMEOUT; } else if (ret == PACKET_EAGAIN) { return PACKET_EAGAIN; } } } sftp->requirev_start = 0; return -1; } /* }}} */ /* {{{ libssh2_sftp_attrsize * Size that attr will occupy when turned into a bin struct */ static int libssh2_sftp_attrsize(const LIBSSH2_SFTP_ATTRIBUTES * attrs) { int attrsize = 4; /* flags(4) */ if (!attrs) { return attrsize; } if (attrs->flags & LIBSSH2_SFTP_ATTR_SIZE) attrsize += 8; if (attrs->flags & LIBSSH2_SFTP_ATTR_UIDGID) attrsize += 8; if (attrs->flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) attrsize += 4; if (attrs->flags & LIBSSH2_SFTP_ATTR_ACMODTIME) attrsize += 8; /* atime + mtime as u32 */ return attrsize; } /* }}} */ /* {{{ libssh2_sftp_attr2bin * Populate attributes into an SFTP block */ static int libssh2_sftp_attr2bin(unsigned char *p, const LIBSSH2_SFTP_ATTRIBUTES * attrs) { unsigned char *s = p; unsigned long flag_mask = LIBSSH2_SFTP_ATTR_SIZE | LIBSSH2_SFTP_ATTR_UIDGID | LIBSSH2_SFTP_ATTR_PERMISSIONS | LIBSSH2_SFTP_ATTR_ACMODTIME; /* TODO: When we add SFTP4+ functionality flag_mask can get additional bits */ if (!attrs) { libssh2_htonu32(s, 0); return 4; } libssh2_htonu32(s, attrs->flags & flag_mask); s += 4; if (attrs->flags & LIBSSH2_SFTP_ATTR_SIZE) { libssh2_htonu64(s, attrs->filesize); s += 8; } if (attrs->flags & LIBSSH2_SFTP_ATTR_UIDGID) { libssh2_htonu32(s, attrs->uid); s += 4; libssh2_htonu32(s, attrs->gid); s += 4; } if (attrs->flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) { libssh2_htonu32(s, attrs->permissions); s += 4; } if (attrs->flags & LIBSSH2_SFTP_ATTR_ACMODTIME) { libssh2_htonu32(s, attrs->atime); s += 4; libssh2_htonu32(s, attrs->mtime); s += 4; } return (s - p); } /* }}} */ /* {{{ libssh2_sftp_bin2attr */ static int libssh2_sftp_bin2attr(LIBSSH2_SFTP_ATTRIBUTES * attrs, const unsigned char *p) { const unsigned char *s = p; memset(attrs, 0, sizeof(LIBSSH2_SFTP_ATTRIBUTES)); attrs->flags = libssh2_ntohu32(s); s += 4; if (attrs->flags & LIBSSH2_SFTP_ATTR_SIZE) { attrs->filesize = libssh2_ntohu64(s); s += 8; } if (attrs->flags & LIBSSH2_SFTP_ATTR_UIDGID) { attrs->uid = libssh2_ntohu32(s); s += 4; attrs->gid = libssh2_ntohu32(s); s += 4; } if (attrs->flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) { attrs->permissions = libssh2_ntohu32(s); s += 4; } if (attrs->flags & LIBSSH2_SFTP_ATTR_ACMODTIME) { attrs->atime = libssh2_ntohu32(s); s += 4; attrs->mtime = libssh2_ntohu32(s); s += 4; } return (s - p); } /* }}} */ /* ************ * SFTP API * ************ */ LIBSSH2_CHANNEL_CLOSE_FUNC(libssh2_sftp_dtor); /* {{{ libssh2_sftp_dtor * Shutdown an SFTP stream when the channel closes */ LIBSSH2_CHANNEL_CLOSE_FUNC(libssh2_sftp_dtor) { LIBSSH2_SFTP *sftp = (LIBSSH2_SFTP *) (*channel_abstract); (void) session_abstract; (void) channel; /* Loop through handles closing them */ while (sftp->handles) { libssh2_sftp_close_handle(sftp->handles); } /* Free the partial packet storage for libssh2_sftp_packet_read */ if (sftp->partial_packet) { LIBSSH2_FREE(session, sftp->partial_packet); } /* Free the packet storage for _libssh2_sftp_packet_readdir */ if (sftp->readdir_packet) { LIBSSH2_FREE(session, sftp->readdir_packet); } LIBSSH2_FREE(session, sftp); } /* }}} */ /* {{{ libssh2_sftp_init * Startup an SFTP session * * NOTE: Will block in a busy loop on error. This has to be done, * otherwise the blocking error code would erase the true * cause of the error. */ LIBSSH2_API LIBSSH2_SFTP * libssh2_sftp_init(LIBSSH2_SESSION * session) { unsigned char *data, *s; unsigned long data_len; int rc; if (session->sftpInit_state == libssh2_NB_state_idle) { _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Initializing SFTP subsystem"); session->sftpInit_sftp = NULL; session->sftpInit_state = libssh2_NB_state_created; } if (session->sftpInit_state == libssh2_NB_state_created) { session->sftpInit_channel = libssh2_channel_open_ex(session, "session", sizeof("session") - 1, LIBSSH2_CHANNEL_WINDOW_DEFAULT, LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL, 0); if (!session->sftpInit_channel) { if (libssh2_session_last_errno(session) == LIBSSH2_ERROR_EAGAIN) { libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block starting up channel", 0); return NULL; } else if (libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) { libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE, "Unable to startup channel", 0); session->sftpInit_state = libssh2_NB_state_idle; return NULL; } } session->sftpInit_state = libssh2_NB_state_sent; } if (session->sftpInit_state == libssh2_NB_state_sent) { rc = libssh2_channel_process_startup(session->sftpInit_channel, "subsystem", sizeof("subsystem") - 1, "sftp", strlen("sftp")); if (rc == PACKET_EAGAIN) { libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block to request SFTP subsystem", 0); return NULL; } else if (rc) { libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE, "Unable to request SFTP subsystem", 0); goto sftp_init_error; } session->sftpInit_state = libssh2_NB_state_sent1; } if (session->sftpInit_state == libssh2_NB_state_sent1) { rc = libssh2_channel_handle_extended_data2(session->sftpInit_channel, LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE); if (rc == PACKET_EAGAIN) { libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block requesting handle extended data", 0); return NULL; } session->sftpInit_sftp = LIBSSH2_ALLOC(session, sizeof(LIBSSH2_SFTP)); if (!session->sftpInit_sftp) { libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate a new SFTP structure", 0); goto sftp_init_error; } memset(session->sftpInit_sftp, 0, sizeof(LIBSSH2_SFTP)); session->sftpInit_sftp->channel = session->sftpInit_channel; session->sftpInit_sftp->request_id = 0; libssh2_htonu32(session->sftpInit_buffer, 5); session->sftpInit_buffer[4] = SSH_FXP_INIT; libssh2_htonu32(session->sftpInit_buffer + 5, LIBSSH2_SFTP_VERSION); _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Sending FXP_INIT packet advertising version %d support", (int) LIBSSH2_SFTP_VERSION); session->sftpInit_state = libssh2_NB_state_sent2; } if (session->sftpInit_state == libssh2_NB_state_sent2) { rc = libssh2_channel_write_ex(session->sftpInit_channel, 0, (char *) session->sftpInit_buffer, 9); if (rc == PACKET_EAGAIN) { libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block sending SSH_FXP_INIT", 0); return NULL; } else if (9 != rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send SSH_FXP_INIT", 0); goto sftp_init_error; } session->sftpInit_state = libssh2_NB_state_sent3; } /* For initiallization we are requiring blocking, probably reasonable */ rc = libssh2_sftp_packet_require(session->sftpInit_sftp, SSH_FXP_VERSION, 0, &data, &data_len); if (rc == PACKET_EAGAIN) { libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block waiting for response from SFTP subsystem", 0); return NULL; } else if (rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, "Timeout waiting for response from SFTP subsystem", 0); goto sftp_init_error; } if (data_len < 5) { libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, "Invalid SSH_FXP_VERSION response", 0); goto sftp_init_error; } s = data + 1; session->sftpInit_sftp->version = libssh2_ntohu32(s); s += 4; if (session->sftpInit_sftp->version > LIBSSH2_SFTP_VERSION) { _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Truncating remote SFTP version from %lu", session->sftpInit_sftp->version); session->sftpInit_sftp->version = LIBSSH2_SFTP_VERSION; } _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Enabling SFTP version %lu compatability", session->sftpInit_sftp->version); while (s < (data + data_len)) { unsigned char *extension_name, *extension_data; unsigned long extname_len, extdata_len; extname_len = libssh2_ntohu32(s); s += 4; extension_name = s; s += extname_len; extdata_len = libssh2_ntohu32(s); s += 4; extension_data = s; s += extdata_len; /* TODO: Actually process extensions */ } LIBSSH2_FREE(session, data); /* Make sure that when the channel gets closed, the SFTP service is shut down too */ session->sftpInit_sftp->channel->abstract = session->sftpInit_sftp; session->sftpInit_sftp->channel->close_cb = libssh2_sftp_dtor; session->sftpInit_state = libssh2_NB_state_idle; return session->sftpInit_sftp; sftp_init_error: while (libssh2_channel_free(session->sftpInit_channel) == PACKET_EAGAIN); session->sftpInit_channel = NULL; if (session->sftpInit_sftp) { LIBSSH2_FREE(session, session->sftpInit_sftp); session->sftpInit_sftp = NULL; } session->sftpInit_state = libssh2_NB_state_idle; return NULL; } /* }}} */ /* {{{ libssh2_sftp_shutdown * Shutsdown the SFTP subsystem */ LIBSSH2_API int libssh2_sftp_shutdown(LIBSSH2_SFTP * sftp) { /* * Make sure all memory used in the state variables are free */ if (sftp->partial_packet) { LIBSSH2_FREE(sftp->channel->session, sftp->partial_packet); sftp->partial_packet = NULL; } if (sftp->open_packet) { LIBSSH2_FREE(sftp->channel->session, sftp->open_packet); sftp->open_packet = NULL; } if (sftp->read_packet) { LIBSSH2_FREE(sftp->channel->session, sftp->read_packet); sftp->read_packet = NULL; } if (sftp->readdir_packet) { LIBSSH2_FREE(sftp->channel->session, sftp->readdir_packet); sftp->readdir_packet = NULL; } if (sftp->write_packet) { LIBSSH2_FREE(sftp->channel->session, sftp->write_packet); sftp->write_packet = NULL; } if (sftp->fstat_packet) { LIBSSH2_FREE(sftp->channel->session, sftp->fstat_packet); sftp->fstat_packet = NULL; } if (sftp->unlink_packet) { LIBSSH2_FREE(sftp->channel->session, sftp->unlink_packet); sftp->unlink_packet = NULL; } if (sftp->rename_packet) { LIBSSH2_FREE(sftp->channel->session, sftp->rename_packet); sftp->rename_packet = NULL; } if (sftp->mkdir_packet) { LIBSSH2_FREE(sftp->channel->session, sftp->mkdir_packet); sftp->mkdir_packet = NULL; } if (sftp->rmdir_packet) { LIBSSH2_FREE(sftp->channel->session, sftp->rmdir_packet); sftp->rmdir_packet = NULL; } if (sftp->stat_packet) { LIBSSH2_FREE(sftp->channel->session, sftp->stat_packet); sftp->stat_packet = NULL; } if (sftp->symlink_packet) { LIBSSH2_FREE(sftp->channel->session, sftp->symlink_packet); sftp->symlink_packet = NULL; } return libssh2_channel_free(sftp->channel); } /* }}} */ /* ******************************* * SFTP File and Directory Ops * ******************************* */ /* {{{ libssh2_sftp_open_ex */ LIBSSH2_API LIBSSH2_SFTP_HANDLE * libssh2_sftp_open_ex(LIBSSH2_SFTP * sftp, const char *filename, unsigned int filename_len, unsigned long flags, long mode, int open_type) { LIBSSH2_CHANNEL *channel = sftp->channel; LIBSSH2_SESSION *session = channel->session; LIBSSH2_SFTP_HANDLE *fp; LIBSSH2_SFTP_ATTRIBUTES attrs = { LIBSSH2_SFTP_ATTR_PERMISSIONS, 0, 0, 0, 0, 0, 0 }; unsigned long data_len; unsigned char *data, *s; static const unsigned char fopen_responses[2] = { SSH_FXP_HANDLE, SSH_FXP_STATUS }; int rc; if (sftp->open_state == libssh2_NB_state_idle) { /* packet_len(4) + packet_type(1) + request_id(4) + filename_len(4) + flags(4) */ sftp->open_packet_len = filename_len + 13 + ((open_type == LIBSSH2_SFTP_OPENFILE) ? (4 + libssh2_sftp_attrsize(&attrs)) : 0); s = sftp->open_packet = LIBSSH2_ALLOC(session, sftp->open_packet_len); if (!sftp->open_packet) { libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for FXP_OPEN or FXP_OPENDIR packet", 0); return NULL; } /* Filetype in SFTP 3 and earlier */ attrs.permissions = mode | ((open_type == LIBSSH2_SFTP_OPENFILE) ? LIBSSH2_SFTP_ATTR_PFILETYPE_FILE : LIBSSH2_SFTP_ATTR_PFILETYPE_DIR); libssh2_htonu32(s, sftp->open_packet_len - 4); s += 4; *(s++) = (open_type == LIBSSH2_SFTP_OPENFILE) ? SSH_FXP_OPEN : SSH_FXP_OPENDIR; sftp->open_request_id = sftp->request_id++; libssh2_htonu32(s, sftp->open_request_id); s += 4; libssh2_htonu32(s, filename_len); s += 4; memcpy(s, filename, filename_len); s += filename_len; if (open_type == LIBSSH2_SFTP_OPENFILE) { libssh2_htonu32(s, flags); s += 4; s += libssh2_sftp_attr2bin(s, &attrs); } _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Sending %s open request", (open_type == LIBSSH2_SFTP_OPENFILE) ? "file" : "directory"); sftp->open_state = libssh2_NB_state_created; } if (sftp->open_state == libssh2_NB_state_created) { rc = libssh2_channel_write_ex(channel, 0, (char *) sftp->open_packet, sftp->open_packet_len); if (rc == PACKET_EAGAIN) { libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block sending FXP_OPEN or FXP_OPENDIR command", 0); return NULL; } else if (sftp->open_packet_len != rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send FXP_OPEN or FXP_OPENDIR command", 0); LIBSSH2_FREE(session, sftp->open_packet); sftp->open_packet = NULL; sftp->open_state = libssh2_NB_state_idle; return NULL; } LIBSSH2_FREE(session, sftp->open_packet); sftp->open_packet = NULL; sftp->open_state = libssh2_NB_state_sent; } if (sftp->open_state == libssh2_NB_state_sent) { rc = libssh2_sftp_packet_requirev(sftp, 2, fopen_responses, sftp->open_request_id, &data, &data_len); if (rc == PACKET_EAGAIN) { libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block waiting for status message", 0); return NULL; } else if (rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, "Timeout waiting for status message", 0); sftp->open_state = libssh2_NB_state_idle; return NULL; } } sftp->open_state = libssh2_NB_state_idle; if (data[0] == SSH_FXP_STATUS) { libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, "Failed opening remote file", 0); sftp->last_errno = libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); return NULL; } fp = LIBSSH2_ALLOC(session, sizeof(LIBSSH2_SFTP_HANDLE)); if (!fp) { libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate new SFTP handle structure", 0); LIBSSH2_FREE(session, data); return NULL; } memset(fp, 0, sizeof(LIBSSH2_SFTP_HANDLE)); fp->handle_type = (open_type == LIBSSH2_SFTP_OPENFILE) ? LIBSSH2_SFTP_HANDLE_FILE : LIBSSH2_SFTP_HANDLE_DIR; fp->handle_len = libssh2_ntohu32(data + 5); if (fp->handle_len > 256) { /* SFTP doesn't allow handles longer than 256 characters */ fp->handle_len = 256; } fp->handle = LIBSSH2_ALLOC(session, fp->handle_len); if (!fp->handle) { libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate space for SFTP file/dir handle", 0); LIBSSH2_FREE(session, data); LIBSSH2_FREE(session, fp); return NULL; } memcpy(fp->handle, data + 9, fp->handle_len); LIBSSH2_FREE(session, data); /* Link the file and the sftp session together */ fp->next = sftp->handles; if (fp->next) { fp->next->prev = fp; } fp->sftp = sftp; fp->u.file.offset = 0; _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Open command successful"); return fp; } /* }}} */ /* {{{ libssh2_sftp_read * Read from an SFTP file handle */ LIBSSH2_API ssize_t libssh2_sftp_read(LIBSSH2_SFTP_HANDLE * handle, char *buffer, size_t buffer_maxlen) { LIBSSH2_SFTP *sftp = handle->sftp; LIBSSH2_CHANNEL *channel = sftp->channel; LIBSSH2_SESSION *session = channel->session; unsigned long data_len, request_id; /* 25 = packet_len(4) + packet_type(1) + request_id(4) + handle_len(4) + offset(8) + length(4) */ ssize_t packet_len = handle->handle_len + 25; unsigned char *packet, *s, *data; static const unsigned char read_responses[2] = { SSH_FXP_DATA, SSH_FXP_STATUS }; size_t bytes_read = 0; size_t bytes_requested = 0; size_t total_read = 0; int retcode; if (sftp->read_state == libssh2_NB_state_idle) { _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Reading %lu bytes from SFTP handle", (unsigned long) buffer_maxlen); packet = LIBSSH2_ALLOC(session, packet_len); if (!packet) { libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for FXP_CLOSE packet", 0); return -1; } sftp->read_state = libssh2_NB_state_allocated; } else { packet = sftp->read_packet; request_id = sftp->read_request_id; total_read = sftp->read_total_read; } while (total_read < buffer_maxlen) { s = packet; /* * If buffer_maxlen bytes will be requested, server may return all * with one packet. But libssh2 have packet length limit. * So we request data by pieces. */ bytes_requested = buffer_maxlen - total_read; /* 10 = packet_type(1)+request_id(4)+data_length(4)+end_of_line_flag(1) */ if (bytes_requested > LIBSSH2_SFTP_PACKET_MAXLEN - 10) { bytes_requested = LIBSSH2_SFTP_PACKET_MAXLEN - 10; } #ifdef LIBSSH2_DEBUG_SFTP _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Requesting %lu bytes from SFTP handle", (unsigned long) bytes_requested); #endif if (sftp->read_state == libssh2_NB_state_allocated) { libssh2_htonu32(s, packet_len - 4); s += 4; *(s++) = SSH_FXP_READ; request_id = sftp->request_id++; libssh2_htonu32(s, request_id); s += 4; libssh2_htonu32(s, handle->handle_len); s += 4; memcpy(s, handle->handle, handle->handle_len); s += handle->handle_len; libssh2_htonu64(s, handle->u.file.offset); s += 8; libssh2_htonu32(s, buffer_maxlen); s += 4; sftp->read_state = libssh2_NB_state_created; } if (sftp->read_state == libssh2_NB_state_created) { retcode = libssh2_channel_write_ex(channel, 0, (char *) packet, packet_len); if (retcode == PACKET_EAGAIN) { sftp->read_packet = packet; sftp->read_request_id = request_id; sftp->read_total_read = total_read; return PACKET_EAGAIN; } else if (packet_len != retcode) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send FXP_READ command", 0); LIBSSH2_FREE(session, packet); sftp->read_packet = NULL; sftp->read_state = libssh2_NB_state_idle; return -1; } sftp->read_packet = packet; sftp->read_request_id = request_id; sftp->read_total_read = total_read; sftp->read_state = libssh2_NB_state_sent; } if (sftp->read_state == libssh2_NB_state_sent) { retcode = libssh2_sftp_packet_requirev(sftp, 2, read_responses, request_id, &data, &data_len); if (retcode == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (retcode) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, "Timeout waiting for status message", 0); LIBSSH2_FREE(session, packet); sftp->read_packet = NULL; sftp->read_state = libssh2_NB_state_idle; return -1; } sftp->read_state = libssh2_NB_state_sent1; } switch (data[0]) { case SSH_FXP_STATUS: retcode = libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, packet); LIBSSH2_FREE(session, data); sftp->read_packet = NULL; sftp->read_state = libssh2_NB_state_idle; if (retcode == LIBSSH2_FX_EOF) { return total_read; } else { sftp->last_errno = retcode; libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, "SFTP Protocol Error", 0); return -1; } case SSH_FXP_DATA: bytes_read = libssh2_ntohu32(data + 5); if (bytes_read > (data_len - 9)) { LIBSSH2_FREE(session, packet); sftp->read_packet = NULL; sftp->read_state = libssh2_NB_state_idle; return -1; } #ifdef LIBSSH2_DEBUG_SFTP _libssh2_debug(session, LIBSSH2_DBG_SFTP, "%lu bytes returned", (unsigned long) bytes_read); #endif memcpy(buffer + total_read, data + 9, bytes_read); handle->u.file.offset += bytes_read; total_read += bytes_read; LIBSSH2_FREE(session, data); /* * Set the state back to allocated, so a new one will be * created to either request more data or get EOF */ sftp->read_state = libssh2_NB_state_allocated; } } LIBSSH2_FREE(session, packet); sftp->read_packet = NULL; sftp->read_state = libssh2_NB_state_idle; return total_read; } /* }}} */ /* {{{ libssh2_sftp_readdir * Read from an SFTP directory handle */ LIBSSH2_API int libssh2_sftp_readdir_ex(LIBSSH2_SFTP_HANDLE * handle, char *buffer, size_t buffer_maxlen, char *longentry, size_t longentry_maxlen, LIBSSH2_SFTP_ATTRIBUTES * attrs) { LIBSSH2_SFTP *sftp = handle->sftp; LIBSSH2_CHANNEL *channel = sftp->channel; LIBSSH2_SESSION *session = channel->session; LIBSSH2_SFTP_ATTRIBUTES attrs_dummy; unsigned long data_len, filename_len, longentry_len, num_names; /* 13 = packet_len(4) + packet_type(1) + request_id(4) + handle_len(4) */ ssize_t packet_len = handle->handle_len + 13; unsigned char *s, *data; unsigned char read_responses[2] = { SSH_FXP_NAME, SSH_FXP_STATUS }; int retcode; if (sftp->readdir_state == libssh2_NB_state_idle) { if (handle->u.dir.names_left) { /* * A prior request returned more than one directory entry, * feed it back from the buffer */ unsigned char *s = (unsigned char *) handle->u.dir.next_name; unsigned long real_filename_len = libssh2_ntohu32(s); filename_len = real_filename_len; s += 4; if (filename_len > buffer_maxlen) { filename_len = buffer_maxlen; } memcpy(buffer, s, filename_len); s += real_filename_len; /* The filename is not null terminated, make it so if possible */ if (filename_len < buffer_maxlen) { buffer[filename_len] = '\0'; } if ((longentry == NULL) || (longentry_maxlen == 0)) { /* Skip longname */ s += 4 + libssh2_ntohu32(s); } else { unsigned long real_longentry_len = libssh2_ntohu32(s); longentry_len = real_longentry_len; s += 4; if (longentry_len > longentry_maxlen) { longentry_len = longentry_maxlen; } memcpy(longentry, s, longentry_len); s += real_longentry_len; /* The longentry is not null terminated, make it so if possible */ if (longentry_len < longentry_maxlen) { longentry[longentry_len] = '\0'; } } if (attrs) { memset(attrs, 0, sizeof(LIBSSH2_SFTP_ATTRIBUTES)); } s += libssh2_sftp_bin2attr(attrs ? attrs : &attrs_dummy, s); handle->u.dir.next_name = (char *) s; if ((--handle->u.dir.names_left) == 0) { LIBSSH2_FREE(session, handle->u.dir.names_packet); } _libssh2_debug(session, LIBSSH2_DBG_SFTP, "libssh2_sftp_readdir_ex() return %d", filename_len); return filename_len; } /* Request another entry(entries?) */ s = sftp->readdir_packet = LIBSSH2_ALLOC(session, packet_len); if (!sftp->readdir_packet) { libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for FXP_READDIR packet", 0); return -1; } libssh2_htonu32(s, packet_len - 4); s += 4; *(s++) = SSH_FXP_READDIR; sftp->readdir_request_id = sftp->request_id++; libssh2_htonu32(s, sftp->readdir_request_id); s += 4; libssh2_htonu32(s, handle->handle_len); s += 4; memcpy(s, handle->handle, handle->handle_len); s += handle->handle_len; sftp->readdir_state = libssh2_NB_state_created; } if (sftp->readdir_state == libssh2_NB_state_created) { _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Reading entries from directory handle"); if ((retcode = libssh2_channel_write_ex(channel, 0, (char *) sftp->readdir_packet, packet_len)) == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (packet_len != retcode) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send FXP_READ command", 0); LIBSSH2_FREE(session, sftp->readdir_packet); sftp->readdir_packet = NULL; sftp->readdir_state = libssh2_NB_state_idle; return -1; } LIBSSH2_FREE(session, sftp->readdir_packet); sftp->readdir_packet = NULL; sftp->readdir_state = libssh2_NB_state_sent; } retcode = libssh2_sftp_packet_requirev(sftp, 2, read_responses, sftp->readdir_request_id, &data, &data_len); if (retcode == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (retcode) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, "Timeout waiting for status message", 0); sftp->readdir_state = libssh2_NB_state_idle; return -1; } if (data[0] == SSH_FXP_STATUS) { retcode = libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); if (retcode == LIBSSH2_FX_EOF) { sftp->readdir_state = libssh2_NB_state_idle; return 0; } else { sftp->last_errno = retcode; libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, "SFTP Protocol Error", 0); sftp->readdir_state = libssh2_NB_state_idle; return -1; } } num_names = libssh2_ntohu32(data + 5); _libssh2_debug(session, LIBSSH2_DBG_SFTP, "%lu entries returned", num_names); if (num_names <= 0) { LIBSSH2_FREE(session, data); sftp->readdir_state = libssh2_NB_state_idle; return (num_names == 0) ? 0 : -1; } if (num_names == 1) { unsigned long real_filename_len = libssh2_ntohu32(data + 9); filename_len = real_filename_len; if (filename_len > buffer_maxlen) { filename_len = buffer_maxlen; } memcpy(buffer, data + 13, filename_len); /* The filename is not null terminated, make it so if possible */ if (filename_len < buffer_maxlen) { buffer[filename_len] = '\0'; } if (attrs) { memset(attrs, 0, sizeof(LIBSSH2_SFTP_ATTRIBUTES)); libssh2_sftp_bin2attr(attrs, data + 13 + real_filename_len + (4 + libssh2_ntohu32(data + 13 + real_filename_len))); } LIBSSH2_FREE(session, data); sftp->readdir_state = libssh2_NB_state_idle; return filename_len; } handle->u.dir.names_left = num_names; handle->u.dir.names_packet = data; handle->u.dir.next_name = (char *) data + 9; sftp->readdir_state = libssh2_NB_state_idle; /* Be lazy, just use the name popping mechanism from the start of the function */ return libssh2_sftp_readdir_ex(handle, buffer, buffer_maxlen, longentry, longentry_maxlen, attrs); } /* }}} */ /* {{{ libssh2_sftp_write * Write data to a file handle */ LIBSSH2_API ssize_t libssh2_sftp_write(LIBSSH2_SFTP_HANDLE * handle, const char *buffer, size_t count) { LIBSSH2_SFTP *sftp = handle->sftp; LIBSSH2_CHANNEL *channel = sftp->channel; LIBSSH2_SESSION *session = channel->session; unsigned long data_len, retcode; /* 25 = packet_len(4) + packet_type(1) + request_id(4) + handle_len(4) + offset(8) + count(4) */ ssize_t packet_len = handle->handle_len + count + 25; unsigned char *s, *data; int rc; if (sftp->write_state == libssh2_NB_state_idle) { _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Writing %lu bytes", (unsigned long) count); s = sftp->write_packet = LIBSSH2_ALLOC(session, packet_len); if (!sftp->write_packet) { libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for FXP_WRITE packet", 0); return -1; } libssh2_htonu32(s, packet_len - 4); s += 4; *(s++) = SSH_FXP_WRITE; sftp->write_request_id = sftp->request_id++; libssh2_htonu32(s, sftp->write_request_id); s += 4; libssh2_htonu32(s, handle->handle_len); s += 4; memcpy(s, handle->handle, handle->handle_len); s += handle->handle_len; libssh2_htonu64(s, handle->u.file.offset); s += 8; libssh2_htonu32(s, count); s += 4; memcpy(s, buffer, count); s += count; sftp->write_state = libssh2_NB_state_created; } if (sftp->write_state == libssh2_NB_state_created) { if ((rc = libssh2_channel_write_ex(channel, 0, (char *) sftp->write_packet, packet_len)) == PACKET_EAGAIN) { return PACKET_EAGAIN; } if (packet_len != rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send FXP_READ command", 0); LIBSSH2_FREE(session, sftp->write_packet); sftp->write_packet = NULL; sftp->write_state = libssh2_NB_state_idle; return -1; } LIBSSH2_FREE(session, sftp->write_packet); sftp->write_packet = NULL; sftp->write_state = libssh2_NB_state_sent; } rc = libssh2_sftp_packet_require(sftp, SSH_FXP_STATUS, sftp->write_request_id, &data, &data_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, "Timeout waiting for status message", 0); sftp->write_state = libssh2_NB_state_idle; return -1; } sftp->write_state = libssh2_NB_state_idle; retcode = libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); if (retcode == LIBSSH2_FX_OK) { handle->u.file.offset += count; return count; } libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, "SFTP Protocol Error", 0); sftp->last_errno = retcode; return -1; } /* }}} */ /* {{{ libssh2_sftp_fstat_ex * Get or Set stat on a file */ LIBSSH2_API int libssh2_sftp_fstat_ex(LIBSSH2_SFTP_HANDLE * handle, LIBSSH2_SFTP_ATTRIBUTES * attrs, int setstat) { LIBSSH2_SFTP *sftp = handle->sftp; LIBSSH2_CHANNEL *channel = sftp->channel; LIBSSH2_SESSION *session = channel->session; unsigned long data_len; /* 13 = packet_len(4) + packet_type(1) + request_id(4) + handle_len(4) */ ssize_t packet_len = handle->handle_len + 13 + (setstat ? libssh2_sftp_attrsize(attrs) : 0); unsigned char *s, *data; static const unsigned char fstat_responses[2] = { SSH_FXP_ATTRS, SSH_FXP_STATUS }; int rc; if (sftp->fstat_state == libssh2_NB_state_idle) { _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Issuing %s command", setstat ? "set-stat" : "stat"); s = sftp->fstat_packet = LIBSSH2_ALLOC(session, packet_len); if (!sftp->fstat_packet) { libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for FSTAT/FSETSTAT packet", 0); return -1; } libssh2_htonu32(s, packet_len - 4); s += 4; *(s++) = setstat ? SSH_FXP_FSETSTAT : SSH_FXP_FSTAT; sftp->fstat_request_id = sftp->request_id++; libssh2_htonu32(s, sftp->fstat_request_id); s += 4; libssh2_htonu32(s, handle->handle_len); s += 4; memcpy(s, handle->handle, handle->handle_len); s += handle->handle_len; if (setstat) { s += libssh2_sftp_attr2bin(s, attrs); } sftp->fstat_state = libssh2_NB_state_created; } if (sftp->fstat_state == libssh2_NB_state_created) { rc = libssh2_channel_write_ex(channel, 0, (char *) sftp->fstat_packet, packet_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (packet_len != rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, setstat ? (char *) "Unable to send FXP_FSETSTAT" : (char *) "Unable to send FXP_FSTAT command", 0); LIBSSH2_FREE(session, sftp->fstat_packet); sftp->fstat_packet = NULL; sftp->fstat_state = libssh2_NB_state_idle; return -1; } LIBSSH2_FREE(session, sftp->fstat_packet); sftp->fstat_packet = NULL; sftp->fstat_state = libssh2_NB_state_sent; } rc = libssh2_sftp_packet_requirev(sftp, 2, fstat_responses, sftp->fstat_request_id, &data, &data_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, "Timeout waiting for status message", 0); sftp->fstat_state = libssh2_NB_state_idle; return -1; } sftp->fstat_state = libssh2_NB_state_idle; if (data[0] == SSH_FXP_STATUS) { int retcode; retcode = libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); if (retcode == LIBSSH2_FX_OK) { return 0; } else { sftp->last_errno = retcode; libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, "SFTP Protocol Error", 0); return -1; } } libssh2_sftp_bin2attr(attrs, data + 5); return 0; } /* }}} */ /* {{{ libssh2_sftp_seek * Set the read/write pointer to an arbitrary position within the file */ LIBSSH2_API void libssh2_sftp_seek(LIBSSH2_SFTP_HANDLE * handle, size_t offset) { handle->u.file.offset = offset; } /* }}} */ /* {{{ libssh2_sftp_tell * Return the current read/write pointer's offset */ LIBSSH2_API size_t libssh2_sftp_tell(LIBSSH2_SFTP_HANDLE * handle) { return handle->u.file.offset; } /* }}} */ /* {{{ libssh2_sftp_close_handle * Close a file or directory handle * Also frees handle resource and unlinks it from the SFTP structure */ LIBSSH2_API int libssh2_sftp_close_handle(LIBSSH2_SFTP_HANDLE * handle) { LIBSSH2_SFTP *sftp = handle->sftp; LIBSSH2_CHANNEL *channel = sftp->channel; LIBSSH2_SESSION *session = channel->session; unsigned long data_len, retcode; /* 13 = packet_len(4) + packet_type(1) + request_id(4) + handle_len(4) */ ssize_t packet_len = handle->handle_len + 13; unsigned char *s, *data; int rc; if (handle->close_state == libssh2_NB_state_idle) { _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Closing handle"); s = handle->close_packet = LIBSSH2_ALLOC(session, packet_len); if (!handle->close_packet) { libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for FXP_CLOSE packet", 0); return -1; } libssh2_htonu32(s, packet_len - 4); s += 4; *(s++) = SSH_FXP_CLOSE; handle->close_request_id = sftp->request_id++; libssh2_htonu32(s, handle->close_request_id); s += 4; libssh2_htonu32(s, handle->handle_len); s += 4; memcpy(s, handle->handle, handle->handle_len); s += handle->handle_len; handle->close_state = libssh2_NB_state_created; } if (handle->close_state == libssh2_NB_state_created) { rc = libssh2_channel_write_ex(channel, 0, (char *) handle->close_packet, packet_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (packet_len != rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send FXP_CLOSE command", 0); LIBSSH2_FREE(session, handle->close_packet); handle->close_packet = NULL; handle->close_state = libssh2_NB_state_idle; return -1; } LIBSSH2_FREE(session, handle->close_packet); handle->close_packet = NULL; handle->close_state = libssh2_NB_state_sent; } if (handle->close_state == libssh2_NB_state_sent) { rc = libssh2_sftp_packet_require(sftp, SSH_FXP_STATUS, handle->close_request_id, &data, &data_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, "Timeout waiting for status message", 0); handle->close_state = libssh2_NB_state_idle; return -1; } handle->close_state = libssh2_NB_state_sent1; } retcode = libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); if (retcode != LIBSSH2_FX_OK) { sftp->last_errno = retcode; libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, "SFTP Protocol Error", 0); handle->close_state = libssh2_NB_state_idle; return -1; } if (handle == sftp->handles) { sftp->handles = handle->next; } if (handle->next) { handle->next->prev = NULL; } if ((handle->handle_type == LIBSSH2_SFTP_HANDLE_DIR) && handle->u.dir.names_left) { LIBSSH2_FREE(session, handle->u.dir.names_packet); } handle->close_state = libssh2_NB_state_idle; LIBSSH2_FREE(session, handle->handle); LIBSSH2_FREE(session, handle); return 0; } /* }}} */ /* ********************** * SFTP Miscellaneous * ********************** */ /* {{{ libssh2_sftp_unlink_ex * Delete a file from the remote server */ /* libssh2_sftp_unlink_ex - NB-UNSAFE?? */ LIBSSH2_API int libssh2_sftp_unlink_ex(LIBSSH2_SFTP * sftp, const char *filename, unsigned int filename_len) { LIBSSH2_CHANNEL *channel = sftp->channel; LIBSSH2_SESSION *session = channel->session; unsigned long data_len, retcode; /* 13 = packet_len(4) + packet_type(1) + request_id(4) + filename_len(4) */ ssize_t packet_len = filename_len + 13; unsigned char *s, *data; int rc; if (sftp->unlink_state == libssh2_NB_state_idle) { _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Unlinking %s", filename); s = sftp->unlink_packet = LIBSSH2_ALLOC(session, packet_len); if (!sftp->unlink_packet) { libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for FXP_REMOVE packet", 0); return -1; } libssh2_htonu32(s, packet_len - 4); s += 4; *(s++) = SSH_FXP_REMOVE; sftp->unlink_request_id = sftp->request_id++; libssh2_htonu32(s, sftp->unlink_request_id); s += 4; libssh2_htonu32(s, filename_len); s += 4; memcpy(s, filename, filename_len); s += filename_len; sftp->unlink_state = libssh2_NB_state_created; } if (sftp->unlink_state == libssh2_NB_state_created) { rc = libssh2_channel_write_ex(channel, 0, (char *) sftp->unlink_packet, packet_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (packet_len != rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send FXP_REMOVE command", 0); LIBSSH2_FREE(session, sftp->unlink_packet); sftp->unlink_packet = NULL; sftp->unlink_state = libssh2_NB_state_idle; return -1; } LIBSSH2_FREE(session, sftp->unlink_packet); sftp->unlink_packet = NULL; sftp->unlink_state = libssh2_NB_state_sent; } rc = libssh2_sftp_packet_require(sftp, SSH_FXP_STATUS, sftp->unlink_request_id, &data, &data_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, "Timeout waiting for status message", 0); sftp->unlink_state = libssh2_NB_state_idle; return -1; } sftp->unlink_state = libssh2_NB_state_idle; retcode = libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); if (retcode == LIBSSH2_FX_OK) { return 0; } else { sftp->last_errno = retcode; libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, "SFTP Protocol Error", 0); return -1; } } /* }}} */ /* {{{ libssh2_sftp_rename_ex * Rename a file on the remote server */ LIBSSH2_API int libssh2_sftp_rename_ex(LIBSSH2_SFTP * sftp, const char *source_filename, unsigned int source_filename_len, const char *dest_filename, unsigned int dest_filename_len, long flags) { LIBSSH2_CHANNEL *channel = sftp->channel; LIBSSH2_SESSION *session = channel->session; unsigned long data_len, retcode; ssize_t packet_len = source_filename_len + dest_filename_len + 17 + (sftp->version >= 5 ? 4 : 0); /* packet_len(4) + packet_type(1) + request_id(4) + source_filename_len(4) + dest_filename_len(4) + flags(4){SFTP5+) */ unsigned char *data; int rc; if (sftp->version < 2) { libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, "Server does not support RENAME", 0); return -1; } if (sftp->rename_state == libssh2_NB_state_idle) { _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Renaming %s to %s", source_filename, dest_filename); sftp->rename_s = sftp->rename_packet = LIBSSH2_ALLOC(session, packet_len); if (!sftp->rename_packet) { libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for FXP_RENAME packet", 0); return -1; } libssh2_htonu32(sftp->rename_s, packet_len - 4); sftp->rename_s += 4; *(sftp->rename_s++) = SSH_FXP_RENAME; sftp->rename_request_id = sftp->request_id++; libssh2_htonu32(sftp->rename_s, sftp->rename_request_id); sftp->rename_s += 4; libssh2_htonu32(sftp->rename_s, source_filename_len); sftp->rename_s += 4; memcpy(sftp->rename_s, source_filename, source_filename_len); sftp->rename_s += source_filename_len; libssh2_htonu32(sftp->rename_s, dest_filename_len); sftp->rename_s += 4; memcpy(sftp->rename_s, dest_filename, dest_filename_len); sftp->rename_s += dest_filename_len; if (sftp->version >= 5) { libssh2_htonu32(sftp->rename_s, flags); sftp->rename_s += 4; } sftp->rename_state = libssh2_NB_state_created; } if (sftp->rename_state == libssh2_NB_state_created) { rc = libssh2_channel_write_ex(channel, 0, (char *) sftp->rename_packet, sftp->rename_s - sftp->rename_packet); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (packet_len != rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send FXP_RENAME command", 0); LIBSSH2_FREE(session, sftp->rename_packet); sftp->rename_packet = NULL; sftp->rename_state = libssh2_NB_state_idle; return -1; } LIBSSH2_FREE(session, sftp->rename_packet); sftp->rename_packet = NULL; sftp->rename_state = libssh2_NB_state_sent; } rc = libssh2_sftp_packet_require(sftp, SSH_FXP_STATUS, sftp->rename_request_id, &data, &data_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, "Timeout waiting for status message", 0); sftp->rename_state = libssh2_NB_state_idle; return -1; } sftp->rename_state = libssh2_NB_state_idle; retcode = libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); switch (retcode) { case LIBSSH2_FX_OK: retcode = 0; break; case LIBSSH2_FX_FILE_ALREADY_EXISTS: libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, "File already exists and SSH_FXP_RENAME_OVERWRITE not specified", 0); sftp->last_errno = retcode; retcode = -1; break; case LIBSSH2_FX_OP_UNSUPPORTED: libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, "Operation Not Supported", 0); sftp->last_errno = retcode; retcode = -1; break; default: libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, "SFTP Protocol Error", 0); sftp->last_errno = retcode; retcode = -1; } return retcode; } /* }}} */ /* {{{ libssh2_sftp_mkdir_ex * Create an SFTP directory */ LIBSSH2_API int libssh2_sftp_mkdir_ex(LIBSSH2_SFTP * sftp, const char *path, unsigned int path_len, long mode) { LIBSSH2_CHANNEL *channel = sftp->channel; LIBSSH2_SESSION *session = channel->session; LIBSSH2_SFTP_ATTRIBUTES attrs = { LIBSSH2_SFTP_ATTR_PERMISSIONS, 0, 0, 0, 0, 0, 0 }; unsigned long data_len, retcode, request_id; /* 13 = packet_len(4) + packet_type(1) + request_id(4) + path_len(4) */ ssize_t packet_len = path_len + 13 + libssh2_sftp_attrsize(&attrs); unsigned char *packet, *s, *data; int rc; if (sftp->mkdir_state == libssh2_NB_state_idle) { _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Creating directory %s with mode 0%lo", path, mode); s = packet = LIBSSH2_ALLOC(session, packet_len); if (!packet) { libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for FXP_MKDIR packet", 0); return -1; } /* Filetype in SFTP 3 and earlier */ attrs.permissions = mode | LIBSSH2_SFTP_ATTR_PFILETYPE_DIR; libssh2_htonu32(s, packet_len - 4); s += 4; *(s++) = SSH_FXP_MKDIR; request_id = sftp->request_id++; libssh2_htonu32(s, request_id); s += 4; libssh2_htonu32(s, path_len); s += 4; memcpy(s, path, path_len); s += path_len; s += libssh2_sftp_attr2bin(s, &attrs); sftp->mkdir_state = libssh2_NB_state_created; } else { packet = sftp->mkdir_packet; request_id = sftp->mkdir_request_id; } if (sftp->mkdir_state == libssh2_NB_state_created) { rc = libssh2_channel_write_ex(channel, 0, (char *) packet, packet_len); if (rc == PACKET_EAGAIN) { sftp->mkdir_packet = packet; sftp->mkdir_request_id = request_id; return PACKET_EAGAIN; } if (packet_len != rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send FXP_READ command", 0); LIBSSH2_FREE(session, packet); sftp->mkdir_state = libssh2_NB_state_idle; return -1; } LIBSSH2_FREE(session, packet); sftp->mkdir_state = libssh2_NB_state_sent; sftp->mkdir_packet = NULL; } rc = libssh2_sftp_packet_require(sftp, SSH_FXP_STATUS, request_id, &data, &data_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, "Timeout waiting for status message", 0); sftp->mkdir_state = libssh2_NB_state_idle; return -1; } sftp->mkdir_state = libssh2_NB_state_idle; retcode = libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); if (retcode == LIBSSH2_FX_OK) { return 0; } else { libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, "SFTP Protocol Error", 0); sftp->last_errno = retcode; return -1; } } /* }}} */ /* {{{ libssh2_sftp_rmdir_ex * Remove a directory */ /* libssh2_sftp_rmdir_ex - NB-UNSAFE?? */ LIBSSH2_API int libssh2_sftp_rmdir_ex(LIBSSH2_SFTP * sftp, const char *path, unsigned int path_len) { LIBSSH2_CHANNEL *channel = sftp->channel; LIBSSH2_SESSION *session = channel->session; unsigned long data_len, retcode; /* 13 = packet_len(4) + packet_type(1) + request_id(4) + path_len(4) */ ssize_t packet_len = path_len + 13; unsigned char *s, *data; int rc; if (sftp->rmdir_state == libssh2_NB_state_idle) { _libssh2_debug(session, LIBSSH2_DBG_SFTP, "Removing directory: %s", path); s = sftp->rmdir_packet = LIBSSH2_ALLOC(session, packet_len); if (!sftp->rmdir_packet) { libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for FXP_MKDIR packet", 0); return -1; } libssh2_htonu32(s, packet_len - 4); s += 4; *(s++) = SSH_FXP_RMDIR; sftp->rmdir_request_id = sftp->request_id++; libssh2_htonu32(s, sftp->rmdir_request_id); s += 4; libssh2_htonu32(s, path_len); s += 4; memcpy(s, path, path_len); s += path_len; sftp->rmdir_state = libssh2_NB_state_created; } if (sftp->rmdir_state == libssh2_NB_state_created) { rc = libssh2_channel_write_ex(channel, 0, (char *) sftp->rmdir_packet, packet_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (packet_len != rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send FXP_MKDIR command", 0); LIBSSH2_FREE(session, sftp->rmdir_packet); sftp->rmdir_packet = NULL; sftp->rmdir_state = libssh2_NB_state_idle; return -1; } LIBSSH2_FREE(session, sftp->rmdir_packet); sftp->rmdir_packet = NULL; sftp->rmdir_state = libssh2_NB_state_sent; } rc = libssh2_sftp_packet_require(sftp, SSH_FXP_STATUS, sftp->rmdir_request_id, &data, &data_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, "Timeout waiting for status message", 0); sftp->rmdir_state = libssh2_NB_state_idle; return -1; } sftp->rmdir_state = libssh2_NB_state_idle; retcode = libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); if (retcode == LIBSSH2_FX_OK) { return 0; } else { sftp->last_errno = retcode; libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, "SFTP Protocol Error", 0); return -1; } } /* }}} */ /* {{{ libssh2_sftp_stat_ex * Stat a file or symbolic link */ /* libssh2_sftp_stat_ex - NB-UNSAFE?? */ LIBSSH2_API int libssh2_sftp_stat_ex(LIBSSH2_SFTP * sftp, const char *path, unsigned int path_len, int stat_type, LIBSSH2_SFTP_ATTRIBUTES * attrs) { LIBSSH2_CHANNEL *channel = sftp->channel; LIBSSH2_SESSION *session = channel->session; unsigned long data_len; /* 13 = packet_len(4) + packet_type(1) + request_id(4) + path_len(4) */ ssize_t packet_len = path_len + 13 + ((stat_type == LIBSSH2_SFTP_SETSTAT) ? libssh2_sftp_attrsize(attrs) : 0); unsigned char *s, *data; static const unsigned char stat_responses[2] = { SSH_FXP_ATTRS, SSH_FXP_STATUS }; int rc; if (sftp->stat_state == libssh2_NB_state_idle) { _libssh2_debug(session, LIBSSH2_DBG_SFTP, "%s %s", (stat_type == LIBSSH2_SFTP_SETSTAT) ? "Set-statting" : (stat_type == LIBSSH2_SFTP_LSTAT ? "LStatting" : "Statting"), path); s = sftp->stat_packet = LIBSSH2_ALLOC(session, packet_len); if (!sftp->stat_packet) { libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for FXP_MKDIR packet", 0); return -1; } libssh2_htonu32(s, packet_len - 4); s += 4; switch (stat_type) { case LIBSSH2_SFTP_SETSTAT: *(s++) = SSH_FXP_SETSTAT; break; case LIBSSH2_SFTP_LSTAT: *(s++) = SSH_FXP_LSTAT; break; case LIBSSH2_SFTP_STAT: default: *(s++) = SSH_FXP_STAT; } sftp->stat_request_id = sftp->request_id++; libssh2_htonu32(s, sftp->stat_request_id); s += 4; libssh2_htonu32(s, path_len); s += 4; memcpy(s, path, path_len); s += path_len; if (stat_type == LIBSSH2_SFTP_SETSTAT) { s += libssh2_sftp_attr2bin(s, attrs); } sftp->stat_state = libssh2_NB_state_created; } if (sftp->stat_state == libssh2_NB_state_created) { rc = libssh2_channel_write_ex(channel, 0, (char *) sftp->stat_packet, packet_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (packet_len != rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send STAT/LSTAT/SETSTAT command", 0); LIBSSH2_FREE(session, sftp->stat_packet); sftp->stat_packet = NULL; sftp->stat_state = libssh2_NB_state_idle; return -1; } LIBSSH2_FREE(session, sftp->stat_packet); sftp->stat_packet = NULL; sftp->stat_state = libssh2_NB_state_sent; } rc = libssh2_sftp_packet_requirev(sftp, 2, stat_responses, sftp->stat_request_id, &data, &data_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, "Timeout waiting for status message", 0); sftp->stat_state = libssh2_NB_state_idle; return -1; } sftp->stat_state = libssh2_NB_state_idle; if (data[0] == SSH_FXP_STATUS) { int retcode; retcode = libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); if (retcode == LIBSSH2_FX_OK) { return 0; } else { sftp->last_errno = retcode; libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, "SFTP Protocol Error", 0); return -1; } } memset(attrs, 0, sizeof(LIBSSH2_SFTP_ATTRIBUTES)); libssh2_sftp_bin2attr(attrs, data + 5); LIBSSH2_FREE(session, data); return 0; } /* }}} */ /* {{{ libssh2_sftp_symlink_ex * Read or set a symlink */ LIBSSH2_API int libssh2_sftp_symlink_ex(LIBSSH2_SFTP * sftp, const char *path, unsigned int path_len, char *target, unsigned int target_len, int link_type) { LIBSSH2_CHANNEL *channel = sftp->channel; LIBSSH2_SESSION *session = channel->session; unsigned long data_len, link_len; /* 13 = packet_len(4) + packet_type(1) + request_id(4) + path_len(4) */ ssize_t packet_len = path_len + 13 + ((link_type == LIBSSH2_SFTP_SYMLINK) ? (4 + target_len) : 0); unsigned char *s, *data; static const unsigned char link_responses[2] = { SSH_FXP_NAME, SSH_FXP_STATUS }; int rc; if ((sftp->version < 3) && (link_type != LIBSSH2_SFTP_REALPATH)) { libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, "Server does not support SYMLINK or READLINK", 0); return -1; } if (sftp->symlink_state == libssh2_NB_state_idle) { s = sftp->symlink_packet = LIBSSH2_ALLOC(session, packet_len); if (!sftp->symlink_packet) { libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for SYMLINK/READLINK/REALPATH packet", 0); return -1; } _libssh2_debug(session, LIBSSH2_DBG_SFTP, "%s %s on %s", (link_type == LIBSSH2_SFTP_SYMLINK) ? "Creating" : "Reading", (link_type == LIBSSH2_SFTP_REALPATH) ? "realpath" : "symlink", path); libssh2_htonu32(s, packet_len - 4); s += 4; switch (link_type) { case LIBSSH2_SFTP_REALPATH: *(s++) = SSH_FXP_REALPATH; break; case LIBSSH2_SFTP_SYMLINK: *(s++) = SSH_FXP_SYMLINK; break; case LIBSSH2_SFTP_READLINK: default: *(s++) = SSH_FXP_READLINK; } sftp->symlink_request_id = sftp->request_id++; libssh2_htonu32(s, sftp->symlink_request_id); s += 4; libssh2_htonu32(s, path_len); s += 4; memcpy(s, path, path_len); s += path_len; if (link_type == LIBSSH2_SFTP_SYMLINK) { libssh2_htonu32(s, target_len); s += 4; memcpy(s, target, target_len); s += target_len; } sftp->symlink_state = libssh2_NB_state_created; } if (sftp->symlink_state == libssh2_NB_state_created) { rc = libssh2_channel_write_ex(channel, 0, (char *) sftp->symlink_packet, packet_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (packet_len != rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send SYMLINK/READLINK command", 0); LIBSSH2_FREE(session, sftp->symlink_packet); sftp->symlink_packet = NULL; sftp->symlink_state = libssh2_NB_state_idle; return -1; } LIBSSH2_FREE(session, sftp->symlink_packet); sftp->symlink_packet = NULL; sftp->symlink_state = libssh2_NB_state_sent; } rc = libssh2_sftp_packet_requirev(sftp, 2, link_responses, sftp->symlink_request_id, &data, &data_len); if (rc == PACKET_EAGAIN) { return PACKET_EAGAIN; } else if (rc) { libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, "Timeout waiting for status message", 0); sftp->symlink_state = libssh2_NB_state_idle; return -1; } sftp->symlink_state = libssh2_NB_state_idle; if (data[0] == SSH_FXP_STATUS) { int retcode; retcode = libssh2_ntohu32(data + 5); LIBSSH2_FREE(session, data); if (retcode == LIBSSH2_FX_OK) { return 0; } else { sftp->last_errno = retcode; libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, "SFTP Protocol Error", 0); return -1; } } if (libssh2_ntohu32(data + 5) < 1) { libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, "Invalid READLINK/REALPATH response, no name entries", 0); LIBSSH2_FREE(session, data); return -1; } link_len = libssh2_ntohu32(data + 9); if (link_len >= target_len) { link_len = target_len - 1; } memcpy(target, data + 13, link_len); target[link_len] = 0; LIBSSH2_FREE(session, data); return link_len; } /* }}} */ /* {{{ libssh2_sftp_last_error * Returns the last error code reported by SFTP */ LIBSSH2_API unsigned long libssh2_sftp_last_error(LIBSSH2_SFTP * sftp) { return sftp->last_errno; } /* }}} */