#include "libssh2_priv.h"

#include "libssh2_sftp.h"

#include "channel.h"

#include "session.h"

#include "sftp.h"

#include <assert.h>

#include <stdlib.h> /* strtol() */

#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_ATTR_PFILETYPE_FILE 0100000

#define LIBSSH2_SFTP_ATTR_PFILETYPE_DIR 0040000

#define SSH_FXE_STATVFS_ST_RDONLY 0x00000001

#define SSH_FXE_STATVFS_ST_NOSUID 0x00000002

#define LIBSSH2_SFTP_PACKET_MAXLEN (256 * 1024)

static int sftp_packet_ask(LIBSSH2_SFTP *sftp, unsigned char packet_type,

uint32_t request_id, unsigned char **data,

size_t *data_len);

static void sftp_packet_flush(LIBSSH2_SFTP *sftp);

static struct sftp_zombie_requests *

find_zombie_request(LIBSSH2_SFTP *sftp, uint32_t request_id)

{

struct sftp_zombie_requests *zombie =

_libssh2_list_first(&sftp->zombie_requests);

while(zombie) {

if(zombie->request_id == request_id)

break;

else

zombie = _libssh2_list_next(&zombie->node);

}

return zombie;

}

static void

remove_zombie_request(LIBSSH2_SFTP *sftp, uint32_t request_id)

{

LIBSSH2_SESSION *session = sftp->channel->session;

struct sftp_zombie_requests *zombie = find_zombie_request(sftp,

request_id);

if(zombie) {

_libssh2_debug((session, LIBSSH2_TRACE_SFTP,

"Removing request ID %u from the list of "

"zombie requests",

request_id));

_libssh2_list_remove(&zombie->node);

LIBSSH2_FREE(session, zombie);

}

}

static int

add_zombie_request(LIBSSH2_SFTP *sftp, uint32_t request_id)

{

LIBSSH2_SESSION *session = sftp->channel->session;

struct sftp_zombie_requests *zombie;

_libssh2_debug((session, LIBSSH2_TRACE_SFTP,

"Marking request ID %u as a zombie request", request_id));

zombie = LIBSSH2_ALLOC(sftp->channel->session,

sizeof(struct sftp_zombie_requests));

if(!zombie)

return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,

"malloc fail for zombie request ID");

else {

zombie->request_id = request_id;

_libssh2_list_add(&sftp->zombie_requests, &zombie->node);

return LIBSSH2_ERROR_NONE;

}

}

static int

sftp_packet_add(LIBSSH2_SFTP *sftp, unsigned char *data,

size_t data_len)

{

LIBSSH2_SESSION *session = sftp->channel->session;

LIBSSH2_SFTP_PACKET *packet;

uint32_t request_id;

if(data_len < 5) {

return LIBSSH2_ERROR_OUT_OF_BOUNDARY;

}

_libssh2_debug((session, LIBSSH2_TRACE_SFTP,

"Received packet type %u (len %lu)",

(unsigned int)data[0], (unsigned long)data_len));

/*

switch(data[0]) {

case SSH_FXP_INIT:

case SSH_FXP_VERSION:

case SSH_FXP_OPEN:

case SSH_FXP_CLOSE:

case SSH_FXP_READ:

case SSH_FXP_WRITE:

case SSH_FXP_LSTAT:

case SSH_FXP_FSTAT:

case SSH_FXP_SETSTAT:

case SSH_FXP_FSETSTAT:

case SSH_FXP_OPENDIR:

case SSH_FXP_READDIR:

case SSH_FXP_REMOVE:

case SSH_FXP_MKDIR:

case SSH_FXP_RMDIR:

case SSH_FXP_REALPATH:

case SSH_FXP_STAT:

case SSH_FXP_RENAME:

case SSH_FXP_READLINK:

case SSH_FXP_SYMLINK:

case SSH_FXP_STATUS:

case SSH_FXP_HANDLE:

case SSH_FXP_DATA:

case SSH_FXP_NAME:

case SSH_FXP_ATTRS:

case SSH_FXP_EXTENDED:

case SSH_FXP_EXTENDED_REPLY:

break;

default:

sftp->last_errno = LIBSSH2_FX_OK;

return _libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,

"Out of sync with the world");

}

request_id = _libssh2_ntohu32(&data[1]);

_libssh2_debug((session, LIBSSH2_TRACE_SFTP, "Received packet id %d",

request_id));

/* Don't add the packet if it answers a request we've given up on. */

if((data[0] == SSH_FXP_STATUS || data[0] == SSH_FXP_DATA)

&& find_zombie_request(sftp, request_id)) {

/* If we get here, the file ended before the response arrived. We

LIBSSH2_FREE(session, data);

remove_zombie_request(sftp, request_id);

return LIBSSH2_ERROR_NONE;

}

packet = LIBSSH2_ALLOC(session, sizeof(LIBSSH2_SFTP_PACKET));

if(!packet) {

return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,

"Unable to allocate datablock for SFTP packet");

}

packet->data = data;

packet->data_len = data_len;

packet->request_id = request_id;

_libssh2_list_add(&sftp->packets, &packet->node);

return LIBSSH2_ERROR_NONE;

}

static int

sftp_packet_read(LIBSSH2_SFTP *sftp)

{

LIBSSH2_CHANNEL *channel = sftp->channel;

LIBSSH2_SESSION *session = channel->session;

unsigned char *packet = NULL;

ssize_t rc;

unsigned long recv_window;

int packet_type;

uint32_t request_id;

_libssh2_debug((session, LIBSSH2_TRACE_SFTP, "recv packet"));

switch(sftp->packet_state) {

case libssh2_NB_state_sent: /* EAGAIN from window adjusting */

sftp->packet_state = libssh2_NB_state_idle;

packet = sftp->partial_packet;

goto window_adjust;

case libssh2_NB_state_sent1: /* EAGAIN from channel read */

sftp->packet_state = libssh2_NB_state_idle;

packet = sftp->partial_packet;

_libssh2_debug((session, LIBSSH2_TRACE_SFTP,

"partial read cont, len: %u", sftp->partial_len));

_libssh2_debug((session, LIBSSH2_TRACE_SFTP,

"partial read cont, already recvd: %lu",

(unsigned long)sftp->partial_received));

LIBSSH2_FALLTHROUGH();

default:

if(!packet) {

/* only do this if there's not already a packet buffer allocated

/* each packet starts with a 32 bit length field */

rc = _libssh2_channel_read(channel, 0,

(char *)&sftp->packet_header[

sftp->packet_header_len],

sizeof(sftp->packet_header) -

sftp->packet_header_len);

if(rc == LIBSSH2_ERROR_EAGAIN)

return (int)rc;

else if(rc < 0)

return _libssh2_error(session, (int)rc, "channel read");

sftp->packet_header_len += rc;

if(sftp->packet_header_len != sizeof(sftp->packet_header))

/* we got a short read for the header part */

return LIBSSH2_ERROR_EAGAIN;

/* parse SFTP packet header */

sftp->partial_len = _libssh2_ntohu32(sftp->packet_header);

packet_type = sftp->packet_header[4];

request_id = _libssh2_ntohu32(sftp->packet_header + 5);

/* make sure we don't proceed if the packet size is unreasonably

if(sftp->partial_len > LIBSSH2_SFTP_PACKET_MAXLEN &&

/* exception: response to SSH_FXP_READDIR request */

!(sftp->readdir_state != libssh2_NB_state_idle &&

sftp->readdir_request_id == request_id &&

packet_type == SSH_FXP_NAME)) {

libssh2_channel_flush(channel);

sftp->packet_header_len = 0;

return _libssh2_error(session,

LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED,

"SFTP packet too large");

}

if(sftp->partial_len < 5)

return _libssh2_error(session,

LIBSSH2_ERROR_ALLOC,

"Invalid SFTP packet size");

_libssh2_debug((session, LIBSSH2_TRACE_SFTP,

"Data begin - Packet Length: %lu",

(unsigned long)sftp->partial_len));

packet = LIBSSH2_ALLOC(session, sftp->partial_len);

if(!packet)

return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,

"Unable to allocate SFTP packet");

sftp->packet_header_len = 0;

sftp->partial_packet = packet;

/* copy over packet type(4) and request id(1) */

sftp->partial_received = 5;

memcpy(packet, sftp->packet_header + 4, 5);

window_adjust:

recv_window = libssh2_channel_window_read_ex(channel, NULL, NULL);

if(sftp->partial_len > recv_window) {

/* ask for twice the data amount we need at once */

rc = _libssh2_channel_receive_window_adjust(channel,

sftp->partial_len

* 2,

1, NULL);

/* store the state so that we continue with the correct

sftp->packet_state = (rc == LIBSSH2_ERROR_EAGAIN) ?

libssh2_NB_state_sent :

libssh2_NB_state_idle;

if(rc == LIBSSH2_ERROR_EAGAIN)

return (int)rc;

}

}

/* Read as much of the packet as we can */

while(sftp->partial_len > sftp->partial_received) {

rc = _libssh2_channel_read(channel, 0,

(char *)&packet[sftp->partial_received],

sftp->partial_len -

sftp->partial_received);

if(rc == LIBSSH2_ERROR_EAGAIN) {

/*

sftp->packet_state = libssh2_NB_state_sent1;

return (int)rc;

}

else if(rc < 0) {

LIBSSH2_FREE(session, packet);

sftp->partial_packet = NULL;

return _libssh2_error(session, (int)rc,

"Error waiting for SFTP packet");

}

sftp->partial_received += rc;

}

sftp->partial_packet = NULL;

/* sftp_packet_add takes ownership of the packet and might free it

packet_type = packet[0];

rc = sftp_packet_add(sftp, packet, sftp->partial_len);

if(rc) {

LIBSSH2_FREE(session, packet);

return (int)rc;

}

else {

return packet_type;

}

}

/* WON'T REACH */

}

static void sftp_packetlist_flush(LIBSSH2_SFTP_HANDLE *handle)

{

struct sftp_pipeline_chunk *chunk;

LIBSSH2_SFTP *sftp = handle->sftp;

LIBSSH2_SESSION *session = sftp->channel->session;

/* remove pending packets, if any */

chunk = _libssh2_list_first(&handle->packet_list);

while(chunk) {

unsigned char *data;

size_t data_len;

int rc;

struct sftp_pipeline_chunk *next = _libssh2_list_next(&chunk->node);

rc = sftp_packet_ask(sftp, SSH_FXP_STATUS,

chunk->request_id, &data, &data_len);

if(rc)

rc = sftp_packet_ask(sftp, SSH_FXP_DATA,

chunk->request_id, &data, &data_len);

if(!rc)

/* we found a packet, free it */

LIBSSH2_FREE(session, data);

else if(chunk->sent)

/* there was no incoming packet for this request, mark this

add_zombie_request(sftp, chunk->request_id);

_libssh2_list_remove(&chunk->node);

LIBSSH2_FREE(session, chunk);

chunk = next;

}

}

static int

sftp_packet_ask(LIBSSH2_SFTP *sftp, unsigned char packet_type,

uint32_t request_id, unsigned char **data,

size_t *data_len)

{

LIBSSH2_SESSION *session = sftp->channel->session;

LIBSSH2_SFTP_PACKET *packet = _libssh2_list_first(&sftp->packets);

if(!packet)

return -1;

/* Special consideration when getting VERSION packet */

while(packet) {

if((packet->data[0] == packet_type) &&

((packet_type == SSH_FXP_VERSION) ||

(packet->request_id == request_id))) {

/* Match! Fetch the data */

*data = packet->data;

*data_len = packet->data_len;

/* unlink and free this struct */

_libssh2_list_remove(&packet->node);

LIBSSH2_FREE(session, packet);

return 0;

}

/* check next struct in the list */

packet = _libssh2_list_next(&packet->node);

}

return -1;

}

static int

sftp_packet_require(LIBSSH2_SFTP *sftp, unsigned char packet_type,

uint32_t request_id, unsigned char **data,

size_t *data_len, size_t required_size)

{

LIBSSH2_SESSION *session = sftp->channel->session;

int rc;

if(!data || !data_len || required_size == 0) {

return LIBSSH2_ERROR_BAD_USE;

}

_libssh2_debug((session, LIBSSH2_TRACE_SFTP, "Requiring packet %u id %u",

(unsigned int) packet_type, request_id));

if(sftp_packet_ask(sftp, packet_type, request_id, data, data_len) == 0) {

/* The right packet was available in the packet brigade */

_libssh2_debug((session, LIBSSH2_TRACE_SFTP, "Got %u",

(unsigned int) packet_type));

if(*data_len < required_size) {

return LIBSSH2_ERROR_BUFFER_TOO_SMALL;

}

return LIBSSH2_ERROR_NONE;

}

while(session->socket_state == LIBSSH2_SOCKET_CONNECTED) {

rc = sftp_packet_read(sftp);

if(rc < 0)

return rc;

/* data was read, check the queue again */

if(!sftp_packet_ask(sftp, packet_type, request_id, data, data_len)) {

/* The right packet was available in the packet brigade */

_libssh2_debug((session, LIBSSH2_TRACE_SFTP, "Got %d",

(unsigned int) packet_type));

if(*data_len < required_size) {

return LIBSSH2_ERROR_BUFFER_TOO_SMALL;

}

return LIBSSH2_ERROR_NONE;

}

}

/* Only reached if the socket died */

return LIBSSH2_ERROR_SOCKET_DISCONNECT;

}

static int

sftp_packet_requirev(LIBSSH2_SFTP *sftp, int num_valid_responses,

const unsigned char *valid_responses,

uint32_t request_id, unsigned char **data,

size_t *data_len, size_t required_size)

{

int i;

int rc;

if(!data || !data_len || required_size == 0) {

return LIBSSH2_ERROR_BAD_USE;

}

/* If no timeout is active, start a new one */

if(sftp->requirev_start == 0)

sftp->requirev_start = time(NULL);

while(sftp->channel->session->socket_state == LIBSSH2_SOCKET_CONNECTED) {

for(i = 0; i < num_valid_responses; i++) {

if(sftp_packet_ask(sftp, valid_responses[i], request_id,

data, data_len) == 0) {

/*

sftp->requirev_start = 0;

if(*data_len < required_size) {

return LIBSSH2_ERROR_BUFFER_TOO_SMALL;

}

return LIBSSH2_ERROR_NONE;

}

}

rc = sftp_packet_read(sftp);

if((rc < 0) && (rc != LIBSSH2_ERROR_EAGAIN)) {

sftp->requirev_start = 0;

return rc;

}

else if(rc <= 0) {

/* prevent busy-looping */

long left =

sftp->channel->session->packet_read_timeout -

(long)(time(NULL) - sftp->requirev_start);

if(left <= 0) {

sftp->requirev_start = 0;

return LIBSSH2_ERROR_TIMEOUT;

}

else if(rc == LIBSSH2_ERROR_EAGAIN) {

return rc;

}

}

}

sftp->requirev_start = 0;

/* Only reached if the socket died */

return LIBSSH2_ERROR_SOCKET_DISCONNECT;

}

static int sftp_attrsize(unsigned long flags)

{

return 4 + /* flags(4) */

((flags & LIBSSH2_SFTP_ATTR_SIZE) ? 8 : 0) +

((flags & LIBSSH2_SFTP_ATTR_UIDGID) ? 8 : 0) +

((flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) ? 4 : 0) +

((flags & LIBSSH2_SFTP_ATTR_ACMODTIME) ? 8 : 0);

/* atime + mtime as u32 */

}

static ssize_t

sftp_attr2bin(unsigned char *p, const LIBSSH2_SFTP_ATTRIBUTES * attrs)

{

unsigned char *s = p;

uint32_t 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

if(!attrs) {

_libssh2_htonu32(s, 0);

return 4;

}

_libssh2_store_u32(&s, (uint32_t)(attrs->flags & flag_mask));

if(attrs->flags & LIBSSH2_SFTP_ATTR_SIZE) {

_libssh2_store_u64(&s, attrs->filesize);

}

if(attrs->flags & LIBSSH2_SFTP_ATTR_UIDGID) {

_libssh2_store_u32(&s, (uint32_t)attrs->uid);

_libssh2_store_u32(&s, (uint32_t)attrs->gid);

}

if(attrs->flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) {

_libssh2_store_u32(&s, (uint32_t)attrs->permissions);

}

if(attrs->flags & LIBSSH2_SFTP_ATTR_ACMODTIME) {

_libssh2_store_u32(&s, (uint32_t)attrs->atime);

_libssh2_store_u32(&s, (uint32_t)attrs->mtime);

}

return s - p;

}

static ssize_t

sftp_bin2attr(LIBSSH2_SFTP_ATTRIBUTES *attrs, const unsigned char *p,

size_t data_len)

{

struct string_buf buf;

uint32_t flags = 0;

buf.data = (unsigned char *)p;

buf.dataptr = buf.data;

buf.len = data_len;

if(_libssh2_get_u32(&buf, &flags)) {

return LIBSSH2_ERROR_BUFFER_TOO_SMALL;

}

attrs->flags = flags;

if(attrs->flags & LIBSSH2_SFTP_ATTR_SIZE) {

if(_libssh2_get_u64(&buf, &(attrs->filesize))) {

return LIBSSH2_ERROR_BUFFER_TOO_SMALL;

}

}

if(attrs->flags & LIBSSH2_SFTP_ATTR_UIDGID) {

uint32_t uid = 0;

uint32_t gid = 0;

if(_libssh2_get_u32(&buf, &uid) ||

_libssh2_get_u32(&buf, &gid)) {

return LIBSSH2_ERROR_BUFFER_TOO_SMALL;

}

attrs->uid = uid;

attrs->gid = gid;

}

if(attrs->flags & LIBSSH2_SFTP_ATTR_PERMISSIONS) {

uint32_t permissions;

if(_libssh2_get_u32(&buf, &permissions)) {

return LIBSSH2_ERROR_BUFFER_TOO_SMALL;

}

attrs->permissions = permissions;

}

if(attrs->flags & LIBSSH2_SFTP_ATTR_ACMODTIME) {

uint32_t atime;

uint32_t mtime;

if(_libssh2_get_u32(&buf, &atime) ||

_libssh2_get_u32(&buf, &mtime)) {

return LIBSSH2_ERROR_BUFFER_TOO_SMALL;

}

attrs->atime = atime;

attrs->mtime = mtime;

}

/* Parse extended data, if present, to avoid stream parsing errors */

if(attrs->flags & LIBSSH2_SFTP_ATTR_EXTENDED) {

uint32_t extended_count;

uint32_t i;

size_t etype_len;

unsigned char *etype;

size_t edata_len;

unsigned char *edata;

if(_libssh2_get_u32(&buf, &extended_count)) {

return LIBSSH2_ERROR_BUFFER_TOO_SMALL;

}

for(i = 0; i < extended_count; ++i) {

if(_libssh2_get_string(&buf, &etype, &etype_len) ||

_libssh2_get_string(&buf, &edata, &edata_len)) {

return LIBSSH2_ERROR_BUFFER_TOO_SMALL;

}

}

}

return buf.dataptr - buf.data;

}

LIBSSH2_CHANNEL_CLOSE_FUNC(libssh2_sftp_dtor);

LIBSSH2_CHANNEL_CLOSE_FUNC(libssh2_sftp_dtor)

{

LIBSSH2_SFTP *sftp = (LIBSSH2_SFTP *) (*channel_abstract);

(void)session_abstract;

(void)channel;

/* Free the partial packet storage for 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);

}

static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)

{

unsigned char *data;

size_t data_len = 0;

ssize_t rc;

LIBSSH2_SFTP *sftp_handle;

struct string_buf buf;

unsigned char *endp;

if(session->sftpInit_state == libssh2_NB_state_idle) {

_libssh2_debug((session, LIBSSH2_TRACE_SFTP,

"Initializing SFTP subsystem"));

/*

assert(!session->sftpInit_sftp);

session->sftpInit_sftp = NULL;

session->sftpInit_state = libssh2_NB_state_created;

}

sftp_handle = session->sftpInit_sftp;

if(session->sftpInit_state == libssh2_NB_state_created) {

session->sftpInit_channel =

_libssh2_channel_open(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");

}

else {

_libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE,

"Unable to startup channel");

session->sftpInit_state = libssh2_NB_state_idle;

}

return NULL;

}

session->sftpInit_state = libssh2_NB_state_sent;

}

if(session->sftpInit_state == libssh2_NB_state_sent) {

int ret = _libssh2_channel_process_startup(session->sftpInit_channel,

"subsystem",

sizeof("subsystem") - 1,

"sftp",

strlen("sftp"));

if(ret == LIBSSH2_ERROR_EAGAIN) {

_libssh2_error(session, LIBSSH2_ERROR_EAGAIN,

"Would block to request SFTP subsystem");

return NULL;

}

else if(ret) {

_libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE,

"Unable to request SFTP subsystem");

goto sftp_init_error;

}

session->sftpInit_state = libssh2_NB_state_sent1;

}

if(session->sftpInit_state == libssh2_NB_state_sent1) {

rc = _libssh2_channel_extended_data(session->sftpInit_channel,

LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE);

if(rc == LIBSSH2_ERROR_EAGAIN) {

_libssh2_error(session, LIBSSH2_ERROR_EAGAIN,

"Would block requesting handle extended data");

return NULL;

}

sftp_handle =

session->sftpInit_sftp =

LIBSSH2_CALLOC(session, sizeof(LIBSSH2_SFTP));

if(!sftp_handle) {

_libssh2_error(session, LIBSSH2_ERROR_ALLOC,

"Unable to allocate a new SFTP structure");

goto sftp_init_error;

}

sftp_handle->channel = session->sftpInit_channel;

sftp_handle->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);

session->sftpInit_sent = 0; /* nothing's sent yet */

_libssh2_debug((session, LIBSSH2_TRACE_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) {

/* sent off what's left of the init buffer to send */

rc = _libssh2_channel_write(session->sftpInit_channel, 0,

session->sftpInit_buffer +

session->sftpInit_sent,

9 - session->sftpInit_sent);

if(rc == LIBSSH2_ERROR_EAGAIN) {

_libssh2_error(session, LIBSSH2_ERROR_EAGAIN,

"Would block sending SSH_FXP_INIT");

return NULL;

}

else if(rc < 0) {

_libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,

"Unable to send SSH_FXP_INIT");

goto sftp_init_error;

}

else {

/* add up the number of bytes sent */

session->sftpInit_sent += rc;

if(session->sftpInit_sent == 9)

/* move on */

session->sftpInit_state = libssh2_NB_state_sent3;

/* if less than 9, we remain in this state to send more later on */

}

}

if(session->sftpInit_state == libssh2_NB_state_error_closing) {

rc = _libssh2_channel_free(session->sftpInit_channel);

if(rc == LIBSSH2_ERROR_EAGAIN) {

_libssh2_error(session, LIBSSH2_ERROR_EAGAIN,

"Would block closing channel");

return NULL;

}

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;

}

rc = sftp_packet_require(sftp_handle, SSH_FXP_VERSION,

0, &data, &data_len, 5);

if(rc == LIBSSH2_ERROR_EAGAIN) {

_libssh2_error(session, LIBSSH2_ERROR_EAGAIN,

"Would block receiving SSH_FXP_VERSION");

return NULL;

}

else if(rc == LIBSSH2_ERROR_BUFFER_TOO_SMALL) {

if(data_len > 0) {

LIBSSH2_FREE(session, data);

}

_libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,

"Invalid SSH_FXP_VERSION response");

goto sftp_init_error;

}

else if(rc) {

_libssh2_error(session, (int)rc,

"Timeout waiting for response from SFTP subsystem");

goto sftp_init_error;

}

buf.data = data;

buf.dataptr = buf.data + 1;

buf.len = data_len;

endp = &buf.data[data_len];

if(_libssh2_get_u32(&buf, &(sftp_handle->version))) {

LIBSSH2_FREE(session, data);

rc = LIBSSH2_ERROR_BUFFER_TOO_SMALL;

goto sftp_init_error;

}

if(sftp_handle->version > LIBSSH2_SFTP_VERSION) {

_libssh2_debug((session, LIBSSH2_TRACE_SFTP,

"Truncating remote SFTP version from %u",

sftp_handle->version));

sftp_handle->version = LIBSSH2_SFTP_VERSION;

}

_libssh2_debug((session, LIBSSH2_TRACE_SFTP,

"Enabling SFTP version %u compatibility",

sftp_handle->version));

while(buf.dataptr < endp) {

unsigned char *extname, *extdata;

size_t extname_len, extdata_len;

uint32_t extversion = 0;

if(_libssh2_get_string(&buf, &extname, &extname_len)) {

LIBSSH2_FREE(session, data);

_libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,

"Data too short when extracting extname");

goto sftp_init_error;

}

if(_libssh2_get_string(&buf, &extdata, &extdata_len)) {

LIBSSH2_FREE(session, data);

_libssh2_error(session, LIBSSH2_ERROR_BUFFER_TOO_SMALL,

"Data too short when extracting extdata");

goto sftp_init_error;

}

if(extdata_len > 0) {

char *extversion_str;

extversion_str = (char *)LIBSSH2_ALLOC(session, extdata_len + 1);

if(!extversion_str) {

_libssh2_error(session, LIBSSH2_ERROR_ALLOC,

"Unable to allocate memory for SSH_FXP_VERSION "

"packet");

goto sftp_init_error;

}

memcpy(extversion_str, extdata, extdata_len);

extversion_str[extdata_len] = '\0';

extversion = (uint32_t)strtol(extversion_str, NULL, 10);