--- /dev/null
+Index: config.w32
+===================================================================
+--- config.w32 (.../tags/RELEASE_0_11_0)
++++ config.w32 (.../trunk)
+@@ -0,0 +1,37 @@
++// $Id$
++// vim:ft=javascript
++
++ARG_WITH("ssh2", "SSH2 support", "no");
++
++if (PHP_SSH2 != "no") {
++ if ((((PHP_ZLIB=="no") && (CHECK_LIB("zlib_a.lib", "ssh2", PHP_SSH2) || CHECK_LIB("zlib.lib", "ssh2", PHP_SSH2))) ||
++ (PHP_ZLIB_SHARED && CHECK_LIB("zlib.lib", "ssh2", PHP_SSH2)) || (PHP_ZLIB == "yes" && (!PHP_ZLIB_SHARED))) &&
++ CHECK_LIB("libeay32.lib", "ssh2", PHP_SSH2) &&
++ CHECK_LIB("ssleay32.lib", "ssh2", PHP_SSH2) &&
++ CHECK_LIB("ws2_32.lib", "ssh2", PHP_SSH2)) {
++
++ // Use bundled lib if none installed, even if it is outdated.
++ if (!(CHECK_LIB("libssh2_a.lib;libssh2.lib", "ssh2", PHP_SSH2) &&
++ CHECK_HEADER_ADD_INCLUDE("libssh2.h", "CFLAGS_SSH2", PHP_PHP_BUILD + "\\include\\libssh2"))) {
++ FSO.CopyFile(configure_module_dirname + "\\libssh2\\src\\libssh2_config.h.in.w32",
++ configure_module_dirname + "\\libssh2\\src\\libssh2_config.h");
++
++ ADD_FLAG('CFLAGS_SSH2', '/DLIBSSH2_WIN32=1 /DLIBSSH2_API= /I ' +
++ configure_module_dirname + '/libssh2/include');
++ }
++
++ AC_DEFINE('HAVE_SSH2LIB', 1);
++ AC_DEFINE('PHP_SSH2_REMOTE_FORWARDING', 1);
++ AC_DEFINE('PHP_SSH2_HOSTBASED_AUTH', 1);
++ AC_DEFINE('PHP_SSH2_POLL', 1);
++ AC_DEFINE('PHP_SSH2_PUBLICKEY_SUBSYSTEM', 1);
++
++ EXTENSION("ssh2", "ssh2.c ssh2_fopen_wrappers.c ssh2_sftp.c");
++
++ ADD_SOURCES(configure_module_dirname + "/libssh2/src", "channel.c comp.c crypt.c \
++ hostkey.c kex.c mac.c misc.c openssl.c packet.c pem.c publickey.c scp.c \
++ session.c sftp.c transport.c userauth.c", "ssh2");
++ } else {
++ WARNING("ssh2 not enabled: libraries or headers not found");
++ }
++}
+
+Property changes on: config.w32
+___________________________________________________________________
+Added: svn:eol-style
+ + native
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.11
+
+Index: ssh2.c
+===================================================================
+--- ssh2.c (.../tags/RELEASE_0_11_0)
++++ ssh2.c (.../trunk)
+@@ -47,14 +47,9 @@
+ int le_ssh2_pkey_subsys;
+ #endif
+
+-#ifdef ZEND_ENGINE_2
+-static
+- ZEND_BEGIN_ARG_INFO(php_ssh2_first_arg_force_ref, 0)
+- ZEND_ARG_PASS_INFO(1)
+- ZEND_END_ARG_INFO()
+-#else
+-static unsigned char php_ssh2_first_arg_force_ref[] = { 1, BYREF_FORCE };
+-#endif
++ZEND_BEGIN_ARG_INFO(php_ssh2_first_arg_force_ref, 0)
++ ZEND_ARG_PASS_INFO(1)
++ZEND_END_ARG_INFO()
+
+ /* *************
+ * Callbacks *
+@@ -248,7 +243,7 @@
+ /* {{{ php_ssh2_set_callback
+ * Try to set a method if it's passed in with the hash table
+ */
+-static int php_ssh2_set_callback(LIBSSH2_SESSION *session, HashTable *ht, char *callback, int callback_len, int callback_type, php_ssh2_session_data *data)
++static int php_ssh2_set_callback(LIBSSH2_SESSION *session, HashTable *ht, char *callback, int callback_len, int callback_type, php_ssh2_session_data *data TSRMLS_DC)
+ {
+ zval **handler, *copyval;
+ void *internal_handler;
+@@ -257,7 +252,7 @@
+ return 0;
+ }
+
+- if (!handler || !*handler || !zend_is_callable(*handler, 0, NULL)) {
++ if (!handler || !*handler || !zend_is_callable(*handler, 0, NULL ZEND_IS_CALLABLE_TSRMLS_CC)) {
+ return -1;
+ }
+
+@@ -358,7 +353,7 @@
+ if (!session) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to initialize SSH2 session");
+ efree(data);
+- close(socket);
++ closesocket(socket);
+ return NULL;
+ }
+ libssh2_banner_set(session, LIBSSH2_SSH_DEFAULT_BANNER " PHP");
+@@ -411,19 +406,19 @@
+ if (callbacks) {
+ /* ignore debug disconnect macerror */
+
+- if (php_ssh2_set_callback(session, HASH_OF(callbacks), "ignore", sizeof("ignore") - 1, LIBSSH2_CALLBACK_IGNORE, data)) {
++ if (php_ssh2_set_callback(session, HASH_OF(callbacks), "ignore", sizeof("ignore") - 1, LIBSSH2_CALLBACK_IGNORE, data TSRMLS_CC)) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed setting IGNORE callback");
+ }
+
+- if (php_ssh2_set_callback(session, HASH_OF(callbacks), "debug", sizeof("debug") - 1, LIBSSH2_CALLBACK_DEBUG, data)) {
++ if (php_ssh2_set_callback(session, HASH_OF(callbacks), "debug", sizeof("debug") - 1, LIBSSH2_CALLBACK_DEBUG, data TSRMLS_CC)) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed setting DEBUG callback");
+ }
+
+- if (php_ssh2_set_callback(session, HASH_OF(callbacks), "macerror", sizeof("macerror") - 1, LIBSSH2_CALLBACK_MACERROR, data)) {
++ if (php_ssh2_set_callback(session, HASH_OF(callbacks), "macerror", sizeof("macerror") - 1, LIBSSH2_CALLBACK_MACERROR, data TSRMLS_CC)) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed setting MACERROR callback");
+ }
+
+- if (php_ssh2_set_callback(session, HASH_OF(callbacks), "disconnect", sizeof("disconnect") - 1, LIBSSH2_CALLBACK_DISCONNECT, data)) {
++ if (php_ssh2_set_callback(session, HASH_OF(callbacks), "disconnect", sizeof("disconnect") - 1, LIBSSH2_CALLBACK_DISCONNECT, data TSRMLS_CC)) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed setting DISCONNECT callback");
+ }
+ }
+@@ -434,7 +429,7 @@
+
+ last_error = libssh2_session_last_error(session, &error_msg, NULL, 0);
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error starting up SSH connection(%d): %s", last_error, error_msg);
+- close(socket);
++ closesocket(socket);
+ libssh2_session_free(session);
+ efree(data);
+ return NULL;
+@@ -1148,7 +1143,7 @@
+ zval_ptr_dtor(&(*data)->disconnect_cb);
+ }
+
+- close((*data)->socket);
++ closesocket((*data)->socket);
+
+ efree(*data);
+ *data = NULL;
+@@ -1274,7 +1269,7 @@
+
+ /* {{{ ssh2_functions[]
+ */
+-function_entry ssh2_functions[] = {
++zend_function_entry ssh2_functions[] = {
+ PHP_FE(ssh2_connect, NULL)
+ PHP_FE(ssh2_methods_negotiated, NULL)
+ PHP_FE(ssh2_fingerprint, NULL)
+
+Property changes on: ssh2.c
+___________________________________________________________________
+Modified: cvs2svn:cvs-rev
+ - 1.22
+ + 1.25
+
+Index: libssh2/include/libssh2_publickey.h
+===================================================================
+--- libssh2/include/libssh2_publickey.h (.../tags/RELEASE_0_11_0)
++++ libssh2/include/libssh2_publickey.h (.../trunk)
+@@ -0,0 +1,101 @@
++/* Copyright (c) 2004-2006, Sara Golemon <sarag@libssh2.org>
++ * 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.
++ */
++
++/* Note: This include file is only needed for using the
++ * publickey SUBSYSTEM which is not the same as publickey
++ * authentication. For authentication you only need libssh2.h
++ *
++ * For more information on the publickey subsystem,
++ * refer to IETF draft: secsh-publickey
++ */
++
++#ifndef LIBSSH2_PUBLICKEY_H
++#define LIBSSH2_PUBLICKEY_H 1
++
++typedef struct _LIBSSH2_PUBLICKEY LIBSSH2_PUBLICKEY;
++
++typedef struct _libssh2_publickey_attribute {
++ const char *name;
++ unsigned long name_len;
++ const char *value;
++ unsigned long value_len;
++ char mandatory;
++} libssh2_publickey_attribute;
++
++typedef struct _libssh2_publickey_list {
++ unsigned char *packet; /* For freeing */
++
++ const unsigned char *name;
++ unsigned long name_len;
++ const unsigned char *blob;
++ unsigned long blob_len;
++ unsigned long num_attrs;
++ libssh2_publickey_attribute *attrs; /* free me */
++} libssh2_publickey_list;
++
++/* Generally use the first macro here, but if both name and value are string literals, you can use _fast() to take advantage of preprocessing */
++#define libssh2_publickey_attribute(name, value, mandatory) { (name), strlen(name), (value), strlen(value), (mandatory) },
++#define libssh2_publickey_attribute_fast(name, value, mandatory) { (name), sizeof(name) - 1, (value), sizeof(value) - 1, (mandatory) },
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/* Publickey Subsystem */
++LIBSSH2_API LIBSSH2_PUBLICKEY *libssh2_publickey_init(LIBSSH2_SESSION *session);
++
++LIBSSH2_API int libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name, unsigned long name_len,
++ const unsigned char *blob, unsigned long blob_len, char overwrite,
++ unsigned long num_attrs, const libssh2_publickey_attribute attrs[]);
++#define libssh2_publickey_add(pkey, name, blob, blob_len, overwrite, num_attrs, attrs) \
++ libssh2_publickey_add_ex((pkey), (name), strlen(name), (blob), (blob_len), (overwrite), (num_attrs), (attrs))
++
++LIBSSH2_API int libssh2_publickey_remove_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name, unsigned long name_len,
++ const unsigned char *blob, unsigned long blob_len);
++#define libssh2_publickey_remove(pkey, name, blob, blob_len) \
++ libssh2_publickey_remove_ex((pkey), (name), strlen(name), (blob), (blob_len))
++
++LIBSSH2_API int libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY *pkey, unsigned long *num_keys, libssh2_publickey_list **pkey_list);
++LIBSSH2_API void libssh2_publickey_list_free(LIBSSH2_PUBLICKEY *pkey, libssh2_publickey_list *pkey_list);
++
++LIBSSH2_API int libssh2_publickey_shutdown(LIBSSH2_PUBLICKEY *pkey);
++
++#ifdef __cplusplus
++} /* extern "C" */
++#endif
++
++#endif /* ndef: LIBSSH2_PUBLICKEY_H */
+
+Property changes on: libssh2/include/libssh2_publickey.h
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.2
+Added: svn:eol-style
+ + native
+
+Index: libssh2/include/libssh2_sftp.h
+===================================================================
+--- libssh2/include/libssh2_sftp.h (.../tags/RELEASE_0_11_0)
++++ libssh2/include/libssh2_sftp.h (.../trunk)
+@@ -0,0 +1,251 @@
++/* Copyright (c) 2004-2008, Sara Golemon <sarag@libssh2.org>
++ * 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.
++ */
++
++#ifndef LIBSSH2_SFTP_H
++#define LIBSSH2_SFTP_H 1
++
++#ifndef WIN32
++#include <unistd.h>
++#endif
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/* Note: Version 6 was documented at the time of writing
++ * However it was marked as "DO NOT IMPLEMENT" due to pending changes
++ *
++ * Let's start with Version 3 (The version found in OpenSSH) and go from there
++ */
++#define LIBSSH2_SFTP_VERSION 3
++#define LIBSSH2_SFTP_PACKET_MAXLEN 40000
++
++typedef struct _LIBSSH2_SFTP LIBSSH2_SFTP;
++typedef struct _LIBSSH2_SFTP_HANDLE LIBSSH2_SFTP_HANDLE;
++typedef struct _LIBSSH2_SFTP_ATTRIBUTES LIBSSH2_SFTP_ATTRIBUTES;
++
++/* Flags for open_ex() */
++#define LIBSSH2_SFTP_OPENFILE 0
++#define LIBSSH2_SFTP_OPENDIR 1
++
++/* Flags for rename_ex() */
++#define LIBSSH2_SFTP_RENAME_OVERWRITE 0x00000001
++#define LIBSSH2_SFTP_RENAME_ATOMIC 0x00000002
++#define LIBSSH2_SFTP_RENAME_NATIVE 0x00000004
++
++/* Flags for stat_ex() */
++#define LIBSSH2_SFTP_STAT 0
++#define LIBSSH2_SFTP_LSTAT 1
++#define LIBSSH2_SFTP_SETSTAT 2
++
++/* Flags for symlink_ex() */
++#define LIBSSH2_SFTP_SYMLINK 0
++#define LIBSSH2_SFTP_READLINK 1
++#define LIBSSH2_SFTP_REALPATH 2
++
++/* SFTP attribute flag bits */
++#define LIBSSH2_SFTP_ATTR_SIZE 0x00000001
++#define LIBSSH2_SFTP_ATTR_UIDGID 0x00000002
++#define LIBSSH2_SFTP_ATTR_PERMISSIONS 0x00000004
++#define LIBSSH2_SFTP_ATTR_ACMODTIME 0x00000008
++#define LIBSSH2_SFTP_ATTR_EXTENDED 0x80000000
++
++struct _LIBSSH2_SFTP_ATTRIBUTES {
++ /* If flags & ATTR_* bit is set, then the value in this struct will be meaningful
++ * Otherwise it should be ignored
++ */
++ unsigned long flags;
++
++ libssh2_uint64_t filesize;
++ unsigned long uid, gid;
++ unsigned long permissions;
++ unsigned long atime, mtime;
++};
++
++/* SFTP filetypes */
++#define LIBSSH2_SFTP_TYPE_REGULAR 1
++#define LIBSSH2_SFTP_TYPE_DIRECTORY 2
++#define LIBSSH2_SFTP_TYPE_SYMLINK 3
++#define LIBSSH2_SFTP_TYPE_SPECIAL 4
++#define LIBSSH2_SFTP_TYPE_UNKNOWN 5
++#define LIBSSH2_SFTP_TYPE_SOCKET 6
++#define LIBSSH2_SFTP_TYPE_CHAR_DEVICE 7
++#define LIBSSH2_SFTP_TYPE_BLOCK_DEVICE 8
++#define LIBSSH2_SFTP_TYPE_FIFO 9
++
++/*
++ * Reproduce the POSIX file modes here for systems that are not
++ * POSIX compliant.
++ *
++ * These is used in "permissions" of "struct _LIBSSH2_SFTP_ATTRIBUTES"
++ */
++/* File type */
++#define LIBSSH2_SFTP_S_IFMT 0170000 /* type of file mask */
++#define LIBSSH2_SFTP_S_IFIFO 0010000 /* named pipe (fifo) */
++#define LIBSSH2_SFTP_S_IFCHR 0020000 /* character special */
++#define LIBSSH2_SFTP_S_IFDIR 0040000 /* directory */
++#define LIBSSH2_SFTP_S_IFBLK 0060000 /* block special */
++#define LIBSSH2_SFTP_S_IFREG 0100000 /* regular */
++#define LIBSSH2_SFTP_S_IFLNK 0120000 /* symbolic link */
++#define LIBSSH2_SFTP_S_IFSOCK 0140000 /* socket */
++
++/* File mode */
++/* Read, write, execute/search by owner */
++#define LIBSSH2_SFTP_S_IRWXU 0000700 /* RWX mask for owner */
++#define LIBSSH2_SFTP_S_IRUSR 0000400 /* R for owner */
++#define LIBSSH2_SFTP_S_IWUSR 0000200 /* W for owner */
++#define LIBSSH2_SFTP_S_IXUSR 0000100 /* X for owner */
++/* Read, write, execute/search by group */
++#define LIBSSH2_SFTP_S_IRWXG 0000070 /* RWX mask for group */
++#define LIBSSH2_SFTP_S_IRGRP 0000040 /* R for group */
++#define LIBSSH2_SFTP_S_IWGRP 0000020 /* W for group */
++#define LIBSSH2_SFTP_S_IXGRP 0000010 /* X for group */
++/* Read, write, execute/search by others */
++#define LIBSSH2_SFTP_S_IRWXO 0000007 /* RWX mask for other */
++#define LIBSSH2_SFTP_S_IROTH 0000004 /* R for other */
++#define LIBSSH2_SFTP_S_IWOTH 0000002 /* W for other */
++#define LIBSSH2_SFTP_S_IXOTH 0000001 /* X for other */
++
++/* SFTP File Transfer Flags -- (e.g. flags parameter to sftp_open())
++ * Danger will robinson... APPEND doesn't have any effect on OpenSSH servers */
++#define LIBSSH2_FXF_READ 0x00000001
++#define LIBSSH2_FXF_WRITE 0x00000002
++#define LIBSSH2_FXF_APPEND 0x00000004
++#define LIBSSH2_FXF_CREAT 0x00000008
++#define LIBSSH2_FXF_TRUNC 0x00000010
++#define LIBSSH2_FXF_EXCL 0x00000020
++
++/* SFTP Status Codes (returned by libssh2_sftp_last_error() ) */
++#define LIBSSH2_FX_OK 0
++#define LIBSSH2_FX_EOF 1
++#define LIBSSH2_FX_NO_SUCH_FILE 2
++#define LIBSSH2_FX_PERMISSION_DENIED 3
++#define LIBSSH2_FX_FAILURE 4
++#define LIBSSH2_FX_BAD_MESSAGE 5
++#define LIBSSH2_FX_NO_CONNECTION 6
++#define LIBSSH2_FX_CONNECTION_LOST 7
++#define LIBSSH2_FX_OP_UNSUPPORTED 8
++#define LIBSSH2_FX_INVALID_HANDLE 9
++#define LIBSSH2_FX_NO_SUCH_PATH 10
++#define LIBSSH2_FX_FILE_ALREADY_EXISTS 11
++#define LIBSSH2_FX_WRITE_PROTECT 12
++#define LIBSSH2_FX_NO_MEDIA 13
++#define LIBSSH2_FX_NO_SPACE_ON_FILESYSTEM 14
++#define LIBSSH2_FX_QUOTA_EXCEEDED 15
++#define LIBSSH2_FX_UNKNOWN_PRINCIPLE 16 /* Initial mis-spelling */
++#define LIBSSH2_FX_UNKNOWN_PRINCIPAL 16
++#define LIBSSH2_FX_LOCK_CONFlICT 17 /* Initial mis-spelling */
++#define LIBSSH2_FX_LOCK_CONFLICT 17
++#define LIBSSH2_FX_DIR_NOT_EMPTY 18
++#define LIBSSH2_FX_NOT_A_DIRECTORY 19
++#define LIBSSH2_FX_INVALID_FILENAME 20
++#define LIBSSH2_FX_LINK_LOOP 21
++
++/* Returned by any function that would block during a read/write opperation */
++#define LIBSSH2SFTP_EAGAIN LIBSSH2_ERROR_EAGAIN
++
++/* SFTP API */
++LIBSSH2_API LIBSSH2_SFTP *libssh2_sftp_init(LIBSSH2_SESSION *session);
++LIBSSH2_API int libssh2_sftp_shutdown(LIBSSH2_SFTP *sftp);
++LIBSSH2_API unsigned long libssh2_sftp_last_error(LIBSSH2_SFTP *sftp);
++
++/* File / Directory Ops */
++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);
++#define libssh2_sftp_open(sftp, filename, flags, mode) \
++ libssh2_sftp_open_ex((sftp), (filename), strlen(filename), (flags), (mode), LIBSSH2_SFTP_OPENFILE)
++#define libssh2_sftp_opendir(sftp, path) \
++ libssh2_sftp_open_ex((sftp), (path), strlen(path), 0, 0, LIBSSH2_SFTP_OPENDIR)
++
++LIBSSH2_API ssize_t libssh2_sftp_read(LIBSSH2_SFTP_HANDLE *handle, char *buffer, size_t buffer_maxlen);
++
++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);
++#define libssh2_sftp_readdir(handle, buffer, buffer_maxlen, attrs) \
++ libssh2_sftp_readdir_ex((handle), (buffer), (buffer_maxlen), NULL, 0, (attrs))
++
++LIBSSH2_API ssize_t libssh2_sftp_write(LIBSSH2_SFTP_HANDLE *handle, const char *buffer, size_t count);
++
++LIBSSH2_API int libssh2_sftp_close_handle(LIBSSH2_SFTP_HANDLE *handle);
++#define libssh2_sftp_close(handle) libssh2_sftp_close_handle(handle)
++#define libssh2_sftp_closedir(handle) libssh2_sftp_close_handle(handle)
++
++LIBSSH2_API void libssh2_sftp_seek(LIBSSH2_SFTP_HANDLE *handle, size_t offset);
++LIBSSH2_API void libssh2_sftp_seek64(LIBSSH2_SFTP_HANDLE *handle, libssh2_uint64_t offset);
++#define libssh2_sftp_rewind(handle) libssh2_sftp_seek64((handle), 0)
++
++LIBSSH2_API size_t libssh2_sftp_tell(LIBSSH2_SFTP_HANDLE *handle);
++LIBSSH2_API libssh2_uint64_t libssh2_sftp_tell64(LIBSSH2_SFTP_HANDLE *handle);
++
++LIBSSH2_API int libssh2_sftp_fstat_ex(LIBSSH2_SFTP_HANDLE *handle, LIBSSH2_SFTP_ATTRIBUTES *attrs, int setstat);
++#define libssh2_sftp_fstat(handle, attrs) libssh2_sftp_fstat_ex((handle), (attrs), 0)
++#define libssh2_sftp_fsetstat(handle, attrs) libssh2_sftp_fstat_ex((handle), (attrs), 1)
++
++
++
++/* Miscellaneous Ops */
++LIBSSH2_API int libssh2_sftp_rename_ex(LIBSSH2_SFTP *sftp, const char *source_filename, unsigned int srouce_filename_len,
++ const char *dest_filename, unsigned int dest_filename_len,
++ long flags);
++#define libssh2_sftp_rename(sftp, sourcefile, destfile) libssh2_sftp_rename_ex((sftp), (sourcefile), strlen(sourcefile), (destfile), strlen(destfile), \
++ LIBSSH2_SFTP_RENAME_OVERWRITE | LIBSSH2_SFTP_RENAME_ATOMIC | LIBSSH2_SFTP_RENAME_NATIVE)
++
++LIBSSH2_API int libssh2_sftp_unlink_ex(LIBSSH2_SFTP *sftp, const char *filename, unsigned int filename_len);
++#define libssh2_sftp_unlink(sftp, filename) libssh2_sftp_unlink_ex((sftp), (filename), strlen(filename))
++
++LIBSSH2_API int libssh2_sftp_mkdir_ex(LIBSSH2_SFTP *sftp, const char *path, unsigned int path_len, long mode);
++#define libssh2_sftp_mkdir(sftp, path, mode) libssh2_sftp_mkdir_ex((sftp), (path), strlen(path), (mode))
++
++LIBSSH2_API int libssh2_sftp_rmdir_ex(LIBSSH2_SFTP *sftp, const char *path, unsigned int path_len);
++#define libssh2_sftp_rmdir(sftp, path) libssh2_sftp_rmdir_ex((sftp), (path), strlen(path))
++
++LIBSSH2_API int libssh2_sftp_stat_ex(LIBSSH2_SFTP *sftp, const char *path, unsigned int path_len, int stat_type, LIBSSH2_SFTP_ATTRIBUTES *attrs);
++#define libssh2_sftp_stat(sftp, path, attrs) libssh2_sftp_stat_ex((sftp), (path), strlen(path), LIBSSH2_SFTP_STAT, (attrs))
++#define libssh2_sftp_lstat(sftp, path, attrs) libssh2_sftp_stat_ex((sftp), (path), strlen(path), LIBSSH2_SFTP_LSTAT, (attrs))
++#define libssh2_sftp_setstat(sftp, path, attrs) libssh2_sftp_stat_ex((sftp), (path), strlen(path), LIBSSH2_SFTP_SETSTAT, (attrs))
++
++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);
++#define libssh2_sftp_symlink(sftp, orig, linkpath) libssh2_sftp_symlink_ex((sftp), (orig), strlen(orig), (linkpath), strlen(linkpath), LIBSSH2_SFTP_SYMLINK)
++#define libssh2_sftp_readlink(sftp, path, target, maxlen) libssh2_sftp_symlink_ex((sftp), (path), strlen(path), (target), (maxlen), LIBSSH2_SFTP_READLINK)
++#define libssh2_sftp_realpath(sftp, path, target, maxlen) libssh2_sftp_symlink_ex((sftp), (path), strlen(path), (target), (maxlen), LIBSSH2_SFTP_REALPATH)
++
++#ifdef __cplusplus
++} /* extern "C" */
++#endif
++
++#endif /* LIBSSH2_SFTP_H */
+
+Property changes on: libssh2/include/libssh2_sftp.h
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.2
+Added: svn:eol-style
+ + native
+
+Index: libssh2/include/libssh2.h
+===================================================================
+--- libssh2/include/libssh2.h (.../tags/RELEASE_0_11_0)
++++ libssh2/include/libssh2.h (.../trunk)
+@@ -0,0 +1,489 @@
++/* Copyright (c) 2004-2008, Sara Golemon <sarag@libssh2.org>
++ * 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.
++ */
++
++#ifndef LIBSSH2_H
++#define LIBSSH2_H 1
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#include <stddef.h>
++#include <string.h>
++#include <sys/stat.h>
++#include <sys/types.h>
++
++/* Allow alternate API prefix from CFLAGS or calling app */
++#ifndef LIBSSH2_API
++# ifdef LIBSSH2_WIN32
++# ifdef LIBSSH2_LIBRARY
++# define LIBSSH2_API __declspec(dllexport)
++# else
++# define LIBSSH2_API __declspec(dllimport)
++# endif /* LIBSSH2_LIBRARY */
++# else /* !LIBSSH2_WIN32 */
++# define LIBSSH2_API
++# endif /* LIBSSH2_WIN32 */
++#endif /* LIBSSH2_API */
++
++#if defined(LIBSSH2_DARWIN) || (defined(LIBSSH2_WIN32) && !defined(_MSC_VER) && !defined(__MINGW32__))
++# include <sys/uio.h>
++#endif
++
++#if (defined(NETWARE) && !defined(__NOVELL_LIBC__))
++# include <sys/bsdskt.h>
++typedef unsigned int uint32_t;
++#endif
++
++#if defined(LIBSSH2_WIN32) && defined(_MSC_VER) && (_MSC_VER <= 1400)
++typedef unsigned __int64 libssh2_uint64_t;
++typedef __int64 libssh2_int64_t;
++typedef unsigned int uint32_t;
++#ifndef _SSIZE_T_DEFINED
++typedef int ssize_t;
++#define _SSIZE_T_DEFINED
++#endif
++#else
++typedef unsigned long long libssh2_uint64_t;
++typedef long long libssh2_int64_t;
++#endif
++
++/* We use underscore instead of dash when appending CVS in dev versions just
++ to make the BANNER define (used by src/session.c) be a valid SSH
++ banner. Release versions have no appended strings and may of coruse not
++ have dashes either. */
++#define LIBSSH2_VERSION "1.0"
++
++/* The numeric version number is also available "in parts" by using these
++ defines: */
++#define LIBSSH2_VERSION_MAJOR 1
++#define LIBSSH2_VERSION_MINOR 0
++#define LIBSSH2_VERSION_PATCH
++
++/* This is the numeric version of the libssh2 version number, meant for easier
++ parsing and comparions by programs. The LIBSSH2_VERSION_NUM define will
++ always follow this syntax:
++
++ 0xXXYYZZ
++
++ Where XX, YY and ZZ are the main version, release and patch numbers in
++ hexadecimal (using 8 bits each). All three numbers are always represented
++ using two digits. 1.2 would appear as "0x010200" while version 9.11.7
++ appears as "0x090b07".
++
++ This 6-digit (24 bits) hexadecimal number does not show pre-release number,
++ and it is always a greater number in a more recent release. It makes
++ comparisons with greater than and less than work.
++*/
++#define LIBSSH2_VERSION_NUM 0x010000
++
++/*
++ * This is the date and time when the full source package was created. The
++ * timestamp is not stored in CVS, as the timestamp is properly set in the
++ * tarballs by the maketgz script.
++ *
++ * The format of the date should follow this template:
++ *
++ * "Mon Feb 12 11:35:33 UTC 2007"
++ */
++#define LIBSSH2_TIMESTAMP "Fri Dec 26 21:35:07 UTC 2008"
++
++/* Part of every banner, user specified or not */
++#define LIBSSH2_SSH_BANNER "SSH-2.0-libssh2_" LIBSSH2_VERSION
++
++/* We *could* add a comment here if we so chose */
++#define LIBSSH2_SSH_DEFAULT_BANNER LIBSSH2_SSH_BANNER
++#define LIBSSH2_SSH_DEFAULT_BANNER_WITH_CRLF LIBSSH2_SSH_DEFAULT_BANNER "\r\n"
++
++/* Default generate and safe prime sizes for diffie-hellman-group-exchange-sha1 */
++#define LIBSSH2_DH_GEX_MINGROUP 1024
++#define LIBSSH2_DH_GEX_OPTGROUP 1536
++#define LIBSSH2_DH_GEX_MAXGROUP 2048
++
++/* Defaults for pty requests */
++#define LIBSSH2_TERM_WIDTH 80
++#define LIBSSH2_TERM_HEIGHT 24
++#define LIBSSH2_TERM_WIDTH_PX 0
++#define LIBSSH2_TERM_HEIGHT_PX 0
++
++/* 1/4 second */
++#define LIBSSH2_SOCKET_POLL_UDELAY 250000
++/* 0.25 * 120 == 30 seconds */
++#define LIBSSH2_SOCKET_POLL_MAXLOOPS 120
++
++/* Maximum size to allow a payload to compress to, plays it safe by falling short of spec limits */
++#define LIBSSH2_PACKET_MAXCOMP 32000
++
++/* Maximum size to allow a payload to deccompress to, plays it safe by allowing more than spec requires */
++#define LIBSSH2_PACKET_MAXDECOMP 40000
++
++/* Maximum size for an inbound compressed payload, plays it safe by overshooting spec limits */
++#define LIBSSH2_PACKET_MAXPAYLOAD 40000
++
++/* Malloc callbacks */
++#define LIBSSH2_ALLOC_FUNC(name) void *name(size_t count, void **abstract)
++#define LIBSSH2_REALLOC_FUNC(name) void *name(void *ptr, size_t count, void **abstract)
++#define LIBSSH2_FREE_FUNC(name) void name(void *ptr, void **abstract)
++
++typedef struct _LIBSSH2_USERAUTH_KBDINT_PROMPT
++{
++ char* text;
++ unsigned int length;
++ unsigned char echo;
++} LIBSSH2_USERAUTH_KBDINT_PROMPT;
++
++typedef struct _LIBSSH2_USERAUTH_KBDINT_RESPONSE
++{
++ char* text;
++ unsigned int length;
++} LIBSSH2_USERAUTH_KBDINT_RESPONSE;
++
++/* 'keyboard-interactive' authentication callback */
++#define LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC(name_) void name_(const char* name, int name_len, const char* instruction, int instruction_len, int num_prompts, const LIBSSH2_USERAUTH_KBDINT_PROMPT* prompts, LIBSSH2_USERAUTH_KBDINT_RESPONSE* responses, void **abstract)
++
++/* Callbacks for special SSH packets */
++#define LIBSSH2_IGNORE_FUNC(name) void name(LIBSSH2_SESSION *session, const char *message, int message_len, void **abstract)
++#define LIBSSH2_DEBUG_FUNC(name) void name(LIBSSH2_SESSION *session, int always_display, const char *message, int message_len, const char *language, int language_len,void **abstract)
++#define LIBSSH2_DISCONNECT_FUNC(name) void name(LIBSSH2_SESSION *session, int reason, const char *message, int message_len, const char *language, int language_len, void **abstract)
++#define LIBSSH2_PASSWD_CHANGEREQ_FUNC(name) void name(LIBSSH2_SESSION *session, char **newpw, int *newpw_len, void **abstract)
++#define LIBSSH2_MACERROR_FUNC(name) int name(LIBSSH2_SESSION *session, const char *packet, int packet_len, void **abstract)
++#define LIBSSH2_X11_OPEN_FUNC(name) void name(LIBSSH2_SESSION *session, LIBSSH2_CHANNEL *channel, const char *shost, int sport, void **abstract)
++
++#define LIBSSH2_CHANNEL_CLOSE_FUNC(name) void name(LIBSSH2_SESSION *session, void **session_abstract, LIBSSH2_CHANNEL *channel, void **channel_abstract)
++
++/* libssh2_session_callback_set() constants */
++#define LIBSSH2_CALLBACK_IGNORE 0
++#define LIBSSH2_CALLBACK_DEBUG 1
++#define LIBSSH2_CALLBACK_DISCONNECT 2
++#define LIBSSH2_CALLBACK_MACERROR 3
++#define LIBSSH2_CALLBACK_X11 4
++
++/* libssh2_session_method_pref() constants */
++#define LIBSSH2_METHOD_KEX 0
++#define LIBSSH2_METHOD_HOSTKEY 1
++#define LIBSSH2_METHOD_CRYPT_CS 2
++#define LIBSSH2_METHOD_CRYPT_SC 3
++#define LIBSSH2_METHOD_MAC_CS 4
++#define LIBSSH2_METHOD_MAC_SC 5
++#define LIBSSH2_METHOD_COMP_CS 6
++#define LIBSSH2_METHOD_COMP_SC 7
++#define LIBSSH2_METHOD_LANG_CS 8
++#define LIBSSH2_METHOD_LANG_SC 9
++
++/* session.flags bits */
++#define LIBSSH2_FLAG_SIGPIPE 0x00000001
++
++typedef struct _LIBSSH2_SESSION LIBSSH2_SESSION;
++typedef struct _LIBSSH2_CHANNEL LIBSSH2_CHANNEL;
++typedef struct _LIBSSH2_LISTENER LIBSSH2_LISTENER;
++
++typedef struct _LIBSSH2_POLLFD {
++ unsigned char type; /* LIBSSH2_POLLFD_* below */
++
++ union {
++ int socket; /* File descriptors -- examined with system select() call */
++ LIBSSH2_CHANNEL *channel; /* Examined by checking internal state */
++ LIBSSH2_LISTENER *listener; /* Read polls only -- are inbound connections waiting to be accepted? */
++ } fd;
++
++ unsigned long events; /* Requested Events */
++ unsigned long revents; /* Returned Events */
++} LIBSSH2_POLLFD;
++
++/* Poll FD Descriptor Types */
++#define LIBSSH2_POLLFD_SOCKET 1
++#define LIBSSH2_POLLFD_CHANNEL 2
++#define LIBSSH2_POLLFD_LISTENER 3
++
++/* Note: Win32 Doesn't actually have a poll() implementation, so some of these values are faked with select() data */
++/* Poll FD events/revents -- Match sys/poll.h where possible */
++#define LIBSSH2_POLLFD_POLLIN 0x0001 /* Data available to be read or connection available -- All */
++#define LIBSSH2_POLLFD_POLLPRI 0x0002 /* Priority data available to be read -- Socket only */
++#define LIBSSH2_POLLFD_POLLEXT 0x0002 /* Extended data available to be read -- Channel only */
++#define LIBSSH2_POLLFD_POLLOUT 0x0004 /* Can may be written -- Socket/Channel */
++/* revents only */
++#define LIBSSH2_POLLFD_POLLERR 0x0008 /* Error Condition -- Socket */
++#define LIBSSH2_POLLFD_POLLHUP 0x0010 /* HangUp/EOF -- Socket */
++#define LIBSSH2_POLLFD_SESSION_CLOSED 0x0010 /* Session Disconnect */
++#define LIBSSH2_POLLFD_POLLNVAL 0x0020 /* Invalid request -- Socket Only */
++#define LIBSSH2_POLLFD_POLLEX 0x0040 /* Exception Condition -- Socket/Win32 */
++#define LIBSSH2_POLLFD_CHANNEL_CLOSED 0x0080 /* Channel Disconnect */
++#define LIBSSH2_POLLFD_LISTENER_CLOSED 0x0080 /* Listener Disconnect */
++
++#define HAVE_LIBSSH2_SESSION_BLOCK_DIRECTION
++/* Block Direction Types */
++#define LIBSSH2_SESSION_BLOCK_INBOUND 0x0001
++#define LIBSSH2_SESSION_BLOCK_OUTBOUND 0x0002
++
++/* Hash Types */
++#define LIBSSH2_HOSTKEY_HASH_MD5 1
++#define LIBSSH2_HOSTKEY_HASH_SHA1 2
++
++/* Disconnect Codes (defined by SSH protocol) */
++#define SSH_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT 1
++#define SSH_DISCONNECT_PROTOCOL_ERROR 2
++#define SSH_DISCONNECT_KEY_EXCHANGE_FAILED 3
++#define SSH_DISCONNECT_RESERVED 4
++#define SSH_DISCONNECT_MAC_ERROR 5
++#define SSH_DISCONNECT_COMPRESSION_ERROR 6
++#define SSH_DISCONNECT_SERVICE_NOT_AVAILABLE 7
++#define SSH_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED 8
++#define SSH_DISCONNECT_HOST_KEY_NOT_VERIFIABLE 9
++#define SSH_DISCONNECT_CONNECTION_LOST 10
++#define SSH_DISCONNECT_BY_APPLICATION 11
++#define SSH_DISCONNECT_TOO_MANY_CONNECTIONS 12
++#define SSH_DISCONNECT_AUTH_CANCELLED_BY_USER 13
++#define SSH_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE 14
++#define SSH_DISCONNECT_ILLEGAL_USER_NAME 15
++
++/* Error Codes (defined by libssh2) */
++#define LIBSSH2_ERROR_NONE 0
++#define LIBSSH2_ERROR_SOCKET_NONE -1
++#define LIBSSH2_ERROR_BANNER_NONE -2
++#define LIBSSH2_ERROR_BANNER_SEND -3
++#define LIBSSH2_ERROR_INVALID_MAC -4
++#define LIBSSH2_ERROR_KEX_FAILURE -5
++#define LIBSSH2_ERROR_ALLOC -6
++#define LIBSSH2_ERROR_SOCKET_SEND -7
++#define LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE -8
++#define LIBSSH2_ERROR_TIMEOUT -9
++#define LIBSSH2_ERROR_HOSTKEY_INIT -10
++#define LIBSSH2_ERROR_HOSTKEY_SIGN -11
++#define LIBSSH2_ERROR_DECRYPT -12
++#define LIBSSH2_ERROR_SOCKET_DISCONNECT -13
++#define LIBSSH2_ERROR_PROTO -14
++#define LIBSSH2_ERROR_PASSWORD_EXPIRED -15
++#define LIBSSH2_ERROR_FILE -16
++#define LIBSSH2_ERROR_METHOD_NONE -17
++#define LIBSSH2_ERROR_PUBLICKEY_UNRECOGNIZED -18
++#define LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED -19
++#define LIBSSH2_ERROR_CHANNEL_OUTOFORDER -20
++#define LIBSSH2_ERROR_CHANNEL_FAILURE -21
++#define LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED -22
++#define LIBSSH2_ERROR_CHANNEL_UNKNOWN -23
++#define LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED -24
++#define LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED -25
++#define LIBSSH2_ERROR_CHANNEL_CLOSED -26
++#define LIBSSH2_ERROR_CHANNEL_EOF_SENT -27
++#define LIBSSH2_ERROR_SCP_PROTOCOL -28
++#define LIBSSH2_ERROR_ZLIB -29
++#define LIBSSH2_ERROR_SOCKET_TIMEOUT -30
++#define LIBSSH2_ERROR_SFTP_PROTOCOL -31
++#define LIBSSH2_ERROR_REQUEST_DENIED -32
++#define LIBSSH2_ERROR_METHOD_NOT_SUPPORTED -33
++#define LIBSSH2_ERROR_INVAL -34
++#define LIBSSH2_ERROR_INVALID_POLL_TYPE -35
++#define LIBSSH2_ERROR_PUBLICKEY_PROTOCOL -36
++#define LIBSSH2_ERROR_EAGAIN -37
++
++/* Session API */
++LIBSSH2_API LIBSSH2_SESSION *libssh2_session_init_ex(LIBSSH2_ALLOC_FUNC((*my_alloc)), LIBSSH2_FREE_FUNC((*my_free)), LIBSSH2_REALLOC_FUNC((*my_realloc)), void *abstract);
++#define libssh2_session_init() libssh2_session_init_ex(NULL, NULL, NULL, NULL)
++LIBSSH2_API void **libssh2_session_abstract(LIBSSH2_SESSION *session);
++
++LIBSSH2_API void *libssh2_session_callback_set(LIBSSH2_SESSION *session, int cbtype, void *callback);
++LIBSSH2_API int libssh2_banner_set(LIBSSH2_SESSION *session, const char *banner);
++
++LIBSSH2_API int libssh2_session_startup(LIBSSH2_SESSION *session, int sock);
++LIBSSH2_API int libssh2_session_disconnect_ex(LIBSSH2_SESSION *session, int reason, const char *description, const char *lang);
++#define libssh2_session_disconnect(session, description) libssh2_session_disconnect_ex((session), SSH_DISCONNECT_BY_APPLICATION, (description), "")
++LIBSSH2_API int libssh2_session_free(LIBSSH2_SESSION *session);
++
++LIBSSH2_API const char *libssh2_hostkey_hash(LIBSSH2_SESSION *session, int hash_type);
++
++LIBSSH2_API int libssh2_session_method_pref(LIBSSH2_SESSION *session, int method_type, const char *prefs);
++LIBSSH2_API const char *libssh2_session_methods(LIBSSH2_SESSION *session, int method_type);
++LIBSSH2_API int libssh2_session_last_error(LIBSSH2_SESSION *session, char **errmsg, int *errmsg_len, int want_buf);
++LIBSSH2_API int libssh2_session_last_errno(LIBSSH2_SESSION *session);
++LIBSSH2_API int libssh2_session_block_directions(LIBSSH2_SESSION *session);
++
++LIBSSH2_API int libssh2_session_flag(LIBSSH2_SESSION *session, int flag, int value);
++
++/* Userauth API */
++LIBSSH2_API char *libssh2_userauth_list(LIBSSH2_SESSION *session, const char *username, unsigned int username_len);
++LIBSSH2_API int libssh2_userauth_authenticated(LIBSSH2_SESSION *session);
++LIBSSH2_API int libssh2_userauth_password_ex(LIBSSH2_SESSION *session, const char *username, unsigned int username_len, const char *password, unsigned int password_len, LIBSSH2_PASSWD_CHANGEREQ_FUNC((*passwd_change_cb)));
++#define libssh2_userauth_password(session, username, password) libssh2_userauth_password_ex((session), (username), strlen(username), (password), strlen(password), NULL)
++
++LIBSSH2_API int libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION *session, const char *username, unsigned int username_len,
++ const char *publickey, const char *privatekey,
++ const char *passphrase);
++#define libssh2_userauth_publickey_fromfile(session, username, publickey, privatekey, passphrase) \
++ libssh2_userauth_publickey_fromfile_ex((session), (username), strlen(username), (publickey), (privatekey), (passphrase))
++LIBSSH2_API int libssh2_userauth_hostbased_fromfile_ex(LIBSSH2_SESSION *session, const char *username, unsigned int username_len,
++ const char *publickey, const char *privatekey,
++ const char *passphrase,
++ const char *hostname, unsigned int hostname_len,
++ const char *local_username, unsigned int local_username_len);
++#define libssh2_userauth_hostbased_fromfile(session, username, publickey, privatekey, passphrase, hostname) \
++ libssh2_userauth_hostbased_fromfile_ex((session), (username), strlen(username), (publickey), (privatekey), (passphrase), (hostname), strlen(hostname), (username), strlen(username))
++
++/*
++ * response_callback is provided with filled by library prompts array,
++ * but client must allocate and fill individual responses. Responses
++ * array is already allocated. Responses data will be freed by libssh2
++ * after callback return, but before subsequent callback invokation.
++ */
++LIBSSH2_API int libssh2_userauth_keyboard_interactive_ex(LIBSSH2_SESSION* session, const char *username, unsigned int username_len,
++ LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC((*response_callback)));
++#define libssh2_userauth_keyboard_interactive(session, username, response_callback) \
++ libssh2_userauth_keyboard_interactive_ex((session), (username), strlen(username), (response_callback))
++
++LIBSSH2_API int libssh2_poll(LIBSSH2_POLLFD *fds, unsigned int nfds, long timeout);
++
++/* Channel API */
++#define LIBSSH2_CHANNEL_WINDOW_DEFAULT 65536
++#define LIBSSH2_CHANNEL_PACKET_DEFAULT 16384
++#define LIBSSH2_CHANNEL_MINADJUST 1024
++
++/* Extended Data Handling */
++#define LIBSSH2_CHANNEL_EXTENDED_DATA_NORMAL 0
++#define LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE 1
++#define LIBSSH2_CHANNEL_EXTENDED_DATA_MERGE 2
++
++#define SSH_EXTENDED_DATA_STDERR 1
++
++/* Returned by any function that would block during a read/write opperation */
++#define LIBSSH2CHANNEL_EAGAIN LIBSSH2_ERROR_EAGAIN
++
++LIBSSH2_API LIBSSH2_CHANNEL *libssh2_channel_open_ex(LIBSSH2_SESSION *session, const char *channel_type, unsigned int channel_type_len, unsigned int window_size, unsigned int packet_size, const char *message, unsigned int message_len);
++#define libssh2_channel_open_session(session) libssh2_channel_open_ex((session), "session", sizeof("session") - 1, LIBSSH2_CHANNEL_WINDOW_DEFAULT, LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL, 0)
++
++LIBSSH2_API LIBSSH2_CHANNEL *libssh2_channel_direct_tcpip_ex(LIBSSH2_SESSION *session, const char *host, int port, const char *shost, int sport);
++#define libssh2_channel_direct_tcpip(session, host, port) libssh2_channel_direct_tcpip_ex((session), (host), (port), "127.0.0.1", 22)
++
++LIBSSH2_API LIBSSH2_LISTENER *libssh2_channel_forward_listen_ex(LIBSSH2_SESSION *session, const char *host, int port, int *bound_port, int queue_maxsize);
++#define libssh2_channel_forward_listen(session, port) libssh2_channel_forward_listen_ex((session), NULL, (port), NULL, 16)
++
++LIBSSH2_API int libssh2_channel_forward_cancel(LIBSSH2_LISTENER *listener);
++
++LIBSSH2_API LIBSSH2_CHANNEL *libssh2_channel_forward_accept(LIBSSH2_LISTENER *listener);
++
++LIBSSH2_API int libssh2_channel_setenv_ex(LIBSSH2_CHANNEL *channel, const char *varname, unsigned int varname_len, const char *value, unsigned int value_len);
++#define libssh2_channel_setenv(channel, varname, value) libssh2_channel_setenv_ex((channel), (varname), strlen(varname), (value), strlen(value))
++
++LIBSSH2_API int libssh2_channel_request_pty_ex(LIBSSH2_CHANNEL *channel, const char *term, unsigned int term_len, const char *modes, unsigned int modes_len, int width, int height, int width_px, int height_px);
++#define libssh2_channel_request_pty(channel, term) libssh2_channel_request_pty_ex((channel), (term), strlen(term), NULL, 0, LIBSSH2_TERM_WIDTH, LIBSSH2_TERM_HEIGHT, LIBSSH2_TERM_WIDTH_PX, LIBSSH2_TERM_HEIGHT_PX)
++
++LIBSSH2_API int libssh2_channel_request_pty_size_ex(LIBSSH2_CHANNEL * channel, int width, int height, int width_px, int height_px);
++#define libssh2_channel_request_pty_size(channel, width, height) libssh2_channel_request_pty_size_ex( (channel), (width), (height), 0, 0)
++
++LIBSSH2_API int libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL *channel, int single_connection, const char *auth_proto, const char *auth_cookie, int screen_number);
++#define libssh2_channel_x11_req(channel, screen_number) libssh2_channel_x11_req_ex((channel), 0, NULL, NULL, (screen_number))
++
++LIBSSH2_API int libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel, const char *request, unsigned int request_len, const char *message, unsigned int message_len);
++#define libssh2_channel_shell(channel) libssh2_channel_process_startup((channel), "shell", sizeof("shell") - 1, NULL, 0)
++#define libssh2_channel_exec(channel, command) libssh2_channel_process_startup((channel), "exec", sizeof("exec") - 1, (command), strlen(command))
++#define libssh2_channel_subsystem(channel, subsystem) libssh2_channel_process_startup((channel), "subsystem", sizeof("subsystem") - 1, (subsystem), strlen(subsystem))
++
++LIBSSH2_API ssize_t libssh2_channel_read_ex(LIBSSH2_CHANNEL *channel, int stream_id, char *buf, size_t buflen);
++#define libssh2_channel_read(channel, buf, buflen) \
++ libssh2_channel_read_ex((channel), 0, (buf), (buflen))
++#define libssh2_channel_read_stderr(channel, buf, buflen) \
++ libssh2_channel_read_ex((channel), SSH_EXTENDED_DATA_STDERR, (buf), (buflen))
++
++LIBSSH2_API int libssh2_poll_channel_read(LIBSSH2_CHANNEL *channel, int extended);
++
++LIBSSH2_API unsigned long libssh2_channel_window_read_ex(LIBSSH2_CHANNEL *channel, unsigned long *read_avail, unsigned long *window_size_initial);
++#define libssh2_channel_window_read(channel) \
++ libssh2_channel_window_read_ex((channel), NULL, NULL)
++
++LIBSSH2_API unsigned long libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL *channel, unsigned long adjustment, unsigned char force);
++
++LIBSSH2_API ssize_t libssh2_channel_write_ex(LIBSSH2_CHANNEL *channel, int stream_id, const char *buf, size_t buflen);
++
++#define libssh2_channel_write(channel, buf, buflen) \
++ libssh2_channel_write_ex((channel), 0, (buf), (buflen))
++#define libssh2_channel_write_stderr(channel, buf, buflen) \
++ libssh2_channel_write_ex((channel), SSH_EXTENDED_DATA_STDERR, (buf), (buflen))
++
++LIBSSH2_API unsigned long libssh2_channel_window_write_ex(LIBSSH2_CHANNEL *channel, unsigned long *window_size_initial);
++#define libssh2_channel_window_write(channel) libssh2_channel_window_write_ex((channel), NULL)
++
++LIBSSH2_API void libssh2_session_set_blocking(LIBSSH2_SESSION* session, int blocking);
++LIBSSH2_API int libssh2_session_get_blocking(LIBSSH2_SESSION* session);
++
++LIBSSH2_API void libssh2_channel_set_blocking(LIBSSH2_CHANNEL *channel, int blocking);
++
++LIBSSH2_API void libssh2_channel_handle_extended_data(LIBSSH2_CHANNEL *channel, int ignore_mode);
++LIBSSH2_API int libssh2_channel_handle_extended_data2(LIBSSH2_CHANNEL *channel, int ignore_mode);
++/* libssh2_channel_ignore_extended_data() is defined below for BC with version 0.1
++ * Future uses should use libssh2_channel_handle_extended_data() directly
++ * if LIBSSH2_CHANNEL_EXTENDED_DATA_MERGE is passed, extended data will be read (FIFO) from the standard data channel
++ */
++/* DEPRECATED */
++#define libssh2_channel_ignore_extended_data(channel, ignore) libssh2_channel_handle_extended_data((channel), (ignore) ? LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE : LIBSSH2_CHANNEL_EXTENDED_DATA_NORMAL )
++
++#define LIBSSH2_CHANNEL_FLUSH_EXTENDED_DATA -1
++#define LIBSSH2_CHANNEL_FLUSH_ALL -2
++LIBSSH2_API int libssh2_channel_flush_ex(LIBSSH2_CHANNEL *channel, int streamid);
++#define libssh2_channel_flush(channel) libssh2_channel_flush_ex((channel), 0)
++#define libssh2_channel_flush_stderr(channel) libssh2_channel_flush_ex((channel), SSH_EXTENDED_DATA_STDERR)
++LIBSSH2_API int libssh2_channel_get_exit_status(LIBSSH2_CHANNEL* channel);
++
++LIBSSH2_API int libssh2_channel_send_eof(LIBSSH2_CHANNEL *channel);
++LIBSSH2_API int libssh2_channel_eof(LIBSSH2_CHANNEL *channel);
++LIBSSH2_API int libssh2_channel_wait_eof(LIBSSH2_CHANNEL *channel);
++LIBSSH2_API int libssh2_channel_close(LIBSSH2_CHANNEL *channel);
++LIBSSH2_API int libssh2_channel_wait_closed(LIBSSH2_CHANNEL *channel);
++LIBSSH2_API int libssh2_channel_free(LIBSSH2_CHANNEL *channel);
++
++LIBSSH2_API LIBSSH2_CHANNEL *libssh2_scp_recv(LIBSSH2_SESSION *session, const char *path, struct stat *sb);
++LIBSSH2_API LIBSSH2_CHANNEL *libssh2_scp_send_ex(LIBSSH2_SESSION *session, const char *path, int mode, size_t size, long mtime, long atime);
++#define libssh2_scp_send(session, path, mode, size) libssh2_scp_send_ex((session), (path), (mode), (size), 0, 0)
++
++LIBSSH2_API int libssh2_base64_decode(LIBSSH2_SESSION *session, char **dest, unsigned int *dest_len, const char *src, unsigned int src_len);
++
++/* NOTE NOTE NOTE
++ libssh2_trace() has no function in builds that aren't built with debug
++ enabled
++ */
++LIBSSH2_API int libssh2_trace(LIBSSH2_SESSION *session, int bitmask);
++#define LIBSSH2_TRACE_TRANS (1<<1)
++#define LIBSSH2_TRACE_KEX (1<<2)
++#define LIBSSH2_TRACE_AUTH (1<<3)
++#define LIBSSH2_TRACE_CONN (1<<4)
++#define LIBSSH2_TRACE_SCP (1<<5)
++#define LIBSSH2_TRACE_SFTP (1<<6)
++#define LIBSSH2_TRACE_ERROR (1<<7)
++#define LIBSSH2_TRACE_PUBLICKEY (1<<8)
++
++#ifdef __cplusplus
++} /* extern "C" */
++#endif
++
++#endif /* LIBSSH2_H */
+
+Property changes on: libssh2/include/libssh2.h
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.3
+Added: svn:eol-style
+ + native
+
+Index: libssh2/src/comp.c
+===================================================================
+--- libssh2/src/comp.c (.../tags/RELEASE_0_11_0)
++++ libssh2/src/comp.c (.../trunk)
+@@ -0,0 +1,340 @@
++/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
++ * 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"
++#ifdef LIBSSH2_HAVE_ZLIB
++# include <zlib.h>
++#endif
++
++/* ********
++ * none *
++ ******** */
++
++/* {{{ libssh2_comp_method_none_comp
++ * Minimalist compression: Absolutely none
++ */
++static int
++libssh2_comp_method_none_comp(LIBSSH2_SESSION * session,
++ int compress,
++ unsigned char **dest,
++ unsigned long *dest_len,
++ unsigned long payload_limit,
++ int *free_dest,
++ const unsigned char *src,
++ unsigned long src_len, void **abstract)
++{
++ (void) session;
++ (void) compress;
++ (void) payload_limit;
++ (void) abstract;
++ *dest = (unsigned char *) src;
++ *dest_len = src_len;
++
++ *free_dest = 0;
++
++ return 0;
++}
++
++/* }}} */
++
++static const LIBSSH2_COMP_METHOD libssh2_comp_method_none = {
++ "none",
++ NULL,
++ libssh2_comp_method_none_comp,
++ NULL
++};
++
++#ifdef LIBSSH2_HAVE_ZLIB
++/* ********
++ * zlib *
++ ******** */
++
++/* {{{ Memory management wrappers
++ * Yes, I realize we're doing a callback to a callback,
++ * Deal...
++ */
++
++static voidpf
++libssh2_comp_method_zlib_alloc(voidpf opaque, uInt items, uInt size)
++{
++ LIBSSH2_SESSION *session = (LIBSSH2_SESSION *) opaque;
++
++ return (voidpf) LIBSSH2_ALLOC(session, items * size);
++}
++
++static void
++libssh2_comp_method_zlib_free(voidpf opaque, voidpf address)
++{
++ LIBSSH2_SESSION *session = (LIBSSH2_SESSION *) opaque;
++
++ LIBSSH2_FREE(session, address);
++}
++
++/* }}} */
++
++/* {{{ libssh2_comp_method_zlib_init
++ * All your bandwidth are belong to us (so save some)
++ */
++static int
++libssh2_comp_method_zlib_init(LIBSSH2_SESSION * session, int compress,
++ void **abstract)
++{
++ z_stream *strm;
++ int status;
++
++ strm = LIBSSH2_ALLOC(session, sizeof(z_stream));
++ if (!strm) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for zlib compression/decompression",
++ 0);
++ return -1;
++ }
++ memset(strm, 0, sizeof(z_stream));
++
++ strm->opaque = (voidpf) session;
++ strm->zalloc = (alloc_func) libssh2_comp_method_zlib_alloc;
++ strm->zfree = (free_func) libssh2_comp_method_zlib_free;
++ if (compress) {
++ /* deflate */
++ status = deflateInit(strm, Z_DEFAULT_COMPRESSION);
++ } else {
++ /* inflate */
++ status = inflateInit(strm);
++ }
++
++ if (status != Z_OK) {
++ LIBSSH2_FREE(session, strm);
++ return -1;
++ }
++ *abstract = strm;
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_comp_method_zlib_comp
++ * zlib, a compression standard for all occasions
++ */
++static int
++libssh2_comp_method_zlib_comp(LIBSSH2_SESSION * session,
++ int compress,
++ unsigned char **dest,
++ unsigned long *dest_len,
++ unsigned long payload_limit,
++ int *free_dest,
++ const unsigned char *src,
++ unsigned long src_len, void **abstract)
++{
++ z_stream *strm = *abstract;
++ /* A short-term alloc of a full data chunk is better than a series of
++ reallocs */
++ char *out;
++ int out_maxlen = compress ? (src_len + 4) : (2 * src_len);
++ int limiter = 0;
++
++ /* In practice they never come smaller than this */
++ if (out_maxlen < 25) {
++ out_maxlen = 25;
++ }
++
++ if (out_maxlen > (int) payload_limit) {
++ out_maxlen = payload_limit;
++ }
++
++ strm->next_in = (unsigned char *) src;
++ strm->avail_in = src_len;
++ strm->next_out = (unsigned char *) LIBSSH2_ALLOC(session, out_maxlen);
++ out = (char *) strm->next_out;
++ strm->avail_out = out_maxlen;
++ if (!strm->next_out) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate compression/decompression buffer",
++ 0);
++ return -1;
++ }
++ while (strm->avail_in) {
++ int status;
++
++ if (compress) {
++ status = deflate(strm, Z_PARTIAL_FLUSH);
++ } else {
++ status = inflate(strm, Z_PARTIAL_FLUSH);
++ }
++ if (status != Z_OK) {
++ libssh2_error(session, LIBSSH2_ERROR_ZLIB,
++ "compress/decompression failure", 0);
++ LIBSSH2_FREE(session, out);
++ return -1;
++ }
++ if (strm->avail_in) {
++ unsigned long out_ofs = out_maxlen - strm->avail_out;
++ char *newout;
++
++ out_maxlen +=
++ compress ? (strm->avail_in + 4) : (2 * strm->avail_in);
++
++ if ((out_maxlen > (int) payload_limit) && !compress && limiter++) {
++ libssh2_error(session, LIBSSH2_ERROR_ZLIB,
++ "Excessive growth in decompression phase", 0);
++ LIBSSH2_FREE(session, out);
++ return -1;
++ }
++
++ newout = LIBSSH2_REALLOC(session, out, out_maxlen);
++ if (!newout) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to expand compress/decompression buffer",
++ 0);
++ LIBSSH2_FREE(session, out);
++ return -1;
++ }
++ out = newout;
++ strm->next_out = (unsigned char *) out + out_ofs;
++ strm->avail_out +=
++ compress ? (strm->avail_in + 4) : (2 * strm->avail_in);
++ } else
++ while (!strm->avail_out) {
++ /* Done with input, might be a byte or two in internal buffer during compress
++ * Or potentially many bytes if it's a decompress
++ */
++ int grow_size = compress ? 8 : 1024;
++ char *newout;
++
++ if (out_maxlen >= (int) payload_limit) {
++ libssh2_error(session, LIBSSH2_ERROR_ZLIB,
++ "Excessive growth in decompression phase",
++ 0);
++ LIBSSH2_FREE(session, out);
++ return -1;
++ }
++
++ if (grow_size > (int) (payload_limit - out_maxlen)) {
++ grow_size = payload_limit - out_maxlen;
++ }
++
++ out_maxlen += grow_size;
++ strm->avail_out = grow_size;
++
++ newout = LIBSSH2_REALLOC(session, out, out_maxlen);
++ if (!newout) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to expand final compress/decompress buffer",
++ 0);
++ LIBSSH2_FREE(session, out);
++ return -1;
++ }
++ out = newout;
++ strm->next_out = (unsigned char *) out + out_maxlen -
++ grow_size;
++
++ if (compress) {
++ status = deflate(strm, Z_PARTIAL_FLUSH);
++ } else {
++ status = inflate(strm, Z_PARTIAL_FLUSH);
++ }
++ if (status != Z_OK) {
++ libssh2_error(session, LIBSSH2_ERROR_ZLIB,
++ "compress/decompression failure", 0);
++ LIBSSH2_FREE(session, out);
++ return -1;
++ }
++ }
++ }
++
++ *dest = (unsigned char *) out;
++ *dest_len = out_maxlen - strm->avail_out;
++ *free_dest = 1;
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_comp_method_zlib_dtor
++ * All done, no more compression for you
++ */
++static int
++libssh2_comp_method_zlib_dtor(LIBSSH2_SESSION * session, int compress,
++ void **abstract)
++{
++ z_stream *strm = *abstract;
++
++ if (strm) {
++ if (compress) {
++ /* deflate */
++ deflateEnd(strm);
++ } else {
++ /* inflate */
++ inflateEnd(strm);
++ }
++
++ LIBSSH2_FREE(session, strm);
++ }
++
++ *abstract = NULL;
++
++ return 0;
++}
++
++/* }}} */
++
++static const LIBSSH2_COMP_METHOD libssh2_comp_method_zlib = {
++ "zlib",
++ libssh2_comp_method_zlib_init,
++ libssh2_comp_method_zlib_comp,
++ libssh2_comp_method_zlib_dtor,
++};
++#endif /* LIBSSH2_HAVE_ZLIB */
++
++/* ***********************
++ * Compression Methods *
++ *********************** */
++
++static const LIBSSH2_COMP_METHOD *_libssh2_comp_methods[] = {
++ &libssh2_comp_method_none,
++#ifdef LIBSSH2_HAVE_ZLIB
++ &libssh2_comp_method_zlib,
++#endif /* LIBSSH2_HAVE_ZLIB */
++ NULL
++};
++
++const LIBSSH2_COMP_METHOD **
++libssh2_comp_methods(void)
++{
++ return _libssh2_comp_methods;
++}
+
+Property changes on: libssh2/src/comp.c
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.2
+Added: svn:eol-style
+ + native
+
+Index: libssh2/src/libgcrypt.c
+===================================================================
+--- libssh2/src/libgcrypt.c (.../tags/RELEASE_0_11_0)
++++ libssh2/src/libgcrypt.c (.../trunk)
+@@ -0,0 +1,560 @@
++/* Copyright (C) 2006, 2007, The Written Word, Inc.
++ * Copyright (C) 2008, Simon Josefsson
++ * 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 <string.h>
++
++int
++_libssh2_rsa_new(libssh2_rsa_ctx ** rsa,
++ const unsigned char *edata,
++ unsigned long elen,
++ const unsigned char *ndata,
++ unsigned long nlen,
++ const unsigned char *ddata,
++ unsigned long dlen,
++ const unsigned char *pdata,
++ unsigned long plen,
++ const unsigned char *qdata,
++ unsigned long qlen,
++ const unsigned char *e1data,
++ unsigned long e1len,
++ const unsigned char *e2data,
++ unsigned long e2len,
++ const unsigned char *coeffdata, unsigned long coefflen)
++{
++ int rc;
++ (void) e1data;
++ (void) e1len;
++ (void) e2data;
++ (void) e2len;
++
++ if (ddata) {
++ rc = gcry_sexp_build
++ (rsa, NULL,
++ "(private-key(rsa(n%b)(e%b)(d%b)(q%b)(p%b)(u%b)))",
++ nlen, ndata, elen, edata, dlen, ddata, plen, pdata,
++ qlen, qdata, coefflen, coeffdata);
++ } else {
++ rc = gcry_sexp_build(rsa, NULL, "(public-key(rsa(n%b)(e%b)))",
++ nlen, ndata, elen, edata);
++ }
++ if (rc) {
++ *rsa = NULL;
++ return -1;
++ }
++
++ return 0;
++}
++
++int
++_libssh2_rsa_sha1_verify(libssh2_rsa_ctx * rsa,
++ const unsigned char *sig,
++ unsigned long sig_len,
++ const unsigned char *m, unsigned long m_len)
++{
++ unsigned char hash[SHA_DIGEST_LENGTH];
++ gcry_sexp_t s_sig, s_hash;
++ int rc = -1;
++
++ libssh2_sha1(m, m_len, hash);
++
++ rc = gcry_sexp_build(&s_hash, NULL,
++ "(data (flags pkcs1) (hash sha1 %b))",
++ SHA_DIGEST_LENGTH, hash);
++ if (rc != 0) {
++ return -1;
++ }
++
++ rc = gcry_sexp_build(&s_sig, NULL, "(sig-val(rsa(s %b)))", sig_len, sig);
++ if (rc != 0) {
++ gcry_sexp_release(s_hash);
++ return -1;
++ }
++
++ rc = gcry_pk_verify(s_sig, s_hash, rsa);
++ gcry_sexp_release(s_sig);
++ gcry_sexp_release(s_hash);
++
++ return (rc == 0) ? 0 : -1;
++}
++
++int
++_libssh2_dsa_new(libssh2_dsa_ctx ** dsactx,
++ const unsigned char *p,
++ unsigned long p_len,
++ const unsigned char *q,
++ unsigned long q_len,
++ const unsigned char *g,
++ unsigned long g_len,
++ const unsigned char *y,
++ unsigned long y_len,
++ const unsigned char *x, unsigned long x_len)
++{
++ int rc;
++
++ if (x_len) {
++ rc = gcry_sexp_build
++ (dsactx, NULL,
++ "(private-key(dsa(p%b)(q%b)(g%b)(y%b)(x%b)))",
++ p_len, p, q_len, q, g_len, g, y_len, y, x_len, x);
++ } else {
++ rc = gcry_sexp_build(dsactx, NULL,
++ "(public-key(dsa(p%b)(q%b)(g%b)(y%b)))",
++ p_len, p, q_len, q, g_len, g, y_len, y);
++ }
++
++ if (rc) {
++ *dsactx = NULL;
++ return -1;
++ }
++
++ return 0;
++}
++
++int
++_libssh2_rsa_new_private(libssh2_rsa_ctx ** rsa,
++ LIBSSH2_SESSION * session,
++ FILE * fp, unsigned const char *passphrase)
++{
++ unsigned char *data, *save_data;
++ unsigned int datalen;
++ int ret;
++ unsigned char *n, *e, *d, *p, *q, *e1, *e2, *coeff;
++ unsigned int nlen, elen, dlen, plen, qlen, e1len, e2len, coefflen;
++
++ (void) passphrase;
++
++ ret = _libssh2_pem_parse(session,
++ "-----BEGIN RSA PRIVATE KEY-----",
++ "-----END RSA PRIVATE KEY-----",
++ fp, &data, &datalen);
++ if (ret) {
++ return -1;
++ }
++
++ save_data = data;
++
++ if (_libssh2_pem_decode_sequence(&data, &datalen)) {
++ ret = -1;
++ goto fail;
++ }
++/* First read Version field (should be 0). */
++ ret = _libssh2_pem_decode_integer(&data, &datalen, &n, &nlen);
++ if (ret != 0 || (nlen != 1 && *n != '\0')) {
++ ret = -1;
++ goto fail;
++ }
++
++ ret = _libssh2_pem_decode_integer(&data, &datalen, &n, &nlen);
++ if (ret != 0) {
++ ret = -1;
++ goto fail;
++ }
++
++ ret = _libssh2_pem_decode_integer(&data, &datalen, &e, &elen);
++ if (ret != 0) {
++ ret = -1;
++ goto fail;
++ }
++
++ ret = _libssh2_pem_decode_integer(&data, &datalen, &d, &dlen);
++ if (ret != 0) {
++ ret = -1;
++ goto fail;
++ }
++
++ ret = _libssh2_pem_decode_integer(&data, &datalen, &p, &plen);
++ if (ret != 0) {
++ ret = -1;
++ goto fail;
++ }
++
++ ret = _libssh2_pem_decode_integer(&data, &datalen, &q, &qlen);
++ if (ret != 0) {
++ ret = -1;
++ goto fail;
++ }
++
++ ret = _libssh2_pem_decode_integer(&data, &datalen, &e1, &e1len);
++ if (ret != 0) {
++ ret = -1;
++ goto fail;
++ }
++
++ ret = _libssh2_pem_decode_integer(&data, &datalen, &e2, &e2len);
++ if (ret != 0) {
++ ret = -1;
++ goto fail;
++ }
++
++ ret = _libssh2_pem_decode_integer(&data, &datalen, &coeff, &coefflen);
++ if (ret != 0) {
++ ret = -1;
++ goto fail;
++ }
++
++ if (_libssh2_rsa_new(rsa, e, elen, n, nlen, d, dlen, p, plen,
++ q, qlen, e1, e1len, e2, e2len, coeff, coefflen)) {
++ ret = -1;
++ goto fail;
++ }
++
++ ret = 0;
++
++ fail:
++ LIBSSH2_FREE(session, save_data);
++ return ret;
++}
++
++int
++_libssh2_dsa_new_private(libssh2_dsa_ctx ** dsa,
++ LIBSSH2_SESSION * session,
++ FILE * fp, unsigned const char *passphrase)
++{
++ unsigned char *data, *save_data;
++ unsigned int datalen;
++ int ret;
++ unsigned char *p, *q, *g, *y, *x;
++ unsigned int plen, qlen, glen, ylen, xlen;
++
++ (void) passphrase;
++
++ ret = _libssh2_pem_parse(session,
++ "-----BEGIN DSA PRIVATE KEY-----",
++ "-----END DSA PRIVATE KEY-----",
++ fp, &data, &datalen);
++ if (ret) {
++ return -1;
++ }
++
++ save_data = data;
++
++ if (_libssh2_pem_decode_sequence(&data, &datalen)) {
++ ret = -1;
++ goto fail;
++ }
++
++/* First read Version field (should be 0). */
++ ret = _libssh2_pem_decode_integer(&data, &datalen, &p, &plen);
++ if (ret != 0 || (plen != 1 && *p != '\0')) {
++ ret = -1;
++ goto fail;
++ }
++
++ ret = _libssh2_pem_decode_integer(&data, &datalen, &p, &plen);
++ if (ret != 0) {
++ ret = -1;
++ goto fail;
++ }
++
++ ret = _libssh2_pem_decode_integer(&data, &datalen, &q, &qlen);
++ if (ret != 0) {
++ ret = -1;
++ goto fail;
++ }
++
++ ret = _libssh2_pem_decode_integer(&data, &datalen, &g, &glen);
++ if (ret != 0) {
++ ret = -1;
++ goto fail;
++ }
++
++ ret = _libssh2_pem_decode_integer(&data, &datalen, &y, &ylen);
++ if (ret != 0) {
++ ret = -1;
++ goto fail;
++ }
++
++ ret = _libssh2_pem_decode_integer(&data, &datalen, &x, &xlen);
++ if (ret != 0) {
++ ret = -1;
++ goto fail;
++ }
++
++ if (datalen != 0) {
++ ret = -1;
++ goto fail;
++ }
++
++ if (_libssh2_dsa_new(dsa, p, plen, q, qlen, g, glen, y, ylen, x, xlen)) {
++ ret = -1;
++ goto fail;
++ }
++
++ ret = 0;
++
++ fail:
++ LIBSSH2_FREE(session, save_data);
++ return ret;
++}
++
++int
++_libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
++ libssh2_dsa_ctx * rsactx,
++ const unsigned char *hash,
++ unsigned long hash_len,
++ unsigned char **signature, unsigned long *signature_len)
++{
++ gcry_sexp_t sig_sexp;
++ gcry_sexp_t data;
++ int rc;
++ const char *tmp;
++ size_t size;
++
++ if (hash_len != SHA_DIGEST_LENGTH) {
++ return -1;
++ }
++
++ if (gcry_sexp_build(&data, NULL,
++ "(data (flags pkcs1) (hash sha1 %b))",
++ hash_len, hash)) {
++ return -1;
++ }
++
++ rc = gcry_pk_sign(&sig_sexp, data, rsactx);
++
++ gcry_sexp_release(data);
++
++ if (rc != 0) {
++ return -1;
++ }
++
++ data = gcry_sexp_find_token(sig_sexp, "s", 0);
++ if (!data) {
++ return -1;
++ }
++
++ tmp = gcry_sexp_nth_data(data, 1, &size);
++ if (!tmp) {
++ return -1;
++ }
++
++ if (tmp[0] == '\0') {
++ tmp++;
++ size--;
++ }
++
++ *signature = LIBSSH2_ALLOC(session, size);
++ memcpy(*signature, tmp, size);
++ *signature_len = size;
++
++ return rc;
++}
++
++int
++_libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
++ const unsigned char *hash,
++ unsigned long hash_len, unsigned char *sig)
++{
++ unsigned char zhash[SHA_DIGEST_LENGTH + 1];
++ gcry_sexp_t sig_sexp;
++ gcry_sexp_t data;
++ int ret;
++ const char *tmp;
++ size_t size;
++
++ if (hash_len != SHA_DIGEST_LENGTH) {
++ return -1;
++ }
++
++ memcpy(zhash + 1, hash, hash_len);
++ zhash[0] = 0;
++
++ if (gcry_sexp_build(&data, NULL, "(data (value %b))", hash_len + 1, zhash)) {
++ return -1;
++ }
++
++ ret = gcry_pk_sign(&sig_sexp, data, dsactx);
++
++ gcry_sexp_release(data);
++
++ if (ret != 0) {
++ return -1;
++ }
++
++/* Extract R. */
++
++ data = gcry_sexp_find_token(sig_sexp, "r", 0);
++ if (!data) {
++ ret = -1;
++ goto out;
++ }
++
++ tmp = gcry_sexp_nth_data(data, 1, &size);
++ if (!tmp) {
++ ret = -1;
++ goto out;
++ }
++
++ if (tmp[0] == '\0') {
++ tmp++;
++ size--;
++ }
++
++ if (size != 20) {
++ ret = -1;
++ goto out;
++ }
++
++ memcpy(sig, tmp, 20);
++
++ gcry_sexp_release(data);
++
++/* Extract S. */
++
++ data = gcry_sexp_find_token(sig_sexp, "s", 0);
++ if (!data) {
++ ret = -1;
++ goto out;
++ }
++
++ tmp = gcry_sexp_nth_data(data, 1, &size);
++ if (!tmp) {
++ ret = -1;
++ goto out;
++ }
++
++ if (tmp[0] == '\0') {
++ tmp++;
++ size--;
++ }
++
++ if (size != 20) {
++ ret = -1;
++ goto out;
++ }
++
++ memcpy(sig + 20, tmp, 20);
++
++ ret = 0;
++ out:
++ if (sig_sexp) {
++ gcry_sexp_release(sig_sexp);
++ }
++ if (data) {
++ gcry_sexp_release(data);
++ }
++ return ret;
++}
++
++int
++_libssh2_dsa_sha1_verify(libssh2_dsa_ctx * dsactx,
++ const unsigned char *sig,
++ const unsigned char *m, unsigned long m_len)
++{
++ unsigned char hash[SHA_DIGEST_LENGTH + 1];
++ gcry_sexp_t s_sig, s_hash;
++ int rc = -1;
++
++ libssh2_sha1(m, m_len, hash + 1);
++ hash[0] = 0;
++
++ if (gcry_sexp_build(&s_hash, NULL, "(data(flags raw)(value %b))",
++ SHA_DIGEST_LENGTH + 1, hash)) {
++ return -1;
++ }
++
++ if (gcry_sexp_build(&s_sig, NULL, "(sig-val(dsa(r %b)(s %b)))",
++ 20, sig, 20, sig + 20)) {
++ gcry_sexp_release(s_hash);
++ return -1;
++ }
++
++ rc = gcry_pk_verify(s_sig, s_hash, dsactx);
++ gcry_sexp_release(s_sig);
++ gcry_sexp_release(s_hash);
++
++ return (rc == 0) ? 0 : -1;
++}
++
++int
++_libssh2_cipher_init(_libssh2_cipher_ctx * h,
++ _libssh2_cipher_type(algo),
++ unsigned char *iv, unsigned char *secret, int encrypt)
++{
++ int mode = 0, ret;
++ int keylen = gcry_cipher_get_algo_keylen(algo);
++
++ (void) encrypt;
++
++ if (algo != GCRY_CIPHER_ARCFOUR) {
++ mode = GCRY_CIPHER_MODE_CBC;
++ }
++
++ ret = gcry_cipher_open(h, algo, mode, 0);
++ if (ret) {
++ return -1;
++ }
++
++ ret = gcry_cipher_setkey(*h, secret, keylen);
++ if (ret) {
++ gcry_cipher_close(*h);
++ return -1;
++ }
++
++ if (algo != GCRY_CIPHER_ARCFOUR) {
++ int blklen = gcry_cipher_get_algo_blklen(algo);
++ ret = gcry_cipher_setiv(*h, iv, blklen);
++ if (ret) {
++ gcry_cipher_close(*h);
++ return -1;
++ }
++ }
++
++ return 0;
++}
++
++int
++_libssh2_cipher_crypt(_libssh2_cipher_ctx * ctx,
++ _libssh2_cipher_type(algo),
++ int encrypt, unsigned char *block)
++{
++ size_t blklen = gcry_cipher_get_algo_blklen(algo);
++ int ret;
++ if (blklen == 1) {
++/* Hack for arcfour. */
++ blklen = 8;
++ }
++
++ if (encrypt) {
++ ret = gcry_cipher_encrypt(*ctx, block, blklen, block, blklen);
++ } else {
++ ret = gcry_cipher_decrypt(*ctx, block, blklen, block, blklen);
++ }
++ return ret;
++}
+
+Property changes on: libssh2/src/libgcrypt.c
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.1
+Added: svn:eol-style
+ + native
+Added: svn:executable
+ + *
+
+Index: libssh2/src/userauth.c
+===================================================================
+--- libssh2/src/userauth.c (.../tags/RELEASE_0_11_0)
++++ libssh2/src/userauth.c (.../trunk)
+@@ -0,0 +1,1473 @@
++/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
++ * 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 <ctype.h>
++#include <stdio.h>
++
++/* Needed for struct iovec on some platforms */
++#ifdef HAVE_SYS_UIO_H
++#include <sys/uio.h>
++#endif
++
++
++/* {{{ proto libssh2_userauth_list
++ * List authentication methods
++ * Will yield successful login if "none" happens to be allowable for this user
++ * Not a common configuration for any SSH server though
++ * username should be NULL, or a null terminated string
++ */
++LIBSSH2_API char *
++libssh2_userauth_list(LIBSSH2_SESSION * session, const char *username,
++ unsigned int username_len)
++{
++ static const unsigned char reply_codes[3] =
++ { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, 0 };
++ /* packet_type(1) + username_len(4) + service_len(4) +
++ service(14)"ssh-connection" + method_len(4) + method(4)"none" */
++ unsigned long methods_len;
++ unsigned char *s;
++ int rc;
++
++ if (session->userauth_list_state == libssh2_NB_state_idle) {
++ /* Zero the whole thing out */
++ memset(&session->userauth_list_packet_requirev_state, 0,
++ sizeof(session->userauth_list_packet_requirev_state));
++
++ session->userauth_list_data_len = username_len + 31;
++
++ s = session->userauth_list_data =
++ LIBSSH2_ALLOC(session, session->userauth_list_data_len);
++ if (!session->userauth_list_data) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for userauth_list", 0);
++ return NULL;
++ }
++
++ *(s++) = SSH_MSG_USERAUTH_REQUEST;
++ libssh2_htonu32(s, username_len);
++ s += 4;
++ if (username) {
++ memcpy(s, username, username_len);
++ s += username_len;
++ }
++
++ libssh2_htonu32(s, 14);
++ s += 4;
++ memcpy(s, "ssh-connection", 14);
++ s += 14;
++
++ libssh2_htonu32(s, 4);
++ s += 4;
++ memcpy(s, "none", 4);
++ s += 4;
++
++ session->userauth_list_state = libssh2_NB_state_created;
++ }
++
++ if (session->userauth_list_state == libssh2_NB_state_created) {
++ rc = libssh2_packet_write(session, session->userauth_list_data,
++ session->userauth_list_data_len);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block requesting userauth list", 0);
++ return NULL;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send userauth-none request", 0);
++ LIBSSH2_FREE(session, session->userauth_list_data);
++ session->userauth_list_data = NULL;
++ session->userauth_list_state = libssh2_NB_state_idle;
++ return NULL;
++ }
++ LIBSSH2_FREE(session, session->userauth_list_data);
++ session->userauth_list_data = NULL;
++
++ session->userauth_list_state = libssh2_NB_state_sent;
++ }
++
++ if (session->userauth_list_state == libssh2_NB_state_sent) {
++ rc = libssh2_packet_requirev_ex(session, reply_codes,
++ &session->userauth_list_data,
++ &session->userauth_list_data_len, 0,
++ NULL, 0,
++ &session->
++ userauth_list_packet_requirev_state);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block requesting userauth list", 0);
++ return NULL;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_NONE, "No error", 0);
++ session->userauth_list_state = libssh2_NB_state_idle;
++ return NULL;
++ }
++
++ if (session->userauth_list_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
++ /* Wow, who'dve thought... */
++ libssh2_error(session, LIBSSH2_ERROR_NONE, "No error", 0);
++ LIBSSH2_FREE(session, session->userauth_list_data);
++ session->userauth_list_data = NULL;
++ session->state |= LIBSSH2_STATE_AUTHENTICATED;
++ session->userauth_list_state = libssh2_NB_state_idle;
++ return NULL;
++ }
++
++ methods_len = libssh2_ntohu32(session->userauth_list_data + 1);
++
++ /* Do note that the memory areas overlap! */
++ memmove(session->userauth_list_data, session->userauth_list_data + 5,
++ methods_len);
++ session->userauth_list_data[methods_len] = '\0';
++ _libssh2_debug(session, LIBSSH2_DBG_AUTH, "Permitted auth methods: %s",
++ session->userauth_list_data);
++ }
++
++ session->userauth_list_state = libssh2_NB_state_idle;
++ return (char *) session->userauth_list_data;
++}
++
++/* }}} */
++
++/* {{{ libssh2_userauth_authenticated
++ * 0 if not yet authenticated
++ * non-zero is already authenticated
++ */
++LIBSSH2_API int
++libssh2_userauth_authenticated(LIBSSH2_SESSION * session)
++{
++ return session->state & LIBSSH2_STATE_AUTHENTICATED;
++}
++
++/* }}} */
++
++/* {{{ libssh2_userauth_password
++ * Plain ol' login
++ */
++LIBSSH2_API int
++libssh2_userauth_password_ex(LIBSSH2_SESSION * session, const char *username,
++ unsigned int username_len, const char *password,
++ unsigned int password_len,
++ LIBSSH2_PASSWD_CHANGEREQ_FUNC((*passwd_change_cb)))
++{
++ unsigned char *s;
++ static const unsigned char reply_codes[4] =
++ { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE,
++ SSH_MSG_USERAUTH_PASSWD_CHANGEREQ, 0
++ };
++ int rc;
++
++ if (session->userauth_pswd_state == libssh2_NB_state_idle) {
++ /* Zero the whole thing out */
++ memset(&session->userauth_pswd_packet_requirev_state, 0,
++ sizeof(session->userauth_pswd_packet_requirev_state));
++
++ /*
++ * 40 = acket_type(1) + username_len(4) + service_len(4) +
++ * service(14)"ssh-connection" + method_len(4) + method(8)"password" +
++ * chgpwdbool(1) + password_len(4) */
++ session->userauth_pswd_data_len = username_len + password_len + 40;
++
++ session->userauth_pswd_data0 = ~SSH_MSG_USERAUTH_PASSWD_CHANGEREQ;
++
++ s = session->userauth_pswd_data =
++ LIBSSH2_ALLOC(session, session->userauth_pswd_data_len);
++ if (!session->userauth_pswd_data) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for userauth-password request",
++ 0);
++ return -1;
++ }
++
++ *(s++) = SSH_MSG_USERAUTH_REQUEST;
++ libssh2_htonu32(s, username_len);
++ s += 4;
++ memcpy(s, username, username_len);
++ s += username_len;
++
++ libssh2_htonu32(s, sizeof("ssh-connection") - 1);
++ s += 4;
++ memcpy(s, "ssh-connection", sizeof("ssh-connection") - 1);
++ s += sizeof("ssh-connection") - 1;
++
++ libssh2_htonu32(s, sizeof("password") - 1);
++ s += 4;
++ memcpy(s, "password", sizeof("password") - 1);
++ s += sizeof("password") - 1;
++
++ *s = '\0';
++ s++;
++
++ libssh2_htonu32(s, password_len);
++ s += 4;
++ memcpy(s, password, password_len);
++ s += password_len;
++
++ _libssh2_debug(session, LIBSSH2_DBG_AUTH,
++ "Attempting to login using password authentication");
++
++ session->userauth_pswd_state = libssh2_NB_state_created;
++ }
++
++ if (session->userauth_pswd_state == libssh2_NB_state_created) {
++ rc = libssh2_packet_write(session, session->userauth_pswd_data,
++ session->userauth_pswd_data_len);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send userauth-password request", 0);
++ LIBSSH2_FREE(session, session->userauth_pswd_data);
++ session->userauth_pswd_data = NULL;
++ session->userauth_pswd_state = libssh2_NB_state_idle;
++ return -1;
++ }
++ LIBSSH2_FREE(session, session->userauth_pswd_data);
++ session->userauth_pswd_data = NULL;
++
++ session->userauth_pswd_state = libssh2_NB_state_sent;
++ }
++
++ password_response:
++
++ if ((session->userauth_pswd_state == libssh2_NB_state_sent)
++ || (session->userauth_pswd_state == libssh2_NB_state_sent1)
++ || (session->userauth_pswd_state == libssh2_NB_state_sent2)) {
++ if (session->userauth_pswd_state == libssh2_NB_state_sent) {
++ rc = libssh2_packet_requirev_ex(session, reply_codes,
++ &session->userauth_pswd_data,
++ &session->userauth_pswd_data_len,
++ 0, NULL, 0,
++ &session->
++ userauth_pswd_packet_requirev_state);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ session->userauth_pswd_state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ if (session->userauth_pswd_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
++ _libssh2_debug(session, LIBSSH2_DBG_AUTH,
++ "Password authentication successful");
++ LIBSSH2_FREE(session, session->userauth_pswd_data);
++ session->userauth_pswd_data = NULL;
++ session->state |= LIBSSH2_STATE_AUTHENTICATED;
++ session->userauth_pswd_state = libssh2_NB_state_idle;
++ return 0;
++ }
++
++ session->userauth_pswd_newpw = NULL;
++ session->userauth_pswd_newpw_len = 0;
++
++ session->userauth_pswd_state = libssh2_NB_state_sent1;
++ }
++
++ if ((session->userauth_pswd_data[0] ==
++ SSH_MSG_USERAUTH_PASSWD_CHANGEREQ)
++ || (session->userauth_pswd_data0 ==
++ SSH_MSG_USERAUTH_PASSWD_CHANGEREQ)) {
++ session->userauth_pswd_data0 = SSH_MSG_USERAUTH_PASSWD_CHANGEREQ;
++
++ if ((session->userauth_pswd_state == libssh2_NB_state_sent1) ||
++ (session->userauth_pswd_state == libssh2_NB_state_sent2)) {
++ if (session->userauth_pswd_state == libssh2_NB_state_sent1) {
++ _libssh2_debug(session, LIBSSH2_DBG_AUTH,
++ "Password change required");
++ LIBSSH2_FREE(session, session->userauth_pswd_data);
++ session->userauth_pswd_data = NULL;
++ }
++ if (passwd_change_cb) {
++ if (session->userauth_pswd_state == libssh2_NB_state_sent1) {
++ passwd_change_cb(session,
++ &session->userauth_pswd_newpw,
++ &session->userauth_pswd_newpw_len,
++ &session->abstract);
++ if (!session->userauth_pswd_newpw) {
++ libssh2_error(session,
++ LIBSSH2_ERROR_PASSWORD_EXPIRED,
++ "Password expired, and callback failed",
++ 0);
++ return -1;
++ }
++
++ /* basic data_len + newpw_len(4) */
++ session->userauth_pswd_data_len =
++ username_len + password_len + 44 +
++ session->userauth_pswd_newpw_len;
++
++ s = session->userauth_pswd_data =
++ LIBSSH2_ALLOC(session,
++ session->userauth_pswd_data_len);
++ if (!session->userauth_pswd_data) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for userauth-password-change request",
++ 0);
++ LIBSSH2_FREE(session,
++ session->userauth_pswd_newpw);
++ session->userauth_pswd_newpw = NULL;
++ return -1;
++ }
++
++ *(s++) = SSH_MSG_USERAUTH_REQUEST;
++ libssh2_htonu32(s, username_len);
++ s += 4;
++ memcpy(s, username, username_len);
++ s += username_len;
++
++ libssh2_htonu32(s, sizeof("ssh-connection") - 1);
++ s += 4;
++ memcpy(s, "ssh-connection",
++ sizeof("ssh-connection") - 1);
++ s += sizeof("ssh-connection") - 1;
++
++ libssh2_htonu32(s, sizeof("password") - 1);
++ s += 4;
++ memcpy(s, "password", sizeof("password") - 1);
++ s += sizeof("password") - 1;
++
++ *s = 0x01;
++ s++;
++
++ libssh2_htonu32(s, password_len);
++ s += 4;
++ memcpy(s, password, password_len);
++ s += password_len;
++
++ libssh2_htonu32(s, session->userauth_pswd_newpw_len);
++ s += 4;
++ memcpy(s, session->userauth_pswd_newpw,
++ session->userauth_pswd_newpw_len);
++ s += session->userauth_pswd_newpw_len;
++
++ session->userauth_pswd_state = libssh2_NB_state_sent2;
++ }
++
++ if (session->userauth_pswd_state == libssh2_NB_state_sent2) {
++ rc = libssh2_packet_write(session,
++ session->userauth_pswd_data,
++ session->
++ userauth_pswd_data_len);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send userauth-password-change request",
++ 0);
++ LIBSSH2_FREE(session, session->userauth_pswd_data);
++ session->userauth_pswd_data = NULL;
++ LIBSSH2_FREE(session,
++ session->userauth_pswd_newpw);
++ session->userauth_pswd_newpw = NULL;
++ return -1;
++ }
++ LIBSSH2_FREE(session, session->userauth_pswd_data);
++ session->userauth_pswd_data = NULL;
++ LIBSSH2_FREE(session, session->userauth_pswd_newpw);
++ session->userauth_pswd_newpw = NULL;
++
++ /*
++ * Ugliest use of goto ever. Blame it on the
++ * askN => requirev migration.
++ */
++ session->userauth_pswd_state = libssh2_NB_state_sent;
++ goto password_response;
++ }
++ }
++ } else {
++ libssh2_error(session, LIBSSH2_ERROR_PASSWORD_EXPIRED,
++ "Password Expired, and no callback specified",
++ 0);
++ session->userauth_pswd_state = libssh2_NB_state_idle;
++ return -1;
++ }
++ }
++ }
++
++ /* FAILURE */
++ LIBSSH2_FREE(session, session->userauth_pswd_data);
++ session->userauth_pswd_data = NULL;
++ session->userauth_pswd_state = libssh2_NB_state_idle;
++ return -1;
++}
++
++/* }}} */
++
++/* {{{ libssh2_file_read_publickey
++ * Read a public key from an id_???.pub style file
++ */
++static int
++libssh2_file_read_publickey(LIBSSH2_SESSION * session, unsigned char **method,
++ unsigned long *method_len,
++ unsigned char **pubkeydata,
++ unsigned long *pubkeydata_len,
++ const char *pubkeyfile)
++{
++ FILE *fd;
++ char c;
++ unsigned char *pubkey = NULL, *sp1, *sp2, *tmp;
++ size_t pubkey_len = 0;
++ unsigned int tmp_len;
++
++ _libssh2_debug(session, LIBSSH2_DBG_AUTH, "Loading public key file: %s",
++ pubkeyfile);
++ /* Read Public Key */
++ fd = fopen(pubkeyfile, "r");
++ if (!fd) {
++ libssh2_error(session, LIBSSH2_ERROR_FILE,
++ "Unable to open public key file", 0);
++ return -1;
++ }
++ while (!feof(fd) && (c = fgetc(fd)) != '\r' && c != '\n')
++ pubkey_len++;
++ if (feof(fd)) {
++ /* the last character was EOF */
++ pubkey_len--;
++ }
++ rewind(fd);
++
++ if (pubkey_len <= 1) {
++ libssh2_error(session, LIBSSH2_ERROR_FILE,
++ "Invalid data in public key file", 0);
++ fclose(fd);
++ return -1;
++ }
++
++ pubkey = LIBSSH2_ALLOC(session, pubkey_len);
++ if (!pubkey) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for public key data", 0);
++ fclose(fd);
++ return -1;
++ }
++ if (fread(pubkey, 1, pubkey_len, fd) != pubkey_len) {
++ libssh2_error(session, LIBSSH2_ERROR_FILE,
++ "Unable to read public key from file", 0);
++ LIBSSH2_FREE(session, pubkey);
++ fclose(fd);
++ return -1;
++ }
++ fclose(fd);
++ /*
++ * Remove trailing whitespace
++ */
++ while (pubkey_len && isspace(pubkey[pubkey_len - 1]))
++ pubkey_len--;
++
++ if (!pubkey_len) {
++ libssh2_error(session, LIBSSH2_ERROR_FILE, "Missing public key data",
++ 0);
++ LIBSSH2_FREE(session, pubkey);
++ return -1;
++ }
++
++ if ((sp1 = memchr(pubkey, ' ', pubkey_len)) == NULL) {
++ libssh2_error(session, LIBSSH2_ERROR_FILE, "Invalid public key data",
++ 0);
++ LIBSSH2_FREE(session, pubkey);
++ return -1;
++ }
++ /* Wasting some bytes here (okay, more than some),
++ * but since it's likely to be freed soon anyway,
++ * we'll just avoid the extra free/alloc and call it a wash */
++ *method = pubkey;
++ *method_len = sp1 - pubkey;
++
++ sp1++;
++
++ if ((sp2 = memchr(sp1, ' ', pubkey_len - *method_len)) == NULL) {
++ /* Assume that the id string is missing, but that it's okay */
++ sp2 = pubkey + pubkey_len;
++ }
++
++ if (libssh2_base64_decode
++ (session, (char **) &tmp, &tmp_len, (char *) sp1, sp2 - sp1)) {
++ libssh2_error(session, LIBSSH2_ERROR_FILE,
++ "Invalid key data, not base64 encoded", 0);
++ LIBSSH2_FREE(session, pubkey);
++ return -1;
++ }
++ *pubkeydata = tmp;
++ *pubkeydata_len = tmp_len;
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_file_read_privatekey
++ * Read a PEM encoded private key from an id_??? style file
++ */
++static int
++libssh2_file_read_privatekey(LIBSSH2_SESSION * session,
++ const LIBSSH2_HOSTKEY_METHOD ** hostkey_method,
++ void **hostkey_abstract,
++ const unsigned char *method, int method_len,
++ const char *privkeyfile, const char *passphrase)
++{
++ const LIBSSH2_HOSTKEY_METHOD **hostkey_methods_avail =
++ libssh2_hostkey_methods();
++
++ _libssh2_debug(session, LIBSSH2_DBG_AUTH, "Loading private key file: %s",
++ privkeyfile);
++ *hostkey_method = NULL;
++ *hostkey_abstract = NULL;
++ while (*hostkey_methods_avail && (*hostkey_methods_avail)->name) {
++ if ((*hostkey_methods_avail)->initPEM
++ && strncmp((*hostkey_methods_avail)->name, (const char *) method,
++ method_len) == 0) {
++ *hostkey_method = *hostkey_methods_avail;
++ break;
++ }
++ hostkey_methods_avail++;
++ }
++ if (!*hostkey_method) {
++ libssh2_error(session, LIBSSH2_ERROR_METHOD_NONE,
++ "No handler for specified private key", 0);
++ return -1;
++ }
++
++ if ((*hostkey_method)->
++ initPEM(session, privkeyfile, (unsigned char *) passphrase,
++ hostkey_abstract)) {
++ libssh2_error(session, LIBSSH2_ERROR_FILE,
++ "Unable to initialize private key from file", 0);
++ return -1;
++ }
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_userauth_hostbased_fromfile_ex
++ * Authenticate using a keypair found in the named files
++ */
++LIBSSH2_API int
++libssh2_userauth_hostbased_fromfile_ex(LIBSSH2_SESSION * session,
++ const char *username,
++ unsigned int username_len,
++ const char *publickey,
++ const char *privatekey,
++ const char *passphrase,
++ const char *hostname,
++ unsigned int hostname_len,
++ const char *local_username,
++ unsigned int local_username_len)
++{
++ static const unsigned char reply_codes[3] =
++ { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, 0 };
++ int rc;
++
++ if (session->userauth_host_state == libssh2_NB_state_idle) {
++ const LIBSSH2_HOSTKEY_METHOD *privkeyobj;
++ unsigned char *pubkeydata, *sig;
++ unsigned long pubkeydata_len;
++ unsigned long sig_len;
++ void *abstract;
++ unsigned char buf[5];
++ struct iovec datavec[4];
++
++ /* Zero the whole thing out */
++ memset(&session->userauth_host_packet_requirev_state, 0,
++ sizeof(session->userauth_host_packet_requirev_state));
++
++ if (libssh2_file_read_publickey
++ (session, &session->userauth_host_method,
++ &session->userauth_host_method_len, &pubkeydata, &pubkeydata_len,
++ publickey)) {
++ return -1;
++ }
++
++ /*
++ * 48 = packet_type(1) + username_len(4) + servicename_len(4) +
++ * service_name(14)"ssh-connection" + authmethod_len(4) +
++ * authmethod(9)"hostbased" + method_len(4) + pubkeydata_len(4) +
++ * local_username_len(4)
++ */
++ session->userauth_host_packet_len =
++ username_len + session->userauth_host_method_len + hostname_len +
++ local_username_len + pubkeydata_len + 48;
++
++ /*
++ * Preallocate space for an overall length, method name again,
++ * and the signature, which won't be any larger than the size of
++ * the publickeydata itself
++ */
++ session->userauth_host_s = session->userauth_host_packet =
++ LIBSSH2_ALLOC(session,
++ session->userauth_host_packet_len + 4 + (4 +
++ session->
++ userauth_host_method_len)
++ + (4 + pubkeydata_len));
++ if (!session->userauth_host_packet) {
++ LIBSSH2_FREE(session, session->userauth_host_method);
++ session->userauth_host_method = NULL;
++ return -1;
++ }
++
++ *(session->userauth_host_s++) = SSH_MSG_USERAUTH_REQUEST;
++ libssh2_htonu32(session->userauth_host_s, username_len);
++ session->userauth_host_s += 4;
++ memcpy(session->userauth_host_s, username, username_len);
++ session->userauth_host_s += username_len;
++
++ libssh2_htonu32(session->userauth_host_s, 14);
++ session->userauth_host_s += 4;
++ memcpy(session->userauth_host_s, "ssh-connection", 14);
++ session->userauth_host_s += 14;
++
++ libssh2_htonu32(session->userauth_host_s, 9);
++ session->userauth_host_s += 4;
++ memcpy(session->userauth_host_s, "hostbased", 9);
++ session->userauth_host_s += 9;
++
++ libssh2_htonu32(session->userauth_host_s,
++ session->userauth_host_method_len);
++ session->userauth_host_s += 4;
++ memcpy(session->userauth_host_s, session->userauth_host_method,
++ session->userauth_host_method_len);
++ session->userauth_host_s += session->userauth_host_method_len;
++
++ libssh2_htonu32(session->userauth_host_s, pubkeydata_len);
++ session->userauth_host_s += 4;
++ memcpy(session->userauth_host_s, pubkeydata, pubkeydata_len);
++ session->userauth_host_s += pubkeydata_len;
++
++ libssh2_htonu32(session->userauth_host_s, hostname_len);
++ session->userauth_host_s += 4;
++ memcpy(session->userauth_host_s, hostname, hostname_len);
++ session->userauth_host_s += hostname_len;
++
++ libssh2_htonu32(session->userauth_host_s, local_username_len);
++ session->userauth_host_s += 4;
++ memcpy(session->userauth_host_s, local_username, local_username_len);
++ session->userauth_host_s += local_username_len;
++
++ if (libssh2_file_read_privatekey
++ (session, &privkeyobj, &abstract, session->userauth_host_method,
++ session->userauth_host_method_len, privatekey, passphrase)) {
++ LIBSSH2_FREE(session, session->userauth_host_method);
++ session->userauth_host_method = NULL;
++ LIBSSH2_FREE(session, session->userauth_host_packet);
++ session->userauth_host_packet = NULL;
++ return -1;
++ }
++
++ libssh2_htonu32(buf, session->session_id_len);
++ datavec[0].iov_base = buf;
++ datavec[0].iov_len = 4;
++ datavec[1].iov_base = session->session_id;
++ datavec[1].iov_len = session->session_id_len;
++ datavec[2].iov_base = session->userauth_host_packet;
++ datavec[2].iov_len = session->userauth_host_packet_len;
++
++ if (privkeyobj->signv(session, &sig, &sig_len, 3, datavec, &abstract)) {
++ LIBSSH2_FREE(session, session->userauth_host_method);
++ session->userauth_host_method = NULL;
++ LIBSSH2_FREE(session, session->userauth_host_packet);
++ session->userauth_host_packet = NULL;
++ if (privkeyobj->dtor) {
++ privkeyobj->dtor(session, &abstract);
++ }
++ return -1;
++ }
++
++ if (privkeyobj->dtor) {
++ privkeyobj->dtor(session, &abstract);
++ }
++
++ if (sig_len > pubkeydata_len) {
++ unsigned char *newpacket;
++ /* Should *NEVER* happen, but...well.. better safe than sorry */
++ newpacket = LIBSSH2_REALLOC(session, session->userauth_host_packet, session->userauth_host_packet_len + 4 + (4 + session->userauth_host_method_len) + (4 + sig_len)); /* PK sigblob */
++ if (!newpacket) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Failed allocating additional space for userauth-hostbased packet",
++ 0);
++ LIBSSH2_FREE(session, sig);
++ LIBSSH2_FREE(session, session->userauth_host_packet);
++ session->userauth_host_packet = NULL;
++ LIBSSH2_FREE(session, session->userauth_host_method);
++ session->userauth_host_method = NULL;
++ return -1;
++ }
++ session->userauth_host_packet = newpacket;
++ }
++
++ session->userauth_host_s =
++ session->userauth_host_packet + session->userauth_host_packet_len;
++
++ libssh2_htonu32(session->userauth_host_s,
++ 4 + session->userauth_host_method_len + 4 + sig_len);
++ session->userauth_host_s += 4;
++
++ libssh2_htonu32(session->userauth_host_s,
++ session->userauth_host_method_len);
++ session->userauth_host_s += 4;
++ memcpy(session->userauth_host_s, session->userauth_host_method,
++ session->userauth_host_method_len);
++ session->userauth_host_s += session->userauth_host_method_len;
++ LIBSSH2_FREE(session, session->userauth_host_method);
++ session->userauth_host_method = NULL;
++
++ libssh2_htonu32(session->userauth_host_s, sig_len);
++ session->userauth_host_s += 4;
++ memcpy(session->userauth_host_s, sig, sig_len);
++ session->userauth_host_s += sig_len;
++ LIBSSH2_FREE(session, sig);
++
++ _libssh2_debug(session, LIBSSH2_DBG_AUTH,
++ "Attempting hostbased authentication");
++
++ session->userauth_host_state = libssh2_NB_state_created;
++ }
++
++ if (session->userauth_host_state == libssh2_NB_state_created) {
++ rc = libssh2_packet_write(session, session->userauth_host_packet,
++ session->userauth_host_s -
++ session->userauth_host_packet);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send userauth-hostbased request", 0);
++ LIBSSH2_FREE(session, session->userauth_host_packet);
++ session->userauth_host_packet = NULL;
++ session->userauth_host_state = libssh2_NB_state_idle;
++ return -1;
++ }
++ LIBSSH2_FREE(session, session->userauth_host_packet);
++ session->userauth_host_packet = NULL;
++
++ session->userauth_host_state = libssh2_NB_state_sent;
++ }
++
++ if (session->userauth_host_state == libssh2_NB_state_sent) {
++ unsigned long data_len;
++ rc = libssh2_packet_requirev_ex(session, reply_codes,
++ &session->userauth_host_data,
++ &data_len, 0, NULL, 0,
++ &session->
++ userauth_host_packet_requirev_state);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ session->userauth_host_state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ if (session->userauth_host_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
++ _libssh2_debug(session, LIBSSH2_DBG_AUTH,
++ "Hostbased authentication successful");
++ /* We are us and we've proved it. */
++ LIBSSH2_FREE(session, session->userauth_host_data);
++ session->userauth_host_data = NULL;
++ session->state |= LIBSSH2_STATE_AUTHENTICATED;
++ session->userauth_host_state = libssh2_NB_state_idle;
++ return 0;
++ }
++ }
++
++ /* This public key is not allowed for this user on this server */
++ LIBSSH2_FREE(session, session->userauth_host_data);
++ session->userauth_host_data = NULL;
++ libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
++ "Invalid signature for supplied public key, or bad username/public key combination",
++ 0);
++ session->userauth_host_state = libssh2_NB_state_idle;
++ return -1;
++}
++
++/* }}} */
++
++/* {{{ libssh2_userauth_publickey_fromfile_ex
++ * Authenticate using a keypair found in the named files
++ */
++LIBSSH2_API int
++libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION * session,
++ const char *username,
++ unsigned int username_len,
++ const char *publickey,
++ const char *privatekey,
++ const char *passphrase)
++{
++ unsigned long pubkeydata_len = 0;
++ unsigned char reply_codes[4] =
++ { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE,
++ SSH_MSG_USERAUTH_PK_OK, 0
++ };
++ int rc;
++
++ if (session->userauth_pblc_state == libssh2_NB_state_idle) {
++ unsigned char *pubkeydata;
++
++ /* Zero the whole thing out */
++ memset(&session->userauth_pblc_packet_requirev_state, 0,
++ sizeof(session->userauth_pblc_packet_requirev_state));
++
++ if (libssh2_file_read_publickey
++ (session, &session->userauth_pblc_method,
++ &session->userauth_pblc_method_len, &pubkeydata, &pubkeydata_len,
++ publickey)) {
++ return -1;
++ }
++
++ /*
++ * 45 = packet_type(1) + username_len(4) + servicename_len(4) +
++ * service_name(14)"ssh-connection" + authmethod_len(4) +
++ * authmethod(9)"publickey" + sig_included(1)'\0' + algmethod_len(4) +
++ * publickey_len(4)
++ */
++ session->userauth_pblc_packet_len =
++ username_len + session->userauth_pblc_method_len + pubkeydata_len +
++ 45;
++
++ /*
++ * Preallocate space for an overall length, method name again, and
++ * the signature, which won't be any larger than the size of the
++ * publickeydata itself
++ */
++ session->userauth_pblc_s = session->userauth_pblc_packet =
++ LIBSSH2_ALLOC(session,
++ session->userauth_pblc_packet_len + 4 + (4 +
++ session->
++ userauth_pblc_method_len)
++ + (4 + pubkeydata_len));
++ if (!session->userauth_pblc_packet) {
++ LIBSSH2_FREE(session, session->userauth_pblc_method);
++ session->userauth_pblc_method = NULL;
++ LIBSSH2_FREE(session, pubkeydata);
++ return -1;
++ }
++
++ *(session->userauth_pblc_s++) = SSH_MSG_USERAUTH_REQUEST;
++ libssh2_htonu32(session->userauth_pblc_s, username_len);
++ session->userauth_pblc_s += 4;
++ memcpy(session->userauth_pblc_s, username, username_len);
++ session->userauth_pblc_s += username_len;
++
++ libssh2_htonu32(session->userauth_pblc_s, 14);
++ session->userauth_pblc_s += 4;
++ memcpy(session->userauth_pblc_s, "ssh-connection", 14);
++ session->userauth_pblc_s += 14;
++
++ libssh2_htonu32(session->userauth_pblc_s, 9);
++ session->userauth_pblc_s += 4;
++ memcpy(session->userauth_pblc_s, "publickey", 9);
++ session->userauth_pblc_s += 9;
++
++ session->userauth_pblc_b = session->userauth_pblc_s;
++ /* Not sending signature with *this* packet */
++ *(session->userauth_pblc_s++) = 0;
++
++ libssh2_htonu32(session->userauth_pblc_s,
++ session->userauth_pblc_method_len);
++ session->userauth_pblc_s += 4;
++ memcpy(session->userauth_pblc_s, session->userauth_pblc_method,
++ session->userauth_pblc_method_len);
++ session->userauth_pblc_s += session->userauth_pblc_method_len;
++
++ libssh2_htonu32(session->userauth_pblc_s, pubkeydata_len);
++ session->userauth_pblc_s += 4;
++ memcpy(session->userauth_pblc_s, pubkeydata, pubkeydata_len);
++ session->userauth_pblc_s += pubkeydata_len;
++ LIBSSH2_FREE(session, pubkeydata);
++
++ _libssh2_debug(session, LIBSSH2_DBG_AUTH,
++ "Attempting publickey authentication");
++
++ session->userauth_pblc_state = libssh2_NB_state_created;
++ }
++
++ if (session->userauth_pblc_state == libssh2_NB_state_created) {
++ rc = libssh2_packet_write(session, session->userauth_pblc_packet,
++ session->userauth_pblc_packet_len);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send userauth-publickey request", 0);
++ LIBSSH2_FREE(session, session->userauth_pblc_packet);
++ session->userauth_pblc_packet = NULL;
++ LIBSSH2_FREE(session, session->userauth_pblc_method);
++ session->userauth_pblc_method = NULL;
++ session->userauth_pblc_state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ session->userauth_pblc_state = libssh2_NB_state_sent;
++ }
++
++ if (session->userauth_pblc_state == libssh2_NB_state_sent) {
++ const LIBSSH2_HOSTKEY_METHOD *privkeyobj;
++ void *abstract;
++ unsigned char buf[5];
++ struct iovec datavec[4];
++ unsigned char *sig;
++ unsigned long sig_len;
++
++ rc = libssh2_packet_requirev_ex(session, reply_codes,
++ &session->userauth_pblc_data,
++ &session->userauth_pblc_data_len, 0,
++ NULL, 0,
++ &session->
++ userauth_pblc_packet_requirev_state);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ LIBSSH2_FREE(session, session->userauth_pblc_packet);
++ session->userauth_pblc_packet = NULL;
++ LIBSSH2_FREE(session, session->userauth_pblc_method);
++ session->userauth_pblc_method = NULL;
++ session->userauth_pblc_state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ if (session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
++ _libssh2_debug(session, LIBSSH2_DBG_AUTH,
++ "Pubkey authentication prematurely successful");
++ /*
++ * God help any SSH server that allows an UNVERIFIED
++ * public key to validate the user
++ */
++ LIBSSH2_FREE(session, session->userauth_pblc_data);
++ session->userauth_pblc_data = NULL;
++ LIBSSH2_FREE(session, session->userauth_pblc_packet);
++ session->userauth_pblc_packet = NULL;
++ LIBSSH2_FREE(session, session->userauth_pblc_method);
++ session->userauth_pblc_method = NULL;
++ session->state |= LIBSSH2_STATE_AUTHENTICATED;
++ session->userauth_pblc_state = libssh2_NB_state_idle;
++ return 0;
++ }
++
++ if (session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_FAILURE) {
++ /* This public key is not allowed for this user on this server */
++ LIBSSH2_FREE(session, session->userauth_pblc_data);
++ session->userauth_pblc_data = NULL;
++ LIBSSH2_FREE(session, session->userauth_pblc_packet);
++ session->userauth_pblc_packet = NULL;
++ LIBSSH2_FREE(session, session->userauth_pblc_method);
++ session->userauth_pblc_method = NULL;
++ libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNRECOGNIZED,
++ "Username/PublicKey combination invalid", 0);
++ session->userauth_pblc_state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ /* Semi-Success! */
++ LIBSSH2_FREE(session, session->userauth_pblc_data);
++ session->userauth_pblc_data = NULL;
++
++ if (libssh2_file_read_privatekey
++ (session, &privkeyobj, &abstract, session->userauth_pblc_method,
++ session->userauth_pblc_method_len, privatekey, passphrase)) {
++ LIBSSH2_FREE(session, session->userauth_pblc_method);
++ session->userauth_pblc_method = NULL;
++ LIBSSH2_FREE(session, session->userauth_pblc_packet);
++ session->userauth_pblc_packet = NULL;
++ session->userauth_pblc_state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ *session->userauth_pblc_b = 0x01;
++
++ libssh2_htonu32(buf, session->session_id_len);
++ datavec[0].iov_base = buf;
++ datavec[0].iov_len = 4;
++ datavec[1].iov_base = session->session_id;
++ datavec[1].iov_len = session->session_id_len;
++ datavec[2].iov_base = session->userauth_pblc_packet;
++ datavec[2].iov_len = session->userauth_pblc_packet_len;
++
++ if (privkeyobj->signv(session, &sig, &sig_len, 3, datavec, &abstract)) {
++ LIBSSH2_FREE(session, session->userauth_pblc_method);
++ session->userauth_pblc_method = NULL;
++ LIBSSH2_FREE(session, session->userauth_pblc_packet);
++ session->userauth_pblc_packet = NULL;
++ if (privkeyobj->dtor) {
++ privkeyobj->dtor(session, &abstract);
++ }
++ session->userauth_pblc_state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ if (privkeyobj->dtor) {
++ privkeyobj->dtor(session, &abstract);
++ }
++
++ /*
++ * If this function was restarted, pubkeydata_len might still be 0
++ * which will cause an unnecessary but harmless realloc here.
++ */
++ if (sig_len > pubkeydata_len) {
++ unsigned char *newpacket;
++ /* Should *NEVER* happen, but...well.. better safe than sorry */
++ newpacket = LIBSSH2_REALLOC(session, session->userauth_pblc_packet, session->userauth_pblc_packet_len + 4 + (4 + session->userauth_pblc_method_len) + (4 + sig_len)); /* PK sigblob */
++ if (!newpacket) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Failed allocating additional space for userauth-publickey packet",
++ 0);
++ LIBSSH2_FREE(session, sig);
++ LIBSSH2_FREE(session, session->userauth_pblc_packet);
++ session->userauth_pblc_packet = NULL;
++ LIBSSH2_FREE(session, session->userauth_pblc_method);
++ session->userauth_pblc_method = NULL;
++ session->userauth_pblc_state = libssh2_NB_state_idle;
++ return -1;
++ }
++ session->userauth_pblc_packet = newpacket;
++ }
++
++ session->userauth_pblc_s =
++ session->userauth_pblc_packet + session->userauth_pblc_packet_len;
++ session->userauth_pblc_b = NULL;
++
++ libssh2_htonu32(session->userauth_pblc_s,
++ 4 + session->userauth_pblc_method_len + 4 + sig_len);
++ session->userauth_pblc_s += 4;
++
++ libssh2_htonu32(session->userauth_pblc_s,
++ session->userauth_pblc_method_len);
++ session->userauth_pblc_s += 4;
++ memcpy(session->userauth_pblc_s, session->userauth_pblc_method,
++ session->userauth_pblc_method_len);
++ session->userauth_pblc_s += session->userauth_pblc_method_len;
++ LIBSSH2_FREE(session, session->userauth_pblc_method);
++ session->userauth_pblc_method = NULL;
++
++ libssh2_htonu32(session->userauth_pblc_s, sig_len);
++ session->userauth_pblc_s += 4;
++ memcpy(session->userauth_pblc_s, sig, sig_len);
++ session->userauth_pblc_s += sig_len;
++ LIBSSH2_FREE(session, sig);
++
++ _libssh2_debug(session, LIBSSH2_DBG_AUTH,
++ "Attempting publickey authentication -- phase 2");
++
++ session->userauth_pblc_state = libssh2_NB_state_sent1;
++ }
++
++ if (session->userauth_pblc_state == libssh2_NB_state_sent1) {
++ rc = libssh2_packet_write(session, session->userauth_pblc_packet,
++ session->userauth_pblc_s -
++ session->userauth_pblc_packet);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send userauth-publickey request", 0);
++ LIBSSH2_FREE(session, session->userauth_pblc_packet);
++ session->userauth_pblc_packet = NULL;
++ session->userauth_pblc_state = libssh2_NB_state_idle;
++ return -1;
++ }
++ LIBSSH2_FREE(session, session->userauth_pblc_packet);
++ session->userauth_pblc_packet = NULL;
++
++ session->userauth_pblc_state = libssh2_NB_state_sent2;
++ }
++
++ /* PK_OK is no longer valid */
++ reply_codes[2] = 0;
++
++ rc = libssh2_packet_requirev_ex(session, reply_codes,
++ &session->userauth_pblc_data,
++ &session->userauth_pblc_data_len, 0, NULL,
++ 0,
++ &session->
++ userauth_pblc_packet_requirev_state);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ session->userauth_pblc_state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ if (session->userauth_pblc_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
++ _libssh2_debug(session, LIBSSH2_DBG_AUTH,
++ "Publickey authentication successful");
++ /* We are us and we've proved it. */
++ LIBSSH2_FREE(session, session->userauth_pblc_data);
++ session->userauth_pblc_data = NULL;
++ session->state |= LIBSSH2_STATE_AUTHENTICATED;
++ session->userauth_pblc_state = libssh2_NB_state_idle;
++ return 0;
++ }
++
++ /* This public key is not allowed for this user on this server */
++ LIBSSH2_FREE(session, session->userauth_pblc_data);
++ session->userauth_pblc_data = NULL;
++ libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
++ "Invalid signature for supplied public key, or bad username/public key combination",
++ 0);
++ session->userauth_pblc_state = libssh2_NB_state_idle;
++ return -1;
++}
++
++/* }}} */
++
++/* {{{ libssh2_userauth_keyboard_interactive
++ * Authenticate using a challenge-response authentication
++ */
++LIBSSH2_API int
++libssh2_userauth_keyboard_interactive_ex(LIBSSH2_SESSION * session,
++ const char *username,
++ unsigned int username_len,
++ LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC((*response_callback)))
++{
++ unsigned char *s;
++ int rc;
++
++ static const unsigned char reply_codes[4] = { SSH_MSG_USERAUTH_SUCCESS,
++ SSH_MSG_USERAUTH_FAILURE, SSH_MSG_USERAUTH_INFO_REQUEST, 0
++ };
++ unsigned int language_tag_len;
++ unsigned int i;
++
++ if (session->userauth_kybd_state == libssh2_NB_state_idle) {
++ session->userauth_kybd_auth_name = NULL;
++ session->userauth_kybd_auth_instruction = NULL;
++ session->userauth_kybd_num_prompts = 0;
++ session->userauth_kybd_auth_failure = 1;
++ session->userauth_kybd_prompts = NULL;
++ session->userauth_kybd_responses = NULL;
++
++ /* Zero the whole thing out */
++ memset(&session->userauth_kybd_packet_requirev_state, 0,
++ sizeof(session->userauth_kybd_packet_requirev_state));
++
++ session->userauth_kybd_packet_len = 1 /* byte SSH_MSG_USERAUTH_REQUEST */
++ + 4 + username_len /* string user name (ISO-10646 UTF-8, as defined in [RFC-3629]) */
++ + 4 + 14 /* string service name (US-ASCII) */
++ + 4 + 20 /* string "keyboard-interactive" (US-ASCII) */
++ + 4 + 0 /* string language tag (as defined in [RFC-3066]) */
++ + 4 + 0 /* string submethods (ISO-10646 UTF-8) */
++ ;
++
++ session->userauth_kybd_data = s =
++ LIBSSH2_ALLOC(session, session->userauth_kybd_packet_len);
++ if (!s) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for keyboard-interactive authentication",
++ 0);
++ return -1;
++ }
++
++ *s++ = SSH_MSG_USERAUTH_REQUEST;
++
++ /* user name */
++ libssh2_htonu32(s, username_len);
++ s += 4;
++ memcpy(s, username, username_len);
++ s += username_len;
++
++ /* service name */
++ libssh2_htonu32(s, sizeof("ssh-connection") - 1);
++ s += 4;
++ memcpy(s, "ssh-connection", sizeof("ssh-connection") - 1);
++ s += sizeof("ssh-connection") - 1;
++
++ /* "keyboard-interactive" */
++ libssh2_htonu32(s, sizeof("keyboard-interactive") - 1);
++ s += 4;
++ memcpy(s, "keyboard-interactive", sizeof("keyboard-interactive") - 1);
++ s += sizeof("keyboard-interactive") - 1;
++
++ /* language tag */
++ libssh2_htonu32(s, 0);
++ s += 4;
++
++ /* submethods */
++ libssh2_htonu32(s, 0);
++ s += 4;
++
++ _libssh2_debug(session, LIBSSH2_DBG_AUTH,
++ "Attempting keyboard-interactive authentication");
++
++ session->userauth_kybd_state = libssh2_NB_state_created;
++ }
++
++ if (session->userauth_kybd_state == libssh2_NB_state_created) {
++ rc = libssh2_packet_write(session, session->userauth_kybd_data,
++ session->userauth_kybd_packet_len);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send keyboard-interactive request", 0);
++ LIBSSH2_FREE(session, session->userauth_kybd_data);
++ session->userauth_kybd_data = NULL;
++ session->userauth_kybd_state = libssh2_NB_state_idle;
++ return -1;
++ }
++ LIBSSH2_FREE(session, session->userauth_kybd_data);
++ session->userauth_kybd_data = NULL;
++
++ session->userauth_kybd_state = libssh2_NB_state_sent;
++ }
++
++ for(;;) {
++ if (session->userauth_kybd_state == libssh2_NB_state_sent) {
++ rc = libssh2_packet_requirev_ex(session, reply_codes,
++ &session->userauth_kybd_data,
++ &session->userauth_kybd_data_len,
++ 0, NULL, 0,
++ &session->
++ userauth_kybd_packet_requirev_state);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ session->userauth_kybd_state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ if (session->userauth_kybd_data[0] == SSH_MSG_USERAUTH_SUCCESS) {
++ _libssh2_debug(session, LIBSSH2_DBG_AUTH,
++ "Keyboard-interactive authentication successful");
++ LIBSSH2_FREE(session, session->userauth_kybd_data);
++ session->userauth_kybd_data = NULL;
++ session->state |= LIBSSH2_STATE_AUTHENTICATED;
++ session->userauth_kybd_state = libssh2_NB_state_idle;
++ return 0;
++ }
++
++ if (session->userauth_kybd_data[0] == SSH_MSG_USERAUTH_FAILURE) {
++ LIBSSH2_FREE(session, session->userauth_kybd_data);
++ session->userauth_kybd_data = NULL;
++ session->userauth_kybd_state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ /* server requested PAM-like conversation */
++
++ s = session->userauth_kybd_data + 1;
++
++ /* string name (ISO-10646 UTF-8) */
++ session->userauth_kybd_auth_name_len = libssh2_ntohu32(s);
++ s += 4;
++ session->userauth_kybd_auth_name =
++ LIBSSH2_ALLOC(session, session->userauth_kybd_auth_name_len);
++ if (!session->userauth_kybd_auth_name) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for keyboard-interactive 'name' request field",
++ 0);
++ goto cleanup;
++ }
++ memcpy(session->userauth_kybd_auth_name, s,
++ session->userauth_kybd_auth_name_len);
++ s += session->userauth_kybd_auth_name_len;
++
++ /* string instruction (ISO-10646 UTF-8) */
++ session->userauth_kybd_auth_instruction_len = libssh2_ntohu32(s);
++ s += 4;
++ session->userauth_kybd_auth_instruction =
++ LIBSSH2_ALLOC(session,
++ session->userauth_kybd_auth_instruction_len);
++ if (!session->userauth_kybd_auth_instruction) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for keyboard-interactive 'instruction' request field",
++ 0);
++ goto cleanup;
++ }
++ memcpy(session->userauth_kybd_auth_instruction, s,
++ session->userauth_kybd_auth_instruction_len);
++ s += session->userauth_kybd_auth_instruction_len;
++
++ /* string language tag (as defined in [RFC-3066]) */
++ language_tag_len = libssh2_ntohu32(s);
++ s += 4;
++ /* ignoring this field as deprecated */
++ s += language_tag_len;
++
++ /* int num-prompts */
++ session->userauth_kybd_num_prompts = libssh2_ntohu32(s);
++ s += 4;
++
++ session->userauth_kybd_prompts =
++ LIBSSH2_ALLOC(session,
++ sizeof(LIBSSH2_USERAUTH_KBDINT_PROMPT) *
++ session->userauth_kybd_num_prompts);
++ if (!session->userauth_kybd_prompts) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for keyboard-interactive prompts array",
++ 0);
++ goto cleanup;
++ }
++ memset(session->userauth_kybd_prompts, 0,
++ sizeof(LIBSSH2_USERAUTH_KBDINT_PROMPT) *
++ session->userauth_kybd_num_prompts);
++
++ session->userauth_kybd_responses =
++ LIBSSH2_ALLOC(session,
++ sizeof(LIBSSH2_USERAUTH_KBDINT_RESPONSE) *
++ session->userauth_kybd_num_prompts);
++ if (!session->userauth_kybd_responses) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for keyboard-interactive responses array",
++ 0);
++ goto cleanup;
++ }
++ memset(session->userauth_kybd_responses, 0,
++ sizeof(LIBSSH2_USERAUTH_KBDINT_RESPONSE) *
++ session->userauth_kybd_num_prompts);
++
++ for(i = 0; i != session->userauth_kybd_num_prompts; ++i) {
++ /* string prompt[1] (ISO-10646 UTF-8) */
++ session->userauth_kybd_prompts[i].length = libssh2_ntohu32(s);
++ s += 4;
++ session->userauth_kybd_prompts[i].text =
++ LIBSSH2_ALLOC(session,
++ session->userauth_kybd_prompts[i].length);
++ if (!session->userauth_kybd_prompts[i].text) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for keyboard-interactive prompt message",
++ 0);
++ goto cleanup;
++ }
++ memcpy(session->userauth_kybd_prompts[i].text, s,
++ session->userauth_kybd_prompts[i].length);
++ s += session->userauth_kybd_prompts[i].length;
++
++ /* boolean echo[1] */
++ session->userauth_kybd_prompts[i].echo = *s++;
++ }
++
++ response_callback(session->userauth_kybd_auth_name,
++ session->userauth_kybd_auth_name_len,
++ session->userauth_kybd_auth_instruction,
++ session->userauth_kybd_auth_instruction_len,
++ session->userauth_kybd_num_prompts,
++ session->userauth_kybd_prompts,
++ session->userauth_kybd_responses,
++ &session->abstract);
++
++ _libssh2_debug(session, LIBSSH2_DBG_AUTH,
++ "Keyboard-interactive response callback function invoked");
++
++ session->userauth_kybd_packet_len = 1 /* byte SSH_MSG_USERAUTH_INFO_RESPONSE */
++ + 4 /* int num-responses */
++ ;
++
++ for(i = 0; i != session->userauth_kybd_num_prompts; ++i) {
++ /* string response[1] (ISO-10646 UTF-8) */
++ session->userauth_kybd_packet_len +=
++ 4 + session->userauth_kybd_responses[i].length;
++ }
++
++ session->userauth_kybd_data = s =
++ LIBSSH2_ALLOC(session, session->userauth_kybd_packet_len);
++ if (!s) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for keyboard-interactive response packet",
++ 0);
++ goto cleanup;
++ }
++
++ *s = SSH_MSG_USERAUTH_INFO_RESPONSE;
++ s++;
++ libssh2_htonu32(s, session->userauth_kybd_num_prompts);
++ s += 4;
++
++ for(i = 0; i != session->userauth_kybd_num_prompts; ++i) {
++ libssh2_htonu32(s, session->userauth_kybd_responses[i].length);
++ s += 4;
++ memcpy(s, session->userauth_kybd_responses[i].text,
++ session->userauth_kybd_responses[i].length);
++ s += session->userauth_kybd_responses[i].length;
++ }
++
++ session->userauth_kybd_state = libssh2_NB_state_sent1;
++ }
++
++ if (session->userauth_kybd_state == libssh2_NB_state_sent1) {
++ rc = libssh2_packet_write(session, session->userauth_kybd_data,
++ session->userauth_kybd_packet_len);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ }
++ if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send userauth-keyboard-interactive request",
++ 0);
++ goto cleanup;
++ }
++
++ session->userauth_kybd_auth_failure = 0;
++ }
++
++ cleanup:
++ /*
++ * It's safe to clean all the data here, because unallocated pointers
++ * are filled by zeroes
++ */
++
++ LIBSSH2_FREE(session, session->userauth_kybd_data);
++ session->userauth_kybd_data = NULL;
++
++ if (session->userauth_kybd_prompts) {
++ for(i = 0; i != session->userauth_kybd_num_prompts; ++i) {
++ LIBSSH2_FREE(session, session->userauth_kybd_prompts[i].text);
++ session->userauth_kybd_prompts[i].text = NULL;
++ }
++ }
++
++ if (session->userauth_kybd_responses) {
++ for(i = 0; i != session->userauth_kybd_num_prompts; ++i) {
++ LIBSSH2_FREE(session,
++ session->userauth_kybd_responses[i].text);
++ session->userauth_kybd_responses[i].text = NULL;
++ }
++ }
++
++ LIBSSH2_FREE(session, session->userauth_kybd_prompts);
++ session->userauth_kybd_prompts = NULL;
++ LIBSSH2_FREE(session, session->userauth_kybd_responses);
++ session->userauth_kybd_responses = NULL;
++
++ if (session->userauth_kybd_auth_failure) {
++ session->userauth_kybd_state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ session->userauth_kybd_state = libssh2_NB_state_sent;
++ }
++}
++
++/* }}} */
+
+Property changes on: libssh2/src/userauth.c
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.2
+Added: svn:eol-style
+ + native
+
+Index: libssh2/src/mac.c
+===================================================================
+--- libssh2/src/mac.c (.../tags/RELEASE_0_11_0)
++++ libssh2/src/mac.c (.../trunk)
+@@ -0,0 +1,311 @@
++/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
++ * 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"
++
++#ifdef LIBSSH2_MAC_NONE
++/* {{{ libssh2_mac_none_MAC
++ * Minimalist MAC: No MAC
++ */
++static int
++libssh2_mac_none_MAC(LIBSSH2_SESSION * session, unsigned char *buf,
++ unsigned long seqno, const unsigned char *packet,
++ unsigned long packet_len, const unsigned char *addtl,
++ unsigned long addtl_len, void **abstract)
++{
++ return 0;
++}
++
++/* }}} */
++
++
++static LIBSSH2_MAC_METHOD libssh2_mac_method_none = {
++ "none",
++ 0,
++ 0,
++ NULL,
++ libssh2_mac_none_MAC,
++ NULL
++};
++#endif /* LIBSSH2_MAC_NONE */
++
++/* {{{ libssh2_mac_method_common_init
++ * Initialize simple mac methods
++ */
++static int
++libssh2_mac_method_common_init(LIBSSH2_SESSION * session, unsigned char *key,
++ int *free_key, void **abstract)
++{
++ *abstract = key;
++ *free_key = 0;
++ (void) session;
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_mac_method_common_dtor
++ * Cleanup simple mac methods
++ */
++static int
++libssh2_mac_method_common_dtor(LIBSSH2_SESSION * session, void **abstract)
++{
++ if (*abstract) {
++ LIBSSH2_FREE(session, *abstract);
++ }
++ *abstract = NULL;
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_mac_method_hmac_sha1_hash
++ * Calculate hash using full sha1 value
++ */
++static int
++libssh2_mac_method_hmac_sha1_hash(LIBSSH2_SESSION * session,
++ unsigned char *buf, unsigned long seqno,
++ const unsigned char *packet,
++ unsigned long packet_len,
++ const unsigned char *addtl,
++ unsigned long addtl_len, void **abstract)
++{
++ libssh2_hmac_ctx ctx;
++ unsigned char seqno_buf[4];
++ (void) session;
++
++ libssh2_htonu32(seqno_buf, seqno);
++
++ libssh2_hmac_sha1_init(&ctx, *abstract, 20);
++ libssh2_hmac_update(ctx, seqno_buf, 4);
++ libssh2_hmac_update(ctx, packet, packet_len);
++ if (addtl && addtl_len) {
++ libssh2_hmac_update(ctx, addtl, addtl_len);
++ }
++ libssh2_hmac_final(ctx, buf);
++ libssh2_hmac_cleanup(&ctx);
++
++ return 0;
++}
++
++/* }}} */
++
++static const LIBSSH2_MAC_METHOD libssh2_mac_method_hmac_sha1 = {
++ "hmac-sha1",
++ 20,
++ 20,
++ libssh2_mac_method_common_init,
++ libssh2_mac_method_hmac_sha1_hash,
++ libssh2_mac_method_common_dtor,
++};
++
++/* {{{ libssh2_mac_method_hmac_sha1_96_hash
++ * Calculate hash using first 96 bits of sha1 value
++ */
++static int
++libssh2_mac_method_hmac_sha1_96_hash(LIBSSH2_SESSION * session,
++ unsigned char *buf, unsigned long seqno,
++ const unsigned char *packet,
++ unsigned long packet_len,
++ const unsigned char *addtl,
++ unsigned long addtl_len, void **abstract)
++{
++ unsigned char temp[SHA_DIGEST_LENGTH];
++
++ libssh2_mac_method_hmac_sha1_hash(session, temp, seqno, packet, packet_len,
++ addtl, addtl_len, abstract);
++ memcpy(buf, (char *) temp, 96 / 8);
++
++ return 0;
++}
++
++/* }}} */
++
++static const LIBSSH2_MAC_METHOD libssh2_mac_method_hmac_sha1_96 = {
++ "hmac-sha1-96",
++ 12,
++ 20,
++ libssh2_mac_method_common_init,
++ libssh2_mac_method_hmac_sha1_96_hash,
++ libssh2_mac_method_common_dtor,
++};
++
++/* {{{ libssh2_mac_method_hmac_md5_hash
++ * Calculate hash using full md5 value
++ */
++static int
++libssh2_mac_method_hmac_md5_hash(LIBSSH2_SESSION * session, unsigned char *buf,
++ unsigned long seqno,
++ const unsigned char *packet,
++ unsigned long packet_len,
++ const unsigned char *addtl,
++ unsigned long addtl_len, void **abstract)
++{
++ libssh2_hmac_ctx ctx;
++ unsigned char seqno_buf[4];
++ (void) session;
++
++ libssh2_htonu32(seqno_buf, seqno);
++
++ libssh2_hmac_md5_init(&ctx, *abstract, 16);
++ libssh2_hmac_update(ctx, seqno_buf, 4);
++ libssh2_hmac_update(ctx, packet, packet_len);
++ if (addtl && addtl_len) {
++ libssh2_hmac_update(ctx, addtl, addtl_len);
++ }
++ libssh2_hmac_final(ctx, buf);
++ libssh2_hmac_cleanup(&ctx);
++
++ return 0;
++}
++
++/* }}} */
++
++static const LIBSSH2_MAC_METHOD libssh2_mac_method_hmac_md5 = {
++ "hmac-md5",
++ 16,
++ 16,
++ libssh2_mac_method_common_init,
++ libssh2_mac_method_hmac_md5_hash,
++ libssh2_mac_method_common_dtor,
++};
++
++/* {{{ libssh2_mac_method_hmac_md5_96_hash
++ * Calculate hash using first 96 bits of md5 value
++ */
++static int
++libssh2_mac_method_hmac_md5_96_hash(LIBSSH2_SESSION * session,
++ unsigned char *buf, unsigned long seqno,
++ const unsigned char *packet,
++ unsigned long packet_len,
++ const unsigned char *addtl,
++ unsigned long addtl_len, void **abstract)
++{
++ unsigned char temp[MD5_DIGEST_LENGTH];
++
++ libssh2_mac_method_hmac_md5_hash(session, temp, seqno, packet, packet_len,
++ addtl, addtl_len, abstract);
++ memcpy(buf, (char *) temp, 96 / 8);
++
++ return 0;
++}
++
++/* }}} */
++
++static const LIBSSH2_MAC_METHOD libssh2_mac_method_hmac_md5_96 = {
++ "hmac-md5-96",
++ 12,
++ 16,
++ libssh2_mac_method_common_init,
++ libssh2_mac_method_hmac_md5_96_hash,
++ libssh2_mac_method_common_dtor,
++};
++
++#if LIBSSH2_HMAC_RIPEMD
++/* {{{ libssh2_mac_method_hmac_ripemd160_hash
++ * Calculate hash using ripemd160 value
++ */
++static int
++libssh2_mac_method_hmac_ripemd160_hash(LIBSSH2_SESSION * session,
++ unsigned char *buf, unsigned long seqno,
++ const unsigned char *packet,
++ unsigned long packet_len,
++ const unsigned char *addtl,
++ unsigned long addtl_len,
++ void **abstract)
++{
++ libssh2_hmac_ctx ctx;
++ unsigned char seqno_buf[4];
++ (void) session;
++
++ libssh2_htonu32(seqno_buf, seqno);
++
++ libssh2_hmac_ripemd160_init(&ctx, *abstract, 20);
++ libssh2_hmac_update(ctx, seqno_buf, 4);
++ libssh2_hmac_update(ctx, packet, packet_len);
++ if (addtl && addtl_len) {
++ libssh2_hmac_update(ctx, addtl, addtl_len);
++ }
++ libssh2_hmac_final(ctx, buf);
++ libssh2_hmac_cleanup(&ctx);
++
++ return 0;
++}
++
++/* }}} */
++
++static const LIBSSH2_MAC_METHOD libssh2_mac_method_hmac_ripemd160 = {
++ "hmac-ripemd160",
++ 20,
++ 20,
++ libssh2_mac_method_common_init,
++ libssh2_mac_method_hmac_ripemd160_hash,
++ libssh2_mac_method_common_dtor,
++};
++
++static const LIBSSH2_MAC_METHOD libssh2_mac_method_hmac_ripemd160_openssh_com = {
++ "hmac-ripemd160@openssh.com",
++ 20,
++ 20,
++ libssh2_mac_method_common_init,
++ libssh2_mac_method_hmac_ripemd160_hash,
++ libssh2_mac_method_common_dtor,
++};
++#endif /* LIBSSH2_HMAC_RIPEMD */
++
++static const LIBSSH2_MAC_METHOD *_libssh2_mac_methods[] = {
++ &libssh2_mac_method_hmac_sha1,
++ &libssh2_mac_method_hmac_sha1_96,
++ &libssh2_mac_method_hmac_md5,
++ &libssh2_mac_method_hmac_md5_96,
++#if LIBSSH2_HMAC_RIPEMD
++ &libssh2_mac_method_hmac_ripemd160,
++ &libssh2_mac_method_hmac_ripemd160_openssh_com,
++#endif /* LIBSSH2_HMAC_RIPEMD */
++#ifdef LIBSSH2_MAC_NONE
++ &libssh2_mac_method_none,
++#endif /* LIBSSH2_MAC_NONE */
++ NULL
++};
++
++const LIBSSH2_MAC_METHOD **
++libssh2_mac_methods(void)
++{
++ return _libssh2_mac_methods;
++}
+
+Property changes on: libssh2/src/mac.c
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.2
+Added: svn:eol-style
+ + native
+
+Index: libssh2/src/crypt.c
+===================================================================
+--- libssh2/src/crypt.c (.../tags/RELEASE_0_11_0)
++++ libssh2/src/crypt.c (.../trunk)
+@@ -0,0 +1,256 @@
++/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
++ * 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"
++
++#ifdef LIBSSH2_CRYPT_NONE
++/* {{{ libssh2_crypt_none_crypt
++ * Minimalist cipher: VERY secure *wink*
++ */
++static int
++libssh2_crypt_none_crypt(LIBSSH2_SESSION * session, unsigned char *buf,
++ void **abstract)
++{
++ /* Do nothing to the data! */
++ return 0;
++}
++
++/* }}} */
++
++static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_none = {
++ "none",
++ 8, /* blocksize (SSH2 defines minimum blocksize as 8) */
++ 0, /* iv_len */
++ 0, /* secret_len */
++ 0, /* flags */
++ NULL,
++ libssh2_crypt_none_crypt,
++ NULL
++};
++#endif /* LIBSSH2_CRYPT_NONE */
++
++struct crypt_ctx
++{
++ int encrypt;
++ _libssh2_cipher_type(algo);
++ _libssh2_cipher_ctx h;
++};
++
++static int
++_libssh2_init(LIBSSH2_SESSION * session,
++ const LIBSSH2_CRYPT_METHOD * method,
++ unsigned char *iv, int *free_iv,
++ unsigned char *secret, int *free_secret,
++ int encrypt, void **abstract)
++{
++ struct crypt_ctx *ctx = LIBSSH2_ALLOC(session,
++ sizeof(struct crypt_ctx));
++ if (!ctx) {
++ return -1;
++ }
++ ctx->encrypt = encrypt;
++ ctx->algo = method->algo;
++ if (_libssh2_cipher_init(&ctx->h, ctx->algo, iv, secret, encrypt)) {
++ LIBSSH2_FREE(session, ctx);
++ return -1;
++ }
++ *abstract = ctx;
++ *free_iv = 1;
++ *free_secret = 1;
++ return 0;
++}
++
++static int
++_libssh2_encrypt(LIBSSH2_SESSION * session, unsigned char *block,
++ void **abstract)
++{
++ struct crypt_ctx *cctx = *(struct crypt_ctx **) abstract;
++ (void) session;
++ return _libssh2_cipher_crypt(&cctx->h, cctx->algo, cctx->encrypt, block);
++}
++
++static int
++_libssh2_dtor(LIBSSH2_SESSION * session, void **abstract)
++{
++ struct crypt_ctx **cctx = (struct crypt_ctx **) abstract;
++ if (cctx && *cctx) {
++ _libssh2_cipher_dtor(&(*cctx)->h);
++ LIBSSH2_FREE(session, *cctx);
++ *abstract = NULL;
++ }
++ return 0;
++}
++
++#if LIBSSH2_AES
++static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes128_cbc = {
++ "aes128-cbc",
++ 16, /* blocksize */
++ 16, /* initial value length */
++ 16, /* secret length -- 16*8 == 128bit */
++ 0, /* flags */
++ &_libssh2_init,
++ &_libssh2_encrypt,
++ &_libssh2_dtor,
++ _libssh2_cipher_aes128
++};
++
++static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes192_cbc = {
++ "aes192-cbc",
++ 16, /* blocksize */
++ 16, /* initial value length */
++ 24, /* secret length -- 24*8 == 192bit */
++ 0, /* flags */
++ &_libssh2_init,
++ &_libssh2_encrypt,
++ &_libssh2_dtor,
++ _libssh2_cipher_aes192
++};
++
++static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_aes256_cbc = {
++ "aes256-cbc",
++ 16, /* blocksize */
++ 16, /* initial value length */
++ 32, /* secret length -- 32*8 == 256bit */
++ 0, /* flags */
++ &_libssh2_init,
++ &_libssh2_encrypt,
++ &_libssh2_dtor,
++ _libssh2_cipher_aes256
++};
++
++/* rijndael-cbc@lysator.liu.se == aes256-cbc */
++static const LIBSSH2_CRYPT_METHOD
++ libssh2_crypt_method_rijndael_cbc_lysator_liu_se = {
++ "rijndael-cbc@lysator.liu.se",
++ 16, /* blocksize */
++ 16, /* initial value length */
++ 32, /* secret length -- 32*8 == 256bit */
++ 0, /* flags */
++ &_libssh2_init,
++ &_libssh2_encrypt,
++ &_libssh2_dtor,
++ _libssh2_cipher_aes256
++};
++#endif /* LIBSSH2_AES */
++
++#if LIBSSH2_BLOWFISH
++static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_blowfish_cbc = {
++ "blowfish-cbc",
++ 8, /* blocksize */
++ 8, /* initial value length */
++ 16, /* secret length */
++ 0, /* flags */
++ &_libssh2_init,
++ &_libssh2_encrypt,
++ &_libssh2_dtor,
++ _libssh2_cipher_blowfish
++};
++#endif /* LIBSSH2_BLOWFISH */
++
++#if LIBSSH2_RC4
++static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_arcfour = {
++ "arcfour",
++ 8, /* blocksize */
++ 8, /* initial value length */
++ 16, /* secret length */
++ 0, /* flags */
++ &_libssh2_init,
++ &_libssh2_encrypt,
++ &_libssh2_dtor,
++ _libssh2_cipher_arcfour
++};
++#endif /* LIBSSH2_RC4 */
++
++#if LIBSSH2_CAST
++static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_cast128_cbc = {
++ "cast128-cbc",
++ 8, /* blocksize */
++ 8, /* initial value length */
++ 16, /* secret length */
++ 0, /* flags */
++ &_libssh2_init,
++ &_libssh2_encrypt,
++ &_libssh2_dtor,
++ _libssh2_cipher_cast5
++};
++#endif /* LIBSSH2_CAST */
++
++#if LIBSSH2_3DES
++static const LIBSSH2_CRYPT_METHOD libssh2_crypt_method_3des_cbc = {
++ "3des-cbc",
++ 8, /* blocksize */
++ 8, /* initial value length */
++ 24, /* secret length */
++ 0, /* flags */
++ &_libssh2_init,
++ &_libssh2_encrypt,
++ &_libssh2_dtor,
++ _libssh2_cipher_3des
++};
++#endif
++
++static const LIBSSH2_CRYPT_METHOD *_libssh2_crypt_methods[] = {
++#if LIBSSH2_AES
++ &libssh2_crypt_method_aes256_cbc,
++ &libssh2_crypt_method_rijndael_cbc_lysator_liu_se, /* == aes256-cbc */
++ &libssh2_crypt_method_aes192_cbc,
++ &libssh2_crypt_method_aes128_cbc,
++#endif /* LIBSSH2_AES */
++#if LIBSSH2_BLOWFISH
++ &libssh2_crypt_method_blowfish_cbc,
++#endif /* LIBSSH2_BLOWFISH */
++#if LIBSSH2_RC4
++ &libssh2_crypt_method_arcfour,
++#endif /* LIBSSH2_RC4 */
++#if LIBSSH2_CAST
++ &libssh2_crypt_method_cast128_cbc,
++#endif /* LIBSSH2_CAST */
++#if LIBSSH2_3DES
++ &libssh2_crypt_method_3des_cbc,
++#endif /* LIBSSH2_DES */
++#ifdef LIBSSH2_CRYPT_NONE
++ &libssh2_crypt_method_none,
++#endif
++ NULL
++};
++
++/* Expose to kex.c */
++const LIBSSH2_CRYPT_METHOD **
++libssh2_crypt_methods(void)
++{
++ return _libssh2_crypt_methods;
++}
+
+Property changes on: libssh2/src/crypt.c
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.2
+Added: svn:eol-style
+ + native
+
+Index: libssh2/src/libgcrypt.h
+===================================================================
+--- libssh2/src/libgcrypt.h (.../tags/RELEASE_0_11_0)
++++ libssh2/src/libgcrypt.h (.../trunk)
+@@ -0,0 +1,187 @@
++/* Copyright (C) 2006, 2007, The Written Word, Inc.
++ * Copyright (C) 2008, Simon Josefsson
++ * 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 <gcrypt.h>
++
++#define LIBSSH2_MD5 1
++
++#define LIBSSH2_HMAC_RIPEMD 1
++
++#define LIBSSH2_AES 1
++#define LIBSSH2_BLOWFISH 1
++#define LIBSSH2_RC4 1
++#define LIBSSH2_CAST 1
++#define LIBSSH2_3DES 1
++
++#define LIBSSH2_RSA 1
++#define LIBSSH2_DSA 1
++
++#define MD5_DIGEST_LENGTH 16
++#define SHA_DIGEST_LENGTH 20
++
++#define libssh2_random(buf, len) \
++ (gcry_randomize ((buf), (len), GCRY_STRONG_RANDOM), 1)
++
++#define libssh2_sha1_ctx gcry_md_hd_t
++#define libssh2_sha1_init(ctx) gcry_md_open (ctx, GCRY_MD_SHA1, 0);
++#define libssh2_sha1_update(ctx, data, len) gcry_md_write (ctx, data, len)
++#define libssh2_sha1_final(ctx, out) \
++ memcpy (out, gcry_md_read (ctx, 0), 20), gcry_md_close (ctx)
++#define libssh2_sha1(message, len, out) \
++ gcry_md_hash_buffer (GCRY_MD_SHA1, out, message, len)
++
++#define libssh2_md5_ctx gcry_md_hd_t
++#define libssh2_md5_init(ctx) gcry_md_open (ctx, GCRY_MD_MD5, 0);
++#define libssh2_md5_update(ctx, data, len) gcry_md_write (ctx, data, len)
++#define libssh2_md5_final(ctx, out) \
++ memcpy (out, gcry_md_read (ctx, 0), 20), gcry_md_close (ctx)
++#define libssh2_md5(message, len, out) \
++ gcry_md_hash_buffer (GCRY_MD_MD5, out, message, len)
++
++#define libssh2_hmac_ctx gcry_md_hd_t
++#define libssh2_hmac_sha1_init(ctx, key, keylen) \
++ gcry_md_open (ctx, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC), \
++ gcry_md_setkey (*ctx, key, keylen)
++#define libssh2_hmac_md5_init(ctx, key, keylen) \
++ gcry_md_open (ctx, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC), \
++ gcry_md_setkey (*ctx, key, keylen)
++#define libssh2_hmac_ripemd160_init(ctx, key, keylen) \
++ gcry_md_open (ctx, GCRY_MD_RMD160, GCRY_MD_FLAG_HMAC), \
++ gcry_md_setkey (*ctx, key, keylen)
++#define libssh2_hmac_update(ctx, data, datalen) \
++ gcry_md_write (ctx, data, datalen)
++#define libssh2_hmac_final(ctx, data) \
++ memcpy (data, gcry_md_read (ctx, 0), \
++ gcry_md_get_algo_dlen (gcry_md_get_algo (ctx)))
++#define libssh2_hmac_cleanup(ctx) gcry_md_close (*ctx);
++
++#define libssh2_crypto_init() gcry_control (GCRYCTL_DISABLE_SECMEM)
++
++#define libssh2_rsa_ctx struct gcry_sexp
++
++int _libssh2_rsa_new(libssh2_rsa_ctx ** rsa,
++ const unsigned char *edata,
++ unsigned long elen,
++ const unsigned char *ndata,
++ unsigned long nlen,
++ const unsigned char *ddata,
++ unsigned long dlen,
++ const unsigned char *pdata,
++ unsigned long plen,
++ const unsigned char *qdata,
++ unsigned long qlen,
++ const unsigned char *e1data,
++ unsigned long e1len,
++ const unsigned char *e2data,
++ unsigned long e2len,
++ const unsigned char *coeffdata, unsigned long coefflen);
++int _libssh2_rsa_new_private(libssh2_rsa_ctx ** rsa,
++ LIBSSH2_SESSION * session,
++ FILE * fp, unsigned const char *passphrase);
++int _libssh2_rsa_sha1_verify(libssh2_rsa_ctx * rsa,
++ const unsigned char *sig,
++ unsigned long sig_len,
++ const unsigned char *m, unsigned long m_len);
++int _libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
++ libssh2_rsa_ctx * rsactx,
++ const unsigned char *hash,
++ unsigned long hash_len,
++ unsigned char **signature,
++ unsigned long *signature_len);
++
++#define _libssh2_rsa_free(rsactx) gcry_sexp_release (rsactx)
++
++#define libssh2_dsa_ctx struct gcry_sexp
++
++int _libssh2_dsa_new(libssh2_dsa_ctx ** dsa,
++ const unsigned char *pdata,
++ unsigned long plen,
++ const unsigned char *qdata,
++ unsigned long qlen,
++ const unsigned char *gdata,
++ unsigned long glen,
++ const unsigned char *ydata,
++ unsigned long ylen,
++ const unsigned char *x, unsigned long x_len);
++int _libssh2_dsa_new_private(libssh2_dsa_ctx ** dsa,
++ LIBSSH2_SESSION * session,
++ FILE * fp, unsigned const char *passphrase);
++int _libssh2_dsa_sha1_verify(libssh2_dsa_ctx * dsa,
++ const unsigned char *sig,
++ const unsigned char *m, unsigned long m_len);
++int _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
++ const unsigned char *hash,
++ unsigned long hash_len, unsigned char *sig);
++
++#define _libssh2_dsa_free(dsactx) gcry_sexp_release (dsactx)
++
++#define _libssh2_cipher_type(name) int name
++#define _libssh2_cipher_ctx gcry_cipher_hd_t
++
++#define _libssh2_cipher_aes256 GCRY_CIPHER_AES256
++#define _libssh2_cipher_aes192 GCRY_CIPHER_AES192
++#define _libssh2_cipher_aes128 GCRY_CIPHER_AES128
++#define _libssh2_cipher_blowfish GCRY_CIPHER_BLOWFISH
++#define _libssh2_cipher_arcfour GCRY_CIPHER_ARCFOUR
++#define _libssh2_cipher_cast5 GCRY_CIPHER_CAST5
++#define _libssh2_cipher_3des GCRY_CIPHER_3DES
++
++int _libssh2_cipher_init(_libssh2_cipher_ctx * h,
++ _libssh2_cipher_type(algo),
++ unsigned char *iv,
++ unsigned char *secret, int encrypt);
++
++int _libssh2_cipher_crypt(_libssh2_cipher_ctx * ctx,
++ _libssh2_cipher_type(algo),
++ int encrypt, unsigned char *block);
++
++#define _libssh2_cipher_dtor(ctx) gcry_cipher_close(*(ctx))
++
++#define _libssh2_bn struct gcry_mpi
++#define _libssh2_bn_ctx int
++#define _libssh2_bn_ctx_new() 0
++#define _libssh2_bn_ctx_free(bnctx) ((void)0)
++#define _libssh2_bn_init() gcry_mpi_new(0)
++#define _libssh2_bn_rand(bn, bits, top, bottom) gcry_mpi_randomize (bn, bits, GCRY_WEAK_RANDOM)
++#define _libssh2_bn_mod_exp(r, a, p, m, ctx) gcry_mpi_powm (r, a, p, m)
++#define _libssh2_bn_set_word(bn, val) gcry_mpi_set_ui(bn, val)
++#define _libssh2_bn_from_bin(bn, len, val) gcry_mpi_scan(&((bn)), GCRYMPI_FMT_USG, val, len, NULL)
++#define _libssh2_bn_to_bin(bn, val) gcry_mpi_print (GCRYMPI_FMT_USG, val, _libssh2_bn_bytes(bn), NULL, bn)
++#define _libssh2_bn_bytes(bn) (gcry_mpi_get_nbits (bn) / 8 + ((gcry_mpi_get_nbits (bn) % 8 == 0) ? 0 : 1))
++#define _libssh2_bn_bits(bn) gcry_mpi_get_nbits (bn)
++#define _libssh2_bn_free(bn) gcry_mpi_release(bn)
+
+Property changes on: libssh2/src/libgcrypt.h
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.1
+Added: svn:eol-style
+ + native
+Added: svn:executable
+ + *
+
+Index: libssh2/src/packet.c
+===================================================================
+--- libssh2/src/packet.c (.../tags/RELEASE_0_11_0)
++++ libssh2/src/packet.c (.../trunk)
+@@ -0,0 +1,1270 @@
++/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
++ * 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 <errno.h>
++#include <fcntl.h>
++
++#ifdef HAVE_UNISTD_H
++#include <unistd.h>
++#endif
++
++#ifdef HAVE_SYS_TIME_H
++#include <sys/time.h>
++#endif
++
++#ifdef HAVE_INTTYPES_H
++#include <inttypes.h>
++#endif
++
++/* Needed for struct iovec on some platforms */
++#ifdef HAVE_SYS_UIO_H
++#include <sys/uio.h>
++#endif
++
++#include <sys/types.h>
++
++/* {{{ libssh2_packet_queue_listener
++ * Queue a connection request for a listener
++ */
++static inline int
++libssh2_packet_queue_listener(LIBSSH2_SESSION * session, unsigned char *data,
++ unsigned long datalen,
++ packet_queue_listener_state_t * listen_state)
++{
++ /*
++ * Look for a matching listener
++ */
++ unsigned char *s = data + (sizeof("forwarded-tcpip") - 1) + 5;
++ /* 17 = packet_type(1) + channel(4) + reason(4) + descr(4) + lang(4) */
++ unsigned long packet_len = 17 + (sizeof(FwdNotReq) - 1);
++ unsigned char *p;
++ LIBSSH2_LISTENER *listen = session->listeners;
++ char failure_code = 1; /* SSH_OPEN_ADMINISTRATIVELY_PROHIBITED */
++ int rc;
++
++ (void) datalen;
++
++ if (listen_state->state == libssh2_NB_state_idle) {
++ listen_state->sender_channel = libssh2_ntohu32(s);
++ s += 4;
++
++ listen_state->initial_window_size = libssh2_ntohu32(s);
++ s += 4;
++ listen_state->packet_size = libssh2_ntohu32(s);
++ s += 4;
++
++ listen_state->host_len = libssh2_ntohu32(s);
++ s += 4;
++ listen_state->host = s;
++ s += listen_state->host_len;
++ listen_state->port = libssh2_ntohu32(s);
++ s += 4;
++
++ listen_state->shost_len = libssh2_ntohu32(s);
++ s += 4;
++ listen_state->shost = s;
++ s += listen_state->shost_len;
++ listen_state->sport = libssh2_ntohu32(s);
++ s += 4;
++
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Remote received connection from %s:%ld to %s:%ld",
++ listen_state->shost, listen_state->sport,
++ listen_state->host, listen_state->port);
++
++ listen_state->state = libssh2_NB_state_allocated;
++ }
++
++ if (listen_state->state != libssh2_NB_state_sent) {
++ while (listen) {
++ if ((listen->port == (int) listen_state->port) &&
++ (strlen(listen->host) == listen_state->host_len) &&
++ (memcmp
++ (listen->host, listen_state->host,
++ listen_state->host_len) == 0)) {
++ /* This is our listener */
++ LIBSSH2_CHANNEL *channel, *last_queued = listen->queue;
++
++ last_queued = listen->queue;
++ if (listen_state->state == libssh2_NB_state_allocated) {
++ if (listen->queue_maxsize &&
++ (listen->queue_maxsize <= listen->queue_size)) {
++ /* Queue is full */
++ failure_code = 4; /* SSH_OPEN_RESOURCE_SHORTAGE */
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Listener queue full, ignoring");
++ listen_state->state = libssh2_NB_state_sent;
++ break;
++ }
++
++ channel = LIBSSH2_ALLOC(session, sizeof(LIBSSH2_CHANNEL));
++ if (!channel) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate a channel for new connection",
++ 0);
++ failure_code = 4; /* SSH_OPEN_RESOURCE_SHORTAGE */
++ listen_state->state = libssh2_NB_state_sent;
++ break;
++ }
++ memset(channel, 0, sizeof(LIBSSH2_CHANNEL));
++
++ channel->session = session;
++ channel->channel_type_len = sizeof("forwarded-tcpip") - 1;
++ channel->channel_type = LIBSSH2_ALLOC(session,
++ channel->
++ channel_type_len +
++ 1);
++ if (!channel->channel_type) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate a channel for new connection",
++ 0);
++ LIBSSH2_FREE(session, channel);
++ failure_code = 4; /* SSH_OPEN_RESOURCE_SHORTAGE */
++ listen_state->state = libssh2_NB_state_sent;
++ break;
++ }
++ memcpy(channel->channel_type, "forwarded-tcpip",
++ channel->channel_type_len + 1);
++
++ channel->remote.id = listen_state->sender_channel;
++ channel->remote.window_size_initial =
++ LIBSSH2_CHANNEL_WINDOW_DEFAULT;
++ channel->remote.window_size =
++ LIBSSH2_CHANNEL_WINDOW_DEFAULT;
++ channel->remote.packet_size =
++ LIBSSH2_CHANNEL_PACKET_DEFAULT;
++
++ channel->local.id = libssh2_channel_nextid(session);
++ channel->local.window_size_initial =
++ listen_state->initial_window_size;
++ channel->local.window_size =
++ listen_state->initial_window_size;
++ channel->local.packet_size = listen_state->packet_size;
++
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Connection queued: channel %lu/%lu win %lu/%lu packet %lu/%lu",
++ channel->local.id, channel->remote.id,
++ channel->local.window_size,
++ channel->remote.window_size,
++ channel->local.packet_size,
++ channel->remote.packet_size);
++
++ p = listen_state->packet;
++ *(p++) = SSH_MSG_CHANNEL_OPEN_CONFIRMATION;
++ libssh2_htonu32(p, channel->remote.id);
++ p += 4;
++ libssh2_htonu32(p, channel->local.id);
++ p += 4;
++ libssh2_htonu32(p, channel->remote.window_size_initial);
++ p += 4;
++ libssh2_htonu32(p, channel->remote.packet_size);
++ p += 4;
++
++ listen_state->state = libssh2_NB_state_created;
++ }
++
++ if (listen_state->state == libssh2_NB_state_created) {
++ rc = libssh2_packet_write(session, listen_state->packet,
++ 17);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send channel open confirmation",
++ 0);
++ listen_state->state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ /* Link the channel into the end of the queue list */
++
++ if (!last_queued) {
++ listen->queue = channel;
++ listen_state->state = libssh2_NB_state_idle;
++ return 0;
++ }
++
++ while (last_queued->next) {
++ last_queued = last_queued->next;
++ }
++
++ last_queued->next = channel;
++ channel->prev = last_queued;
++
++ listen->queue_size++;
++
++ listen_state->state = libssh2_NB_state_idle;
++ return 0;
++ }
++ }
++
++ listen = listen->next;
++ }
++
++ listen_state->state = libssh2_NB_state_sent;
++ }
++
++ /* We're not listening to you */
++ {
++ p = listen_state->packet;
++ *(p++) = SSH_MSG_CHANNEL_OPEN_FAILURE;
++ libssh2_htonu32(p, listen_state->sender_channel);
++ p += 4;
++ libssh2_htonu32(p, failure_code);
++ p += 4;
++ libssh2_htonu32(p, sizeof(FwdNotReq) - 1);
++ p += 4;
++ memcpy(s, FwdNotReq, sizeof(FwdNotReq) - 1);
++ p += sizeof(FwdNotReq) - 1;
++ libssh2_htonu32(p, 0);
++
++ rc = libssh2_packet_write(session, listen_state->packet, packet_len);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send open failure", 0);
++ listen_state->state = libssh2_NB_state_idle;
++ return -1;
++ }
++ listen_state->state = libssh2_NB_state_idle;
++ return 0;
++ }
++}
++
++/* }}} */
++
++/* {{{ libssh2_packet_x11_open
++ * Accept a forwarded X11 connection
++ */
++static inline int
++libssh2_packet_x11_open(LIBSSH2_SESSION * session, unsigned char *data,
++ unsigned long datalen,
++ packet_x11_open_state_t * x11open_state)
++{
++ int failure_code = 2; /* SSH_OPEN_CONNECT_FAILED */
++ unsigned char *s = data + (sizeof("x11") - 1) + 5;
++ /* 17 = packet_type(1) + channel(4) + reason(4) + descr(4) + lang(4) */
++ unsigned long packet_len = 17 + (sizeof(X11FwdUnAvil) - 1);
++ unsigned char *p;
++ LIBSSH2_CHANNEL *channel;
++ int rc;
++
++ (void) datalen;
++
++ if (x11open_state->state == libssh2_NB_state_idle) {
++ x11open_state->sender_channel = libssh2_ntohu32(s);
++ s += 4;
++ x11open_state->initial_window_size = libssh2_ntohu32(s);
++ s += 4;
++ x11open_state->packet_size = libssh2_ntohu32(s);
++ s += 4;
++ x11open_state->shost_len = libssh2_ntohu32(s);
++ s += 4;
++ x11open_state->shost = s;
++ s += x11open_state->shost_len;
++ x11open_state->sport = libssh2_ntohu32(s);
++ s += 4;
++
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "X11 Connection Received from %s:%ld on channel %lu",
++ x11open_state->shost, x11open_state->sport,
++ x11open_state->sender_channel);
++
++ x11open_state->state = libssh2_NB_state_allocated;
++ }
++
++ if (session->x11) {
++ if (x11open_state->state == libssh2_NB_state_allocated) {
++ channel = LIBSSH2_ALLOC(session, sizeof(LIBSSH2_CHANNEL));
++ if (!channel) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate a channel for new connection",
++ 0);
++ failure_code = 4; /* SSH_OPEN_RESOURCE_SHORTAGE */
++ goto x11_exit;
++ }
++ memset(channel, 0, sizeof(LIBSSH2_CHANNEL));
++
++ channel->session = session;
++ channel->channel_type_len = sizeof("x11") - 1;
++ channel->channel_type = LIBSSH2_ALLOC(session,
++ channel->channel_type_len +
++ 1);
++ if (!channel->channel_type) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate a channel for new connection",
++ 0);
++ LIBSSH2_FREE(session, channel);
++ failure_code = 4; /* SSH_OPEN_RESOURCE_SHORTAGE */
++ goto x11_exit;
++ }
++ memcpy(channel->channel_type, "x11",
++ channel->channel_type_len + 1);
++
++ channel->remote.id = x11open_state->sender_channel;
++ channel->remote.window_size_initial =
++ LIBSSH2_CHANNEL_WINDOW_DEFAULT;
++ channel->remote.window_size = LIBSSH2_CHANNEL_WINDOW_DEFAULT;
++ channel->remote.packet_size = LIBSSH2_CHANNEL_PACKET_DEFAULT;
++
++ channel->local.id = libssh2_channel_nextid(session);
++ channel->local.window_size_initial =
++ x11open_state->initial_window_size;
++ channel->local.window_size = x11open_state->initial_window_size;
++ channel->local.packet_size = x11open_state->packet_size;
++
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "X11 Connection established: channel %lu/%lu win %lu/%lu packet %lu/%lu",
++ channel->local.id, channel->remote.id,
++ channel->local.window_size,
++ channel->remote.window_size,
++ channel->local.packet_size,
++ channel->remote.packet_size);
++ p = x11open_state->packet;
++ *(p++) = SSH_MSG_CHANNEL_OPEN_CONFIRMATION;
++ libssh2_htonu32(p, channel->remote.id);
++ p += 4;
++ libssh2_htonu32(p, channel->local.id);
++ p += 4;
++ libssh2_htonu32(p, channel->remote.window_size_initial);
++ p += 4;
++ libssh2_htonu32(p, channel->remote.packet_size);
++ p += 4;
++
++ x11open_state->state = libssh2_NB_state_created;
++ }
++
++ if (x11open_state->state == libssh2_NB_state_created) {
++ rc = libssh2_packet_write(session, x11open_state->packet, 17);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send channel open confirmation", 0);
++ x11open_state->state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ /* Link the channel into the session */
++ if (session->channels.tail) {
++ session->channels.tail->next = channel;
++ channel->prev = session->channels.tail;
++ } else {
++ session->channels.head = channel;
++ channel->prev = NULL;
++ }
++ channel->next = NULL;
++ session->channels.tail = channel;
++
++ /*
++ * Pass control to the callback, they may turn right around and
++ * free the channel, or actually use it
++ */
++ LIBSSH2_X11_OPEN(channel, (char *) x11open_state->shost,
++ x11open_state->sport);
++
++ x11open_state->state = libssh2_NB_state_idle;
++ return 0;
++ }
++ } else {
++ failure_code = 4; /* SSH_OPEN_RESOURCE_SHORTAGE */
++ }
++
++ x11_exit:
++ p = x11open_state->packet;
++ *(p++) = SSH_MSG_CHANNEL_OPEN_FAILURE;
++ libssh2_htonu32(p, x11open_state->sender_channel);
++ p += 4;
++ libssh2_htonu32(p, failure_code);
++ p += 4;
++ libssh2_htonu32(p, sizeof(X11FwdUnAvil) - 1);
++ p += 4;
++ memcpy(s, X11FwdUnAvil, sizeof(X11FwdUnAvil) - 1);
++ p += sizeof(X11FwdUnAvil) - 1;
++ libssh2_htonu32(p, 0);
++
++ rc = libssh2_packet_write(session, x11open_state->packet, packet_len);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send open failure", 0);
++ x11open_state->state = libssh2_NB_state_idle;
++ return -1;
++ }
++ x11open_state->state = libssh2_NB_state_idle;
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_packet_new
++ * Create a new packet and attach it to the brigade
++ */
++int
++libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
++ size_t datalen, int macstate)
++{
++ int rc;
++
++ if (session->packAdd_state == libssh2_NB_state_idle) {
++ session->packAdd_data_head = 0;
++
++ /* Zero the whole thing out */
++ memset(&session->packAdd_key_state, 0,
++ sizeof(session->packAdd_key_state));
++
++ /* Zero the whole thing out */
++ memset(&session->packAdd_Qlstn_state, 0,
++ sizeof(session->packAdd_Qlstn_state));
++
++ /* Zero the whole thing out */
++ memset(&session->packAdd_x11open_state, 0,
++ sizeof(session->packAdd_x11open_state));
++
++ _libssh2_debug(session, LIBSSH2_DBG_TRANS,
++ "Packet type %d received, length=%d",
++ (int) data[0], (int) datalen);
++ if (macstate == LIBSSH2_MAC_INVALID) {
++ if (session->macerror) {
++ if (LIBSSH2_MACERROR(session, (char *) data, datalen) == 0) {
++ /* Calling app has given the OK, Process it anyway */
++ macstate = LIBSSH2_MAC_CONFIRMED;
++ } else {
++ libssh2_error(session, LIBSSH2_ERROR_INVALID_MAC,
++ "Invalid Message Authentication Code received",
++ 0);
++ if (session->ssh_msg_disconnect) {
++ LIBSSH2_DISCONNECT(session, SSH_DISCONNECT_MAC_ERROR,
++ "Invalid MAC received",
++ sizeof("Invalid MAC received") - 1,
++ "", 0);
++ }
++ LIBSSH2_FREE(session, data);
++ return -1;
++ }
++ } else {
++ libssh2_error(session, LIBSSH2_ERROR_INVALID_MAC,
++ "Invalid Message Authentication Code received",
++ 0);
++ if (session->ssh_msg_disconnect) {
++ LIBSSH2_DISCONNECT(session, SSH_DISCONNECT_MAC_ERROR,
++ "Invalid MAC received",
++ sizeof("Invalid MAC received") - 1,
++ "", 0);
++ }
++ LIBSSH2_FREE(session, data);
++ return -1;
++ }
++ }
++
++ session->packAdd_state = libssh2_NB_state_allocated;
++ }
++
++ /*
++ * =============================== NOTE ===============================
++ * I know this is very ugly and not a really good use of "goto", but
++ * this case statement would be even uglier to do it any other way
++ */
++ if (session->packAdd_state == libssh2_NB_state_jump1) {
++ goto libssh2_packet_add_jump_point1;
++ } else if (session->packAdd_state == libssh2_NB_state_jump2) {
++ goto libssh2_packet_add_jump_point2;
++ } else if (session->packAdd_state == libssh2_NB_state_jump3) {
++ goto libssh2_packet_add_jump_point3;
++ }
++
++ if (session->packAdd_state == libssh2_NB_state_allocated) {
++ /* A couple exceptions to the packet adding rule: */
++ switch (data[0]) {
++ case SSH_MSG_DISCONNECT:
++ {
++ char *message, *language;
++ int reason, message_len, language_len;
++
++ reason = libssh2_ntohu32(data + 1);
++ message_len = libssh2_ntohu32(data + 5);
++ /* 9 = packet_type(1) + reason(4) + message_len(4) */
++ message = (char *) data + 9;
++ language_len = libssh2_ntohu32(data + 9 + message_len);
++ /*
++ * This is where we hack on the data a little,
++ * Use the MSB of language_len to to a terminating NULL
++ * (In all liklihood it is already)
++ * Shift the language tag back a byte (In all likelihood
++ * it's zero length anyway)
++ * Store a NULL in the last byte of the packet to terminate
++ * the language string
++ * With the lengths passed this isn't *REALLY* necessary,
++ * but it's "kind"
++ */
++ message[message_len] = '\0';
++ language = (char *) data + 9 + message_len + 3;
++ if (language_len) {
++ memcpy(language, language + 1, language_len);
++ }
++ language[language_len] = '\0';
++
++ if (session->ssh_msg_disconnect) {
++ LIBSSH2_DISCONNECT(session, reason, message,
++ message_len, language, language_len);
++ }
++ _libssh2_debug(session, LIBSSH2_DBG_TRANS,
++ "Disconnect(%d): %s(%s)", reason,
++ message, language);
++ LIBSSH2_FREE(session, data);
++ session->socket_state = LIBSSH2_SOCKET_DISCONNECTED;
++ session->packAdd_state = libssh2_NB_state_idle;
++ return -1;
++ }
++ break;
++
++ case SSH_MSG_IGNORE:
++ /* As with disconnect, back it up one and add a trailing NULL */
++ memcpy(data + 4, data + 5, datalen - 5);
++ data[datalen] = '\0';
++ if (session->ssh_msg_ignore) {
++ LIBSSH2_IGNORE(session, (char *) data + 4, datalen - 5);
++ }
++ LIBSSH2_FREE(session, data);
++ session->packAdd_state = libssh2_NB_state_idle;
++ return 0;
++ break;
++
++ case SSH_MSG_DEBUG:
++ {
++ int always_display = data[0];
++ char *message, *language;
++ int message_len, language_len;
++
++ message_len = libssh2_ntohu32(data + 2);
++ /* 6 = packet_type(1) + display(1) + message_len(4) */
++ message = (char *) data + 6;
++ language_len = libssh2_ntohu32(data + 6 + message_len);
++ /*
++ * This is where we hack on the data a little,
++ * Use the MSB of language_len to to a terminating NULL
++ * (In all liklihood it is already)
++ * Shift the language tag back a byte (In all likelihood
++ * it's zero length anyway)
++ * Store a NULL in the last byte of the packet to terminate
++ * the language string
++ * With the lengths passed this isn't *REALLY* necessary,
++ * but it's "kind"
++ */
++ message[message_len] = '\0';
++ language = (char *) data + 6 + message_len + 3;
++ if (language_len) {
++ memcpy(language, language + 1, language_len);
++ }
++ language[language_len] = '\0';
++
++ if (session->ssh_msg_debug) {
++ LIBSSH2_DEBUG(session, always_display, message,
++ message_len, language, language_len);
++ }
++ /*
++ * _libssh2_debug will actually truncate this for us so
++ * that it's not an inordinate about of data
++ */
++ _libssh2_debug(session, LIBSSH2_DBG_TRANS,
++ "Debug Packet: %s", message);
++ LIBSSH2_FREE(session, data);
++ session->packAdd_state = libssh2_NB_state_idle;
++ return 0;
++ }
++ break;
++
++ case SSH_MSG_CHANNEL_EXTENDED_DATA:
++ /* streamid(4) */
++ session->packAdd_data_head += 4;
++ case SSH_MSG_CHANNEL_DATA:
++ /* packet_type(1) + channelno(4) + datalen(4) */
++ session->packAdd_data_head += 9;
++ {
++ session->packAdd_channel = libssh2_channel_locate(session,
++ libssh2_ntohu32
++ (data + 1));
++
++ if (!session->packAdd_channel) {
++ libssh2_error(session, LIBSSH2_ERROR_CHANNEL_UNKNOWN,
++ "Packet received for unknown channel, ignoring",
++ 0);
++ LIBSSH2_FREE(session, data);
++ session->packAdd_state = libssh2_NB_state_idle;
++ return 0;
++ }
++#ifdef LIBSSH2DEBUG
++ {
++ unsigned long stream_id = 0;
++
++ if (data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA) {
++ stream_id = libssh2_ntohu32(data + 5);
++ }
++
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "%d bytes received for channel %lu/%lu stream #%lu",
++ (int) (datalen -
++ session->packAdd_data_head),
++ session->packAdd_channel->local.id,
++ session->packAdd_channel->remote.id,
++ stream_id);
++ }
++#endif
++ if ((session->packAdd_channel->remote.
++ extended_data_ignore_mode ==
++ LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE)
++ && (data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA)) {
++ /* Pretend we didn't receive this */
++ LIBSSH2_FREE(session, data);
++
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Ignoring extended data and refunding %d bytes",
++ (int) (datalen - 13));
++ /* Adjust the window based on the block we just freed */
++ libssh2_packet_add_jump_point1:
++ session->packAdd_state = libssh2_NB_state_jump1;
++ rc = libssh2_channel_receive_window_adjust(session->
++ packAdd_channel,
++ datalen - 13,
++ 0);
++ if (rc == PACKET_EAGAIN) {
++ session->socket_block_directions =
++ LIBSSH2_SESSION_BLOCK_OUTBOUND;
++ return PACKET_EAGAIN;
++ }
++ session->packAdd_state = libssh2_NB_state_idle;
++ return 0;
++ }
++
++ /*
++ * REMEMBER! remote means remote as source of data,
++ * NOT remote window!
++ */
++ if (session->packAdd_channel->remote.packet_size <
++ (datalen - session->packAdd_data_head)) {
++ /*
++ * Spec says we MAY ignore bytes sent beyond
++ * packet_size
++ */
++ libssh2_error(session,
++ LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED,
++ "Packet contains more data than we offered to receive, truncating",
++ 0);
++ datalen =
++ session->packAdd_channel->remote.packet_size +
++ session->packAdd_data_head;
++ }
++ if (session->packAdd_channel->remote.window_size <= 0) {
++ /*
++ * Spec says we MAY ignore bytes sent beyond
++ * window_size
++ */
++ libssh2_error(session,
++ LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED,
++ "The current receive window is full, data ignored",
++ 0);
++ LIBSSH2_FREE(session, data);
++ session->packAdd_state = libssh2_NB_state_idle;
++ return 0;
++ }
++ /* Reset EOF status */
++ session->packAdd_channel->remote.eof = 0;
++
++ if ((datalen - session->packAdd_data_head) >
++ session->packAdd_channel->remote.window_size) {
++ libssh2_error(session,
++ LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED,
++ "Remote sent more data than current window allows, truncating",
++ 0);
++ datalen =
++ session->packAdd_channel->remote.window_size +
++ session->packAdd_data_head;
++ } else {
++ /* Now that we've received it, shrink our window */
++ session->packAdd_channel->remote.window_size -=
++ datalen - session->packAdd_data_head;
++ }
++ }
++ break;
++
++ case SSH_MSG_CHANNEL_EOF:
++ {
++ session->packAdd_channel = libssh2_channel_locate(session,
++ libssh2_ntohu32
++ (data + 1));
++
++ if (!session->packAdd_channel) {
++ /* We may have freed already, just quietly ignore this... */
++ LIBSSH2_FREE(session, data);
++ session->packAdd_state = libssh2_NB_state_idle;
++ return 0;
++ }
++
++ _libssh2_debug(session,
++ LIBSSH2_DBG_CONN,
++ "EOF received for channel %lu/%lu",
++ session->packAdd_channel->local.id,
++ session->packAdd_channel->remote.id);
++ session->packAdd_channel->remote.eof = 1;
++
++ LIBSSH2_FREE(session, data);
++ session->packAdd_state = libssh2_NB_state_idle;
++ return 0;
++ }
++ break;
++
++ case SSH_MSG_CHANNEL_REQUEST:
++ {
++ if (libssh2_ntohu32(data + 5) == sizeof("exit-status") - 1
++ && !memcmp("exit-status", data + 9,
++ sizeof("exit-status") - 1)) {
++
++ /* we've got "exit-status" packet. Set the session value */
++ session->packAdd_channel =
++ libssh2_channel_locate(session,
++ libssh2_ntohu32(data + 1));
++
++ if (session->packAdd_channel) {
++ session->packAdd_channel->exit_status =
++ libssh2_ntohu32(data + 9 + sizeof("exit-status"));
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Exit status %lu received for channel %lu/%lu",
++ session->packAdd_channel->exit_status,
++ session->packAdd_channel->local.id,
++ session->packAdd_channel->remote.id);
++ }
++
++ LIBSSH2_FREE(session, data);
++ session->packAdd_state = libssh2_NB_state_idle;
++ return 0;
++ }
++ }
++ break;
++
++ case SSH_MSG_CHANNEL_CLOSE:
++ {
++ session->packAdd_channel = libssh2_channel_locate(session,
++ libssh2_ntohu32
++ (data + 1));
++
++ if (!session->packAdd_channel) {
++ /* We may have freed already, just quietly ignore this... */
++ LIBSSH2_FREE(session, data);
++ session->packAdd_state = libssh2_NB_state_idle;
++ return 0;
++ }
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Close received for channel %lu/%lu",
++ session->packAdd_channel->local.id,
++ session->packAdd_channel->remote.id);
++
++ session->packAdd_channel->remote.close = 1;
++ session->packAdd_channel->remote.eof = 1;
++ /* TODO: Add a callback for this */
++
++ LIBSSH2_FREE(session, data);
++ session->packAdd_state = libssh2_NB_state_idle;
++ return 0;
++ }
++ break;
++
++ case SSH_MSG_CHANNEL_OPEN:
++ if ((datalen >= (sizeof("forwarded-tcpip") + 4)) &&
++ ((sizeof("forwarded-tcpip") - 1) == libssh2_ntohu32(data + 1))
++ &&
++ (memcmp
++ (data + 5, "forwarded-tcpip",
++ sizeof("forwarded-tcpip") - 1) == 0)) {
++
++ libssh2_packet_add_jump_point2:
++ session->packAdd_state = libssh2_NB_state_jump2;
++ rc = libssh2_packet_queue_listener(session, data, datalen,
++ &session->
++ packAdd_Qlstn_state);
++ if (rc == PACKET_EAGAIN) {
++ session->socket_block_directions =
++ LIBSSH2_SESSION_BLOCK_OUTBOUND;
++ return PACKET_EAGAIN;
++ }
++
++ LIBSSH2_FREE(session, data);
++ session->packAdd_state = libssh2_NB_state_idle;
++ return rc;
++ }
++ if ((datalen >= (sizeof("x11") + 4)) &&
++ ((sizeof("x11") - 1) == libssh2_ntohu32(data + 1)) &&
++ (memcmp(data + 5, "x11", sizeof("x11") - 1) == 0)) {
++
++ libssh2_packet_add_jump_point3:
++ session->packAdd_state = libssh2_NB_state_jump3;
++ rc = libssh2_packet_x11_open(session, data, datalen,
++ &session->packAdd_x11open_state);
++ if (rc == PACKET_EAGAIN) {
++ session->socket_block_directions =
++ LIBSSH2_SESSION_BLOCK_OUTBOUND;
++ return PACKET_EAGAIN;
++ }
++
++ LIBSSH2_FREE(session, data);
++ session->packAdd_state = libssh2_NB_state_idle;
++ return rc;
++ }
++ break;
++
++ case SSH_MSG_CHANNEL_WINDOW_ADJUST:
++ {
++ unsigned long bytestoadd = libssh2_ntohu32(data + 5);
++ session->packAdd_channel = libssh2_channel_locate(session,
++ libssh2_ntohu32
++ (data + 1));
++
++ if (session->packAdd_channel && bytestoadd) {
++ session->packAdd_channel->local.window_size += bytestoadd;
++ }
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Window adjust received for channel %lu/%lu, adding %lu bytes, new window_size=%lu",
++ session->packAdd_channel->local.id,
++ session->packAdd_channel->remote.id,
++ bytestoadd,
++ session->packAdd_channel->local.window_size);
++
++ LIBSSH2_FREE(session, data);
++ session->packAdd_state = libssh2_NB_state_idle;
++ return 0;
++ }
++ break;
++ }
++
++ session->packAdd_state = libssh2_NB_state_sent;
++ }
++
++ if (session->packAdd_state == libssh2_NB_state_sent) {
++ session->packAdd_packet =
++ LIBSSH2_ALLOC(session, sizeof(LIBSSH2_PACKET));
++ if (!session->packAdd_packet) {
++ _libssh2_debug(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for LIBSSH2_PACKET");
++ LIBSSH2_FREE(session, data);
++ session->packAdd_state = libssh2_NB_state_idle;
++ return -1;
++ }
++ memset(session->packAdd_packet, 0, sizeof(LIBSSH2_PACKET));
++
++ session->packAdd_packet->data = data;
++ session->packAdd_packet->data_len = datalen;
++ session->packAdd_packet->data_head = session->packAdd_data_head;
++ session->packAdd_packet->mac = macstate;
++ session->packAdd_packet->brigade = &session->packets;
++ session->packAdd_packet->next = NULL;
++
++ if (session->packets.tail) {
++ session->packAdd_packet->prev = session->packets.tail;
++ session->packAdd_packet->prev->next = session->packAdd_packet;
++ session->packets.tail = session->packAdd_packet;
++ } else {
++ session->packets.head = session->packAdd_packet;
++ session->packets.tail = session->packAdd_packet;
++ session->packAdd_packet->prev = NULL;
++ }
++
++ session->packAdd_state = libssh2_NB_state_sent1;
++ }
++
++ if ((data[0] == SSH_MSG_KEXINIT &&
++ !(session->state & LIBSSH2_STATE_EXCHANGING_KEYS)) ||
++ (session->packAdd_state == libssh2_NB_state_sent2)) {
++ if (session->packAdd_state == libssh2_NB_state_sent1) {
++ /*
++ * Remote wants new keys
++ * Well, it's already in the brigade,
++ * let's just call back into ourselves
++ */
++ _libssh2_debug(session, LIBSSH2_DBG_TRANS, "Renegotiating Keys");
++
++ session->packAdd_state = libssh2_NB_state_sent2;
++ }
++
++ /*
++ * The KEXINIT message has been added to the queue.
++ * The packAdd and readPack states need to be reset
++ * because libssh2_kex_exchange (eventually) calls upon
++ * libssh2_packet_read to read the rest of the key exchange
++ * conversation.
++ */
++ session->readPack_state = libssh2_NB_state_idle;
++ session->packet.total_num = 0;
++ session->packAdd_state = libssh2_NB_state_idle;
++ session->fullpacket_state = libssh2_NB_state_idle;
++
++ /*
++ * Also, don't use packAdd_key_state for key re-exchange,
++ * as it will be wiped out in the middle of the exchange.
++ * How about re-using the startup_key_state?
++ */
++ memset(&session->startup_key_state, 0, sizeof(key_exchange_state_t));
++
++ /*
++ * If there was a key reexchange failure, let's just hope we didn't
++ * send NEWKEYS yet, otherwise remote will drop us like a rock
++ */
++ rc = libssh2_kex_exchange(session, 1, &session->startup_key_state);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ }
++ }
++
++ session->packAdd_state = libssh2_NB_state_idle;
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_packet_ask
++ * Scan the brigade for a matching packet type, optionally poll the socket for
++ * a packet first
++ */
++int
++libssh2_packet_ask_ex(LIBSSH2_SESSION * session, unsigned char packet_type,
++ unsigned char **data, unsigned long *data_len,
++ unsigned long match_ofs, const unsigned char *match_buf,
++ unsigned long match_len, int poll_socket)
++{
++ LIBSSH2_PACKET *packet = session->packets.head;
++
++ if (poll_socket) {
++ /*
++ * XXX CHECK ***
++ * When "poll_socket" is "1" libhss2_packet_read() can return
++ * PACKET_EAGAIN. I am not sure what should happen, but internally
++ * there is only one location that might do so, libssh2_packet_askv_ex()
++ */
++ libssh2pack_t rc = libssh2_packet_read(session);
++ if ((rc < 0) && !packet) {
++ return rc;
++ }
++ }
++ _libssh2_debug(session, LIBSSH2_DBG_TRANS,
++ "Looking for packet of type: %d", (int) packet_type);
++
++ while (packet) {
++ if (packet->data[0] == packet_type
++ && (packet->data_len >= (match_ofs + match_len)) && (!match_buf
++ ||
++ (memcmp
++ (packet->
++ data +
++ match_ofs,
++ match_buf,
++ match_len)
++ == 0))) {
++ *data = packet->data;
++ *data_len = packet->data_len;
++
++ if (packet->prev) {
++ packet->prev->next = packet->next;
++ } else {
++ session->packets.head = packet->next;
++ }
++
++ if (packet->next) {
++ packet->next->prev = packet->prev;
++ } else {
++ session->packets.tail = packet->prev;
++ }
++
++ LIBSSH2_FREE(session, packet);
++
++ return 0;
++ }
++ packet = packet->next;
++ }
++ return -1;
++}
++
++/* }}} */
++
++/* {{{ libssh2_packet_askv
++ * Scan for any of a list of packet types in the brigade, optionally poll the
++ * socket for a packet first
++ */
++int
++libssh2_packet_askv_ex(LIBSSH2_SESSION * session,
++ const unsigned char *packet_types,
++ unsigned char **data, unsigned long *data_len,
++ unsigned long match_ofs,
++ const unsigned char *match_buf,
++ unsigned long match_len, int poll_socket)
++{
++ int i, packet_types_len = strlen((char *) packet_types);
++
++ for(i = 0; i < packet_types_len; i++) {
++ /*
++ * XXX CHECK XXX
++ * When "poll_socket" is "1" libssh2_packet_ask_ex() could
++ * return PACKET_EAGAIN. Not sure the correct action, I
++ * think it is right as is.
++ */
++ if (0 == libssh2_packet_ask_ex(session, packet_types[i], data,
++ data_len, match_ofs, match_buf,
++ match_len, i ? 0 : poll_socket)) {
++ return 0;
++ }
++ }
++
++ return -1;
++}
++
++/* }}} */
++
++/* {{{ waitsocket
++ * Returns
++ * negative on error
++ * >0 on incoming data
++ * 0 on timeout
++ *
++ * FIXME: convert to use poll on systems that have it.
++ */
++int
++libssh2_waitsocket(LIBSSH2_SESSION * session, long seconds)
++{
++ struct timeval timeout;
++ int rc;
++ fd_set fd;
++
++ timeout.tv_sec = seconds;
++ timeout.tv_usec = 0;
++
++ FD_ZERO(&fd);
++
++ FD_SET(session->socket_fd, &fd);
++
++ rc = select(session->socket_fd + 1, &fd, NULL, NULL, &timeout);
++
++ return rc;
++}
++
++/* {{{ libssh2_packet_require
++ * Loops libssh2_packet_read() until the packet requested is available
++ * SSH_DISCONNECT or a SOCKET_DISCONNECTED will cause a bailout
++ *
++ * Returns negative on error
++ * Returns 0 when it has taken care of the requested packet.
++ */
++int
++libssh2_packet_require_ex(LIBSSH2_SESSION * session, unsigned char packet_type,
++ unsigned char **data, unsigned long *data_len,
++ unsigned long match_ofs,
++ const unsigned char *match_buf,
++ unsigned long match_len,
++ packet_require_state_t * state)
++{
++ if (state->start == 0) {
++ if (libssh2_packet_ask_ex
++ (session, packet_type, data, data_len, match_ofs, match_buf,
++ match_len, 0) == 0) {
++ /* A packet was available in the packet brigade */
++ return 0;
++ }
++
++ state->start = time(NULL);
++
++ _libssh2_debug(session, LIBSSH2_DBG_TRANS,
++ "May block until packet of type %d becomes available",
++ (int) packet_type);
++ }
++
++ while (session->socket_state == LIBSSH2_SOCKET_CONNECTED) {
++ libssh2pack_t ret = libssh2_packet_read(session);
++ if (ret == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if ((ret == 0) && (!session->socket_block)) {
++ /* If we are in non-blocking and there is no data, return that */
++ return PACKET_EAGAIN;
++ } else if (ret < 0) {
++ state->start = 0;
++ /* an error which is not just because of blocking */
++ return ret;
++ } else if (ret == packet_type) {
++ /* Be lazy, let packet_ask pull it out of the brigade */
++ ret =
++ libssh2_packet_ask_ex(session, packet_type, data, data_len,
++ match_ofs, match_buf, match_len, 0);
++ state->start = 0;
++ return ret;
++ } else if (ret == 0) {
++ /* nothing available, wait until data arrives or we time out */
++ long left = LIBSSH2_READ_TIMEOUT - (time(NULL) - state->start);
++
++ if ((left <= 0) || (libssh2_waitsocket(session, left) <= 0)) {
++ state->start = 0;
++ return PACKET_TIMEOUT;
++ }
++ }
++ }
++
++ /* Only reached if the socket died */
++ return -1;
++}
++
++/* }}} */
++
++/* {{{ libssh2_packet_burn
++ * Loops libssh2_packet_read() until any packet is available and promptly
++ * discards it
++ * Used during KEX exchange to discard badly guessed KEX_INIT packets
++ */
++int
++libssh2_packet_burn(LIBSSH2_SESSION * session,
++ libssh2_nonblocking_states * state)
++{
++ unsigned char *data;
++ unsigned long data_len;
++ unsigned char all_packets[255];
++ int i;
++ int ret;
++
++ if (*state == libssh2_NB_state_idle) {
++ for(i = 1; i < 256; i++) {
++ all_packets[i - 1] = i;
++ }
++
++ if (libssh2_packet_askv_ex
++ (session, all_packets, &data, &data_len, 0, NULL, 0, 0) == 0) {
++ i = data[0];
++ /* A packet was available in the packet brigade, burn it */
++ LIBSSH2_FREE(session, data);
++ return i;
++ }
++
++ _libssh2_debug(session, LIBSSH2_DBG_TRANS,
++ "Blocking until packet becomes available to burn");
++ *state = libssh2_NB_state_created;
++ }
++
++ while (session->socket_state == LIBSSH2_SOCKET_CONNECTED) {
++ if ((ret = libssh2_packet_read(session)) == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (ret < 0) {
++ *state = libssh2_NB_state_idle;
++ return ret;
++ } else if (ret == 0) {
++ /* FIXME: this might busyloop */
++ continue;
++ }
++
++ /* Be lazy, let packet_ask pull it out of the brigade */
++ if (0 ==
++ libssh2_packet_ask_ex(session, ret, &data, &data_len, 0, NULL, 0,
++ 0)) {
++ /* Smoke 'em if you got 'em */
++ LIBSSH2_FREE(session, data);
++ *state = libssh2_NB_state_idle;
++ return ret;
++ }
++ }
++
++ /* Only reached if the socket died */
++ return -1;
++}
++
++/* }}} */
++
++/*
++ * {{{ libssh2_packet_requirev
++ *
++ * Loops libssh2_packet_read() until one of a list of packet types requested is
++ * available
++ * SSH_DISCONNECT or a SOCKET_DISCONNECTED will cause a bailout
++ * packet_types is a null terminated list of packet_type numbers
++ */
++
++int
++libssh2_packet_requirev_ex(LIBSSH2_SESSION * session,
++ const unsigned char *packet_types,
++ unsigned char **data, unsigned long *data_len,
++ unsigned long match_ofs,
++ const unsigned char *match_buf,
++ unsigned long match_len,
++ packet_requirev_state_t * state)
++{
++ if (libssh2_packet_askv_ex
++ (session, packet_types, data, data_len, match_ofs, match_buf,
++ match_len, 0) == 0) {
++ /* One of the packets listed was available in the packet
++ brigade */
++ state->start = 0;
++ return 0;
++ }
++
++ if (state->start == 0) {
++ state->start = time(NULL);
++ }
++
++ while (session->socket_state != LIBSSH2_SOCKET_DISCONNECTED) {
++ int ret = libssh2_packet_read(session);
++ if ((ret < 0) && (ret != PACKET_EAGAIN)) {
++ state->start = 0;
++ return ret;
++ }
++ if (ret <= 0) {
++ long left = LIBSSH2_READ_TIMEOUT - (time(NULL) - state->start);
++
++ if ((left <= 0) || (libssh2_waitsocket(session, left) <= 0)) {
++ state->start = 0;
++ return PACKET_TIMEOUT;
++ } else if (ret == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ }
++ }
++
++ if (strchr((char *) packet_types, ret)) {
++ /* Be lazy, let packet_ask pull it out of the brigade */
++ return libssh2_packet_askv_ex(session, packet_types, data,
++ data_len, match_ofs, match_buf,
++ match_len, 0);
++ }
++ }
++
++ /* Only reached if the socket died */
++ state->start = 0;
++ return -1;
++}
++
++/* }}} */
+
+Property changes on: libssh2/src/packet.c
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.2
+Added: svn:eol-style
+ + native
+
+Index: libssh2/src/channel.c
+===================================================================
+--- libssh2/src/channel.c (.../tags/RELEASE_0_11_0)
++++ libssh2/src/channel.c (.../trunk)
+@@ -0,0 +1,2260 @@
++/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
++ * Copyright (c) 2008 by Daniel Stenberg
++ *
++ * 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"
++#ifdef HAVE_UNISTD_H
++#include <unistd.h>
++#endif
++#include <fcntl.h>
++#ifdef HAVE_INTTYPES_H
++#include <inttypes.h>
++#endif
++
++
++/* {{{ libssh2_channel_nextid
++ * Determine the next channel ID we can use at our end
++ */
++unsigned long
++libssh2_channel_nextid(LIBSSH2_SESSION * session)
++{
++ unsigned long id = session->next_channel;
++ LIBSSH2_CHANNEL *channel;
++
++ channel = session->channels.head;
++
++ while (channel) {
++ if (channel->local.id > id) {
++ id = channel->local.id;
++ }
++ channel = channel->next;
++ }
++
++ /* This is a shortcut to avoid waiting for close packets on channels we've
++ * forgotten about, This *could* be a problem if we request and close 4
++ * billion or so channels in too rapid succession for the remote end to
++ * respond, but the worst case scenario is that some data meant for
++ * another channel Gets picked up by the new one.... Pretty unlikely all
++ * told...
++ */
++ session->next_channel = id + 1;
++ _libssh2_debug(session, LIBSSH2_DBG_CONN, "Allocated new channel ID#%lu",
++ id);
++ return id;
++}
++
++/* }}} */
++
++/* {{{ libssh2_channel_locate
++ * Locate a channel pointer by number
++ */
++LIBSSH2_CHANNEL *
++libssh2_channel_locate(LIBSSH2_SESSION * session, unsigned long channel_id)
++{
++ LIBSSH2_CHANNEL *channel = session->channels.head;
++ while (channel) {
++ if (channel->local.id == channel_id) {
++ return channel;
++ }
++ channel = channel->next;
++ }
++
++ return NULL;
++}
++
++/* }}} */
++
++#define CHANNEL_ADD(session, channel) \
++{ \
++ if ((session)->channels.tail) { \
++ (session)->channels.tail->next = (channel); \
++ (channel)->prev = (session)->channels.tail; \
++ } else { \
++ (session)->channels.head = (channel); \
++ (channel)->prev = NULL; \
++ } \
++ (channel)->next = NULL; \
++ (session)->channels.tail = (channel); \
++ (channel)->session = (session); \
++}
++
++/* {{{ libssh2_channel_open_ex
++ * Establish a generic session channel
++ */
++LIBSSH2_API LIBSSH2_CHANNEL *
++libssh2_channel_open_ex(LIBSSH2_SESSION * session, const char *channel_type,
++ unsigned int channel_type_len,
++ unsigned int window_size, unsigned int packet_size,
++ const char *message, unsigned int message_len)
++{
++ static const unsigned char reply_codes[3] = {
++ SSH_MSG_CHANNEL_OPEN_CONFIRMATION,
++ SSH_MSG_CHANNEL_OPEN_FAILURE,
++ 0
++ };
++ unsigned char *s;
++ int rc;
++
++ if (session->open_state == libssh2_NB_state_idle) {
++ session->open_channel = NULL;
++ session->open_packet = NULL;
++ session->open_data = NULL;
++ /* 17 = packet_type(1) + channel_type_len(4) + sender_channel(4) +
++ * window_size(4) + packet_size(4) */
++ session->open_packet_len = channel_type_len + message_len + 17;
++ session->open_local_channel = libssh2_channel_nextid(session);
++
++ /* Zero the whole thing out */
++ memset(&session->open_packet_requirev_state, 0,
++ sizeof(session->open_packet_requirev_state));
++
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Opening Channel - win %d pack %d", window_size,
++ packet_size);
++ session->open_channel =
++ LIBSSH2_ALLOC(session, sizeof(LIBSSH2_CHANNEL));
++ if (!session->open_channel) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate space for channel data", 0);
++ return NULL;
++ }
++ memset(session->open_channel, 0, sizeof(LIBSSH2_CHANNEL));
++
++ session->open_channel->channel_type_len = channel_type_len;
++ session->open_channel->channel_type =
++ LIBSSH2_ALLOC(session, channel_type_len);
++ if (!session->open_channel->channel_type) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Failed allocating memory for channel type name", 0);
++ LIBSSH2_FREE(session, session->open_channel);
++ session->open_channel = NULL;
++ return NULL;
++ }
++ memcpy(session->open_channel->channel_type, channel_type,
++ channel_type_len);
++
++ /* REMEMBER: local as in locally sourced */
++ session->open_channel->local.id = session->open_local_channel;
++ session->open_channel->remote.window_size = window_size;
++ session->open_channel->remote.window_size_initial = window_size;
++ session->open_channel->remote.packet_size = packet_size;
++
++ CHANNEL_ADD(session, session->open_channel);
++
++ s = session->open_packet =
++ LIBSSH2_ALLOC(session, session->open_packet_len);
++ if (!session->open_packet) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate temporary space for packet", 0);
++ goto channel_error;
++ }
++ *(s++) = SSH_MSG_CHANNEL_OPEN;
++ libssh2_htonu32(s, channel_type_len);
++ s += 4;
++
++ memcpy(s, channel_type, channel_type_len);
++ s += channel_type_len;
++
++ libssh2_htonu32(s, session->open_local_channel);
++ s += 4;
++
++ libssh2_htonu32(s, window_size);
++ s += 4;
++
++ libssh2_htonu32(s, packet_size);
++ s += 4;
++
++ if (message && message_len) {
++ memcpy(s, message, message_len);
++ s += message_len;
++ }
++
++ session->open_state = libssh2_NB_state_created;
++ }
++
++ if (session->open_state == libssh2_NB_state_created) {
++ rc = libssh2_packet_write(session, session->open_packet,
++ session->open_packet_len);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block sending channel-open request", 0);
++ return NULL;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send channel-open request", 0);
++ goto channel_error;
++ }
++
++ session->open_state = libssh2_NB_state_sent;
++ }
++
++ if (session->open_state == libssh2_NB_state_sent) {
++ rc = libssh2_packet_requirev_ex(session, reply_codes,
++ &session->open_data,
++ &session->open_data_len, 1,
++ session->open_packet + 5 +
++ channel_type_len, 4,
++ &session->open_packet_requirev_state);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block", 0);
++ return NULL;
++ } else if (rc) {
++ goto channel_error;
++ }
++
++ if (session->open_data[0] == SSH_MSG_CHANNEL_OPEN_CONFIRMATION) {
++ session->open_channel->remote.id =
++ libssh2_ntohu32(session->open_data + 5);
++ session->open_channel->local.window_size =
++ libssh2_ntohu32(session->open_data + 9);
++ session->open_channel->local.window_size_initial =
++ libssh2_ntohu32(session->open_data + 9);
++ session->open_channel->local.packet_size =
++ libssh2_ntohu32(session->open_data + 13);
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Connection Established - ID: %lu/%lu win: %lu/%lu"
++ " pack: %lu/%lu",
++ session->open_channel->local.id,
++ session->open_channel->remote.id,
++ session->open_channel->local.window_size,
++ session->open_channel->remote.window_size,
++ session->open_channel->local.packet_size,
++ session->open_channel->remote.packet_size);
++ LIBSSH2_FREE(session, session->open_packet);
++ session->open_packet = NULL;
++ LIBSSH2_FREE(session, session->open_data);
++ session->open_data = NULL;
++
++ session->open_state = libssh2_NB_state_idle;
++ return session->open_channel;
++ }
++
++ if (session->open_data[0] == SSH_MSG_CHANNEL_OPEN_FAILURE) {
++ libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE,
++ "Channel open failure", 0);
++ }
++ }
++
++ channel_error:
++
++ if (session->open_data) {
++ LIBSSH2_FREE(session, session->open_data);
++ session->open_data = NULL;
++ }
++ if (session->open_packet) {
++ LIBSSH2_FREE(session, session->open_packet);
++ session->open_packet = NULL;
++ }
++ if (session->open_channel) {
++ unsigned char channel_id[4];
++ LIBSSH2_FREE(session, session->open_channel->channel_type);
++
++ if (session->open_channel->next) {
++ session->open_channel->next->prev = session->open_channel->prev;
++ }
++ if (session->open_channel->prev) {
++ session->open_channel->prev->next = session->open_channel->next;
++ }
++ if (session->channels.head == session->open_channel) {
++ session->channels.head = session->open_channel->next;
++ }
++ if (session->channels.tail == session->open_channel) {
++ session->channels.tail = session->open_channel->prev;
++ }
++
++ /* Clear out packets meant for this channel */
++ libssh2_htonu32(channel_id, session->open_channel->local.id);
++ while ((libssh2_packet_ask_ex
++ (session, SSH_MSG_CHANNEL_DATA, &session->open_data,
++ &session->open_data_len, 1, channel_id, 4, 0) >= 0)
++ ||
++ (libssh2_packet_ask_ex
++ (session, SSH_MSG_CHANNEL_EXTENDED_DATA, &session->open_data,
++ &session->open_data_len, 1, channel_id, 4, 0) >= 0)) {
++ LIBSSH2_FREE(session, session->open_data);
++ session->open_data = NULL;
++ }
++
++ /* Free any state variables still holding data */
++ if (session->open_channel->write_packet) {
++ LIBSSH2_FREE(session, session->open_channel->write_packet);
++ session->open_channel->write_packet = NULL;
++ }
++
++ LIBSSH2_FREE(session, session->open_channel);
++ session->open_channel = NULL;
++ }
++
++ session->open_state = libssh2_NB_state_idle;
++ return NULL;
++}
++
++/* }}} */
++
++/* {{{ libssh2_channel_direct_tcpip_ex
++ * Tunnel TCP/IP connect through the SSH session to direct host/port
++ */
++LIBSSH2_API LIBSSH2_CHANNEL *
++libssh2_channel_direct_tcpip_ex(LIBSSH2_SESSION * session, const char *host,
++ int port, const char *shost, int sport)
++{
++ LIBSSH2_CHANNEL *channel;
++ unsigned char *s;
++
++ if (session->direct_state == libssh2_NB_state_idle) {
++ session->direct_host_len = strlen(host);
++ session->direct_shost_len = strlen(shost);
++ /* host_len(4) + port(4) + shost_len(4) + sport(4) */
++ session->direct_message_len =
++ session->direct_host_len + session->direct_shost_len + 16;
++
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Requesting direct-tcpip session to from %s:%d to %s:%d",
++ shost, sport, host, port);
++
++ s = session->direct_message =
++ LIBSSH2_ALLOC(session, session->direct_message_len);
++ if (!session->direct_message) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for direct-tcpip connection",
++ 0);
++ return NULL;
++ }
++ libssh2_htonu32(s, session->direct_host_len);
++ s += 4;
++ memcpy(s, host, session->direct_host_len);
++ s += session->direct_host_len;
++ libssh2_htonu32(s, port);
++ s += 4;
++
++ libssh2_htonu32(s, session->direct_shost_len);
++ s += 4;
++ memcpy(s, shost, session->direct_shost_len);
++ s += session->direct_shost_len;
++ libssh2_htonu32(s, sport);
++ s += 4;
++
++ session->direct_state = libssh2_NB_state_created;
++ }
++
++ channel =
++ libssh2_channel_open_ex(session, "direct-tcpip",
++ sizeof("direct-tcpip") - 1,
++ LIBSSH2_CHANNEL_WINDOW_DEFAULT,
++ LIBSSH2_CHANNEL_PACKET_DEFAULT,
++ (char *) session->direct_message,
++ session->direct_message_len);
++ if (!channel) {
++ if (libssh2_session_last_errno(session) == LIBSSH2_ERROR_EAGAIN) {
++ /* The error code is still set to LIBSSH2_ERROR_EAGAIN */
++ return NULL;
++ } else {
++ LIBSSH2_FREE(session, session->direct_message);
++ session->direct_message = NULL;
++ return NULL;
++ }
++ }
++
++ LIBSSH2_FREE(session, session->direct_message);
++ session->direct_message = NULL;
++
++ return channel;
++}
++
++/* }}} */
++
++/* {{{ libssh2_channel_forward_listen_ex
++ * Bind a port on the remote host and listen for connections
++ */
++LIBSSH2_API LIBSSH2_LISTENER *
++libssh2_channel_forward_listen_ex(LIBSSH2_SESSION * session, const char *host,
++ int port, int *bound_port, int queue_maxsize)
++{
++ unsigned char *s, *data;
++ static const unsigned char reply_codes[3] =
++ { SSH_MSG_REQUEST_SUCCESS, SSH_MSG_REQUEST_FAILURE, 0 };
++ unsigned long data_len;
++ int rc;
++
++ if (session->fwdLstn_state == libssh2_NB_state_idle) {
++ session->fwdLstn_host_len =
++ (host ? strlen(host) : (sizeof("0.0.0.0") - 1));
++ /* 14 = packet_type(1) + request_len(4) + want_replay(1) + host_len(4)
++ + port(4) */
++ session->fwdLstn_packet_len =
++ session->fwdLstn_host_len + (sizeof("tcpip-forward") - 1) + 14;
++
++ /* Zero the whole thing out */
++ memset(&session->fwdLstn_packet_requirev_state, 0,
++ sizeof(session->fwdLstn_packet_requirev_state));
++
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Requesting tcpip-forward session for %s:%d", host,
++ port);
++
++ s = session->fwdLstn_packet =
++ LIBSSH2_ALLOC(session, session->fwdLstn_packet_len);
++ if (!session->fwdLstn_packet) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memeory for setenv packet", 0);
++ return NULL;
++ }
++
++ *(s++) = SSH_MSG_GLOBAL_REQUEST;
++ libssh2_htonu32(s, sizeof("tcpip-forward") - 1);
++ s += 4;
++ memcpy(s, "tcpip-forward", sizeof("tcpip-forward") - 1);
++ s += sizeof("tcpip-forward") - 1;
++ *(s++) = 0x01; /* want_reply */
++
++ libssh2_htonu32(s, session->fwdLstn_host_len);
++ s += 4;
++ memcpy(s, host ? host : "0.0.0.0", session->fwdLstn_host_len);
++ s += session->fwdLstn_host_len;
++ libssh2_htonu32(s, port);
++ s += 4;
++
++ session->fwdLstn_state = libssh2_NB_state_created;
++ }
++
++ if (session->fwdLstn_state == libssh2_NB_state_created) {
++ rc = libssh2_packet_write(session, session->fwdLstn_packet,
++ session->fwdLstn_packet_len);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block sending global-request packet for "
++ "forward listen request",
++ 0);
++ return NULL;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send global-request packet for forward "
++ "listen request",
++ 0);
++ LIBSSH2_FREE(session, session->fwdLstn_packet);
++ session->fwdLstn_packet = NULL;
++ session->fwdLstn_state = libssh2_NB_state_idle;
++ return NULL;
++ }
++ LIBSSH2_FREE(session, session->fwdLstn_packet);
++ session->fwdLstn_packet = NULL;
++
++ session->fwdLstn_state = libssh2_NB_state_sent;
++ }
++
++ if (session->fwdLstn_state == libssh2_NB_state_sent) {
++ rc = libssh2_packet_requirev_ex(session, reply_codes, &data, &data_len,
++ 0, NULL, 0,
++ &session->
++ fwdLstn_packet_requirev_state);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN, "Would block", 0);
++ return NULL;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_PROTO, "Unknown", 0);
++ session->fwdLstn_state = libssh2_NB_state_idle;
++ return NULL;
++ }
++
++ if (data[0] == SSH_MSG_REQUEST_SUCCESS) {
++ LIBSSH2_LISTENER *listener;
++
++ listener = LIBSSH2_ALLOC(session, sizeof(LIBSSH2_LISTENER));
++ if (!listener) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for listener queue",
++ 0);
++ LIBSSH2_FREE(session, data);
++ session->fwdLstn_state = libssh2_NB_state_idle;
++ return NULL;
++ }
++ memset(listener, 0, sizeof(LIBSSH2_LISTENER));
++ listener->session = session;
++ listener->host =
++ LIBSSH2_ALLOC(session, session->fwdLstn_host_len + 1);
++ if (!listener->host) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for listener queue",
++ 0);
++ LIBSSH2_FREE(session, listener);
++ LIBSSH2_FREE(session, data);
++ session->fwdLstn_state = libssh2_NB_state_idle;
++ return NULL;
++ }
++ memcpy(listener->host, host ? host : "0.0.0.0",
++ session->fwdLstn_host_len);
++ listener->host[session->fwdLstn_host_len] = 0;
++ if (data_len >= 5 && !port) {
++ listener->port = libssh2_ntohu32(data + 1);
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Dynamic tcpip-forward port allocated: %d",
++ listener->port);
++ } else {
++ listener->port = port;
++ }
++
++ listener->queue_size = 0;
++ listener->queue_maxsize = queue_maxsize;
++
++ listener->next = session->listeners;
++ listener->prev = NULL;
++ if (session->listeners) {
++ session->listeners->prev = listener;
++ }
++ session->listeners = listener;
++
++ if (bound_port) {
++ *bound_port = listener->port;
++ }
++
++ LIBSSH2_FREE(session, data);
++ session->fwdLstn_state = libssh2_NB_state_idle;
++ return listener;
++ }
++
++ if (data[0] == SSH_MSG_REQUEST_FAILURE) {
++ LIBSSH2_FREE(session, data);
++ libssh2_error(session, LIBSSH2_ERROR_REQUEST_DENIED,
++ "Unable to complete request for forward-listen", 0);
++ session->fwdLstn_state = libssh2_NB_state_idle;
++ return NULL;
++ }
++ }
++
++ session->fwdLstn_state = libssh2_NB_state_idle;
++
++ return NULL;
++}
++
++/* }}} */
++
++/* {{{ libssh2_channel_forward_cancel
++ * Stop listening on a remote port and free the listener
++ * Toss out any pending (un-accept()ed) connections
++ *
++ * Return 0 on success, PACKET_EAGAIN if would block, -1 on error
++ */
++LIBSSH2_API int
++libssh2_channel_forward_cancel(LIBSSH2_LISTENER * listener)
++{
++ LIBSSH2_SESSION *session = listener->session;
++ LIBSSH2_CHANNEL *queued = listener->queue;
++ unsigned char *packet, *s;
++ unsigned long host_len = strlen(listener->host);
++ /* 14 = packet_type(1) + request_len(4) + want_replay(1) + host_len(4) +
++ port(4) */
++ unsigned long packet_len =
++ host_len + 14 + sizeof("cancel-tcpip-forward") - 1;
++ int rc;
++
++ if (listener->chanFwdCncl_state == libssh2_NB_state_idle) {
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Cancelling tcpip-forward session for %s:%d",
++ listener->host, listener->port);
++
++ s = packet = LIBSSH2_ALLOC(session, packet_len);
++ if (!packet) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memeory for setenv packet", 0);
++ return -1;
++ }
++
++ *(s++) = SSH_MSG_GLOBAL_REQUEST;
++ libssh2_htonu32(s, sizeof("cancel-tcpip-forward") - 1);
++ s += 4;
++ memcpy(s, "cancel-tcpip-forward", sizeof("cancel-tcpip-forward") - 1);
++ s += sizeof("cancel-tcpip-forward") - 1;
++ *(s++) = 0x00; /* want_reply */
++
++ libssh2_htonu32(s, host_len);
++ s += 4;
++ memcpy(s, listener->host, host_len);
++ s += host_len;
++ libssh2_htonu32(s, listener->port);
++ s += 4;
++
++ listener->chanFwdCncl_state = libssh2_NB_state_created;
++ } else {
++ packet = listener->chanFwdCncl_data;
++ }
++
++ if (listener->chanFwdCncl_state == libssh2_NB_state_created) {
++ rc = libssh2_packet_write(session, packet, packet_len);
++ if (rc == PACKET_EAGAIN) {
++ listener->chanFwdCncl_data = packet;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send global-request packet for forward "
++ "listen request",
++ 0);
++ LIBSSH2_FREE(session, packet);
++ listener->chanFwdCncl_state = libssh2_NB_state_idle;
++ return -1;
++ }
++ LIBSSH2_FREE(session, packet);
++
++ listener->chanFwdCncl_state = libssh2_NB_state_sent;
++ }
++
++ while (queued) {
++ LIBSSH2_CHANNEL *next = queued->next;
++
++ rc = libssh2_channel_free(queued);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ }
++ queued = next;
++ }
++ LIBSSH2_FREE(session, listener->host);
++
++ if (listener->next) {
++ listener->next->prev = listener->prev;
++ }
++ if (listener->prev) {
++ listener->prev->next = listener->next;
++ } else {
++ session->listeners = listener->next;
++ }
++
++ LIBSSH2_FREE(session, listener);
++
++ listener->chanFwdCncl_state = libssh2_NB_state_idle;
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_channel_forward_accept
++ * Accept a connection
++ */
++LIBSSH2_API LIBSSH2_CHANNEL *
++libssh2_channel_forward_accept(LIBSSH2_LISTENER * listener)
++{
++ libssh2pack_t rc;
++
++ do {
++ rc = libssh2_packet_read(listener->session);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(listener->session, LIBSSH2_ERROR_EAGAIN,
++ "Would block waiting for packet", 0);
++ return NULL;
++ }
++ } while (rc > 0);
++
++ if (listener->queue) {
++ LIBSSH2_SESSION *session = listener->session;
++ LIBSSH2_CHANNEL *channel;
++
++ channel = listener->queue;
++
++ listener->queue = listener->queue->next;
++ if (listener->queue) {
++ listener->queue->prev = NULL;
++ }
++
++ channel->prev = NULL;
++ channel->next = session->channels.head;
++ session->channels.head = channel;
++
++ if (channel->next) {
++ channel->next->prev = channel;
++ } else {
++ session->channels.tail = channel;
++ }
++ listener->queue_size--;
++
++ return channel;
++ }
++
++ return NULL;
++}
++
++/* }}} */
++
++/* {{{ libssh2_channel_setenv_ex
++ * Set an environment variable prior to requesting a shell/program/subsystem
++ */
++LIBSSH2_API int
++libssh2_channel_setenv_ex(LIBSSH2_CHANNEL * channel, const char *varname,
++ unsigned int varname_len, const char *value,
++ unsigned int value_len)
++{
++ LIBSSH2_SESSION *session = channel->session;
++ unsigned char *s, *data;
++ static const unsigned char reply_codes[3] =
++ { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 };
++ unsigned long data_len;
++ int rc;
++
++ if (channel->setenv_state == libssh2_NB_state_idle) {
++ /* 21 = packet_type(1) + channel_id(4) + request_len(4) +
++ * request(3)"env" + want_reply(1) + varname_len(4) + value_len(4) */
++ channel->setenv_packet_len = varname_len + value_len + 21;
++
++ /* Zero the whole thing out */
++ memset(&channel->setenv_packet_requirev_state, 0,
++ sizeof(channel->setenv_packet_requirev_state));
++
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Setting remote environment variable: %s=%s on "
++ "channel %lu/%lu",
++ varname, value, channel->local.id, channel->remote.id);
++
++ s = channel->setenv_packet =
++ LIBSSH2_ALLOC(session, channel->setenv_packet_len);
++ if (!channel->setenv_packet) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memeory for setenv packet", 0);
++ return -1;
++ }
++
++ *(s++) = SSH_MSG_CHANNEL_REQUEST;
++ libssh2_htonu32(s, channel->remote.id);
++ s += 4;
++ libssh2_htonu32(s, sizeof("env") - 1);
++ s += 4;
++ memcpy(s, "env", sizeof("env") - 1);
++ s += sizeof("env") - 1;
++
++ *(s++) = 0x01;
++
++ libssh2_htonu32(s, varname_len);
++ s += 4;
++ memcpy(s, varname, varname_len);
++ s += varname_len;
++
++ libssh2_htonu32(s, value_len);
++ s += 4;
++ memcpy(s, value, value_len);
++ s += value_len;
++
++ channel->setenv_state = libssh2_NB_state_created;
++ }
++
++ if (channel->setenv_state == libssh2_NB_state_created) {
++ rc = libssh2_packet_write(session, channel->setenv_packet,
++ channel->setenv_packet_len);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send channel-request packet for "
++ "setenv request",
++ 0);
++ LIBSSH2_FREE(session, channel->setenv_packet);
++ channel->setenv_packet = NULL;
++ channel->setenv_state = libssh2_NB_state_idle;
++ return -1;
++ }
++ LIBSSH2_FREE(session, channel->setenv_packet);
++ channel->setenv_packet = NULL;
++
++ libssh2_htonu32(channel->setenv_local_channel, channel->local.id);
++
++ channel->setenv_state = libssh2_NB_state_sent;
++ }
++
++ if (channel->setenv_state == libssh2_NB_state_sent) {
++ rc = libssh2_packet_requirev_ex(session, reply_codes, &data, &data_len,
++ 1, channel->setenv_local_channel, 4,
++ &channel->
++ setenv_packet_requirev_state);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ }
++ if (rc) {
++ channel->setenv_state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ if (data[0] == SSH_MSG_CHANNEL_SUCCESS) {
++ LIBSSH2_FREE(session, data);
++ channel->setenv_state = libssh2_NB_state_idle;
++ return 0;
++ }
++
++ LIBSSH2_FREE(session, data);
++ }
++
++ libssh2_error(session, LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED,
++ "Unable to complete request for channel-setenv", 0);
++ channel->setenv_state = libssh2_NB_state_idle;
++ return -1;
++}
++
++/* }}} */
++
++/* {{{ libssh2_channel_request_pty_ex
++ * Duh... Request a PTY
++ */
++LIBSSH2_API int
++libssh2_channel_request_pty_ex(LIBSSH2_CHANNEL * channel, const char *term,
++ unsigned int term_len, const char *modes,
++ unsigned int modes_len, int width, int height,
++ int width_px, int height_px)
++{
++ LIBSSH2_SESSION *session = channel->session;
++ unsigned char *s, *data;
++ static const unsigned char reply_codes[3] =
++ { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 };
++ unsigned long data_len;
++ int rc;
++
++ if (channel->reqPTY_state == libssh2_NB_state_idle) {
++ /* 41 = packet_type(1) + channel(4) + pty_req_len(4) + "pty_req"(7) +
++ * want_reply(1) + term_len(4) + width(4) + height(4) + width_px(4) +
++ * height_px(4) + modes_len(4) */
++ channel->reqPTY_packet_len = term_len + modes_len + 41;
++
++ /* Zero the whole thing out */
++ memset(&channel->reqPTY_packet_requirev_state, 0,
++ sizeof(channel->reqPTY_packet_requirev_state));
++
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Allocating tty on channel %lu/%lu", channel->local.id,
++ channel->remote.id);
++
++ s = channel->reqPTY_packet =
++ LIBSSH2_ALLOC(session, channel->reqPTY_packet_len);
++ if (!channel->reqPTY_packet) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for pty-request", 0);
++ return -1;
++ }
++
++ *(s++) = SSH_MSG_CHANNEL_REQUEST;
++ libssh2_htonu32(s, channel->remote.id);
++ s += 4;
++ libssh2_htonu32(s, sizeof("pty-req") - 1);
++ s += 4;
++ memcpy(s, "pty-req", sizeof("pty-req") - 1);
++ s += sizeof("pty-req") - 1;
++
++ *(s++) = 0x01;
++
++ libssh2_htonu32(s, term_len);
++ s += 4;
++ if (term) {
++ memcpy(s, term, term_len);
++ s += term_len;
++ }
++
++ libssh2_htonu32(s, width);
++ s += 4;
++ libssh2_htonu32(s, height);
++ s += 4;
++ libssh2_htonu32(s, width_px);
++ s += 4;
++ libssh2_htonu32(s, height_px);
++ s += 4;
++
++ libssh2_htonu32(s, modes_len);
++ s += 4;
++ if (modes) {
++ memcpy(s, modes, modes_len);
++ s += modes_len;
++ }
++
++ channel->reqPTY_state = libssh2_NB_state_created;
++ }
++
++ if (channel->reqPTY_state == libssh2_NB_state_created) {
++ rc = libssh2_packet_write(session, channel->reqPTY_packet,
++ channel->reqPTY_packet_len);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send pty-request packet", 0);
++ LIBSSH2_FREE(session, channel->reqPTY_packet);
++ channel->reqPTY_packet = NULL;
++ channel->reqPTY_state = libssh2_NB_state_idle;
++ return -1;
++ }
++ LIBSSH2_FREE(session, channel->reqPTY_packet);
++ channel->reqPTY_packet = NULL;
++
++ libssh2_htonu32(channel->reqPTY_local_channel, channel->local.id);
++
++ channel->reqPTY_state = libssh2_NB_state_sent;
++ }
++
++ if (channel->reqPTY_state == libssh2_NB_state_sent) {
++ rc = libssh2_packet_requirev_ex(session, reply_codes, &data, &data_len,
++ 1, channel->reqPTY_local_channel, 4,
++ &channel->
++ reqPTY_packet_requirev_state);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ channel->reqPTY_state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ if (data[0] == SSH_MSG_CHANNEL_SUCCESS) {
++ LIBSSH2_FREE(session, data);
++ channel->reqPTY_state = libssh2_NB_state_idle;
++ return 0;
++ }
++ }
++
++ LIBSSH2_FREE(session, data);
++ libssh2_error(session, LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED,
++ "Unable to complete request for channel request-pty", 0);
++ channel->reqPTY_state = libssh2_NB_state_idle;
++ return -1;
++}
++
++/* }}} */
++
++LIBSSH2_API int
++libssh2_channel_request_pty_size_ex(LIBSSH2_CHANNEL * channel, int width,
++ int height, int width_px, int height_px)
++{
++ LIBSSH2_SESSION *session = channel->session;
++ unsigned char *s;
++ int rc;
++
++ if (channel->reqPTY_state == libssh2_NB_state_idle) {
++ channel->reqPTY_packet_len = 39;
++
++ /* Zero the whole thing out */
++ memset(&channel->reqPTY_packet_requirev_state, 0,
++ sizeof(channel->reqPTY_packet_requirev_state));
++
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "changing tty size on channel %lu/%lu",
++ channel->local.id,
++ channel->remote.id);
++
++ s = channel->reqPTY_packet =
++ LIBSSH2_ALLOC(session, channel->reqPTY_packet_len);
++
++ if (!channel->reqPTY_packet) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for pty-request", 0);
++ return -1;
++ }
++
++ *(s++) = SSH_MSG_CHANNEL_REQUEST;
++ libssh2_htonu32(s, channel->remote.id);
++ s += 4;
++ libssh2_htonu32(s, sizeof("window-change") - 1);
++ s += 4;
++ memcpy(s, "window-change", sizeof("window-change") - 1);
++ s += sizeof("window-change") - 1;
++
++ *(s++) = 0x00; /* Don't reply */
++ libssh2_htonu32(s, width);
++ s += 4;
++ libssh2_htonu32(s, height);
++ s += 4;
++ libssh2_htonu32(s, width_px);
++ s += 4;
++ libssh2_htonu32(s, height_px);
++ s += 4;
++
++ channel->reqPTY_state = libssh2_NB_state_created;
++ }
++
++ if (channel->reqPTY_state == libssh2_NB_state_created) {
++ rc = libssh2_packet_write(session, channel->reqPTY_packet,
++ channel->reqPTY_packet_len);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send window-change packet", 0);
++ LIBSSH2_FREE(session, channel->reqPTY_packet);
++ channel->reqPTY_packet = NULL;
++ channel->reqPTY_state = libssh2_NB_state_idle;
++ return -1;
++ }
++ LIBSSH2_FREE(session, channel->reqPTY_packet);
++ channel->reqPTY_packet = NULL;
++ libssh2_htonu32(channel->reqPTY_local_channel, channel->local.id);
++ channel->reqPTY_state = libssh2_NB_state_sent;
++
++ return 0;
++ }
++
++ channel->reqPTY_state = libssh2_NB_state_idle;
++ return -1;
++}
++
++/* Keep this an even number */
++#define LIBSSH2_X11_RANDOM_COOKIE_LEN 32
++
++/* {{{ libssh2_channel_x11_req_ex
++ * Request X11 forwarding
++ */
++LIBSSH2_API int
++libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL * channel, int single_connection,
++ const char *auth_proto, const char *auth_cookie,
++ int screen_number)
++{
++ LIBSSH2_SESSION *session = channel->session;
++ unsigned char *s, *data;
++ static const unsigned char reply_codes[3] =
++ { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 };
++ unsigned long data_len;
++ unsigned long proto_len =
++ auth_proto ? strlen(auth_proto) : (sizeof("MIT-MAGIC-COOKIE-1") - 1);
++ unsigned long cookie_len =
++ auth_cookie ? strlen(auth_cookie) : LIBSSH2_X11_RANDOM_COOKIE_LEN;
++ int rc;
++
++ if (channel->reqX11_state == libssh2_NB_state_idle) {
++ /* 30 = packet_type(1) + channel(4) + x11_req_len(4) + "x11-req"(7) +
++ * want_reply(1) + single_cnx(1) + proto_len(4) + cookie_len(4) +
++ * screen_num(4) */
++ channel->reqX11_packet_len = proto_len + cookie_len + 30;
++
++ /* Zero the whole thing out */
++ memset(&channel->reqX11_packet_requirev_state, 0,
++ sizeof(channel->reqX11_packet_requirev_state));
++
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Requesting x11-req for channel %lu/%lu: single=%d "
++ "proto=%s cookie=%s screen=%d",
++ channel->local.id, channel->remote.id,
++ single_connection,
++ auth_proto ? auth_proto : "MIT-MAGIC-COOKIE-1",
++ auth_cookie ? auth_cookie : "<random>", screen_number);
++
++ s = channel->reqX11_packet =
++ LIBSSH2_ALLOC(session, channel->reqX11_packet_len);
++ if (!channel->reqX11_packet) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for pty-request", 0);
++ return -1;
++ }
++
++ *(s++) = SSH_MSG_CHANNEL_REQUEST;
++ libssh2_htonu32(s, channel->remote.id);
++ s += 4;
++ libssh2_htonu32(s, sizeof("x11-req") - 1);
++ s += 4;
++ memcpy(s, "x11-req", sizeof("x11-req") - 1);
++ s += sizeof("x11-req") - 1;
++
++ *(s++) = 0x01; /* want_reply */
++ *(s++) = single_connection ? 0x01 : 0x00;
++
++ libssh2_htonu32(s, proto_len);
++ s += 4;
++ memcpy(s, auth_proto ? auth_proto : "MIT-MAGIC-COOKIE-1", proto_len);
++ s += proto_len;
++
++ libssh2_htonu32(s, cookie_len);
++ s += 4;
++ if (auth_cookie) {
++ memcpy(s, auth_cookie, cookie_len);
++ } else {
++ int i;
++ unsigned char buffer[LIBSSH2_X11_RANDOM_COOKIE_LEN / 2];
++
++ libssh2_random(buffer, LIBSSH2_X11_RANDOM_COOKIE_LEN / 2);
++ for(i = 0; i < (LIBSSH2_X11_RANDOM_COOKIE_LEN / 2); i++) {
++ snprintf((char *) s + (i * 2), 2, "%02X", buffer[i]);
++ }
++ }
++ s += cookie_len;
++
++ libssh2_htonu32(s, screen_number);
++ s += 4;
++
++ channel->reqX11_state = libssh2_NB_state_created;
++ }
++
++ if (channel->reqX11_state == libssh2_NB_state_created) {
++ rc = libssh2_packet_write(session, channel->reqX11_packet,
++ channel->reqX11_packet_len);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ }
++ if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send x11-req packet", 0);
++ LIBSSH2_FREE(session, channel->reqX11_packet);
++ channel->reqX11_packet = NULL;
++ channel->reqX11_state = libssh2_NB_state_idle;
++ return -1;
++ }
++ LIBSSH2_FREE(session, channel->reqX11_packet);
++ channel->reqX11_packet = NULL;
++
++ libssh2_htonu32(channel->reqX11_local_channel, channel->local.id);
++
++ channel->reqX11_state = libssh2_NB_state_sent;
++ }
++
++ if (channel->reqX11_state == libssh2_NB_state_sent) {
++ rc = libssh2_packet_requirev_ex(session, reply_codes, &data, &data_len,
++ 1, channel->reqX11_local_channel, 4,
++ &channel->
++ reqX11_packet_requirev_state);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ channel->reqX11_state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ if (data[0] == SSH_MSG_CHANNEL_SUCCESS) {
++ LIBSSH2_FREE(session, data);
++ channel->reqX11_state = libssh2_NB_state_idle;
++ return 0;
++ }
++ }
++
++ LIBSSH2_FREE(session, data);
++ libssh2_error(session, LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED,
++ "Unable to complete request for channel x11-req", 0);
++ return -1;
++}
++
++/* }}} */
++
++/* {{{ libssh2_channel_process_startup
++ * Primitive for libssh2_channel_(shell|exec|subsystem)
++ */
++LIBSSH2_API int
++libssh2_channel_process_startup(LIBSSH2_CHANNEL * channel, const char *request,
++ unsigned int request_len, const char *message,
++ unsigned int message_len)
++{
++ LIBSSH2_SESSION *session = channel->session;
++ unsigned char *s, *data;
++ static const unsigned char reply_codes[3] =
++ { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 };
++ unsigned long data_len;
++ libssh2pack_t rc;
++
++ if (channel->process_state == libssh2_NB_state_idle) {
++ /* 10 = packet_type(1) + channel(4) + request_len(4) + want_reply(1) */
++ channel->process_packet_len = request_len + 10;
++
++ /* Zero the whole thing out */
++ memset(&channel->process_packet_requirev_state, 0,
++ sizeof(channel->process_packet_requirev_state));
++
++ if (message) {
++ channel->process_packet_len += message_len + 4;
++ }
++
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "starting request(%s) on channel %lu/%lu, message=%s",
++ request, channel->local.id, channel->remote.id,
++ message);
++ s = channel->process_packet =
++ LIBSSH2_ALLOC(session, channel->process_packet_len);
++ if (!channel->process_packet) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for channel-process request",
++ 0);
++ return -1;
++ }
++
++ *(s++) = SSH_MSG_CHANNEL_REQUEST;
++ libssh2_htonu32(s, channel->remote.id);
++ s += 4;
++ libssh2_htonu32(s, request_len);
++ s += 4;
++ memcpy(s, request, request_len);
++ s += request_len;
++
++ *(s++) = 0x01;
++
++ if (message) {
++ libssh2_htonu32(s, message_len);
++ s += 4;
++ memcpy(s, message, message_len);
++ s += message_len;
++ }
++
++ channel->process_state = libssh2_NB_state_created;
++ }
++
++ if (channel->process_state == libssh2_NB_state_created) {
++ rc = libssh2_packet_write(session, channel->process_packet,
++ channel->process_packet_len);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send channel request", 0);
++ LIBSSH2_FREE(session, channel->process_packet);
++ channel->process_packet = NULL;
++ channel->process_state = libssh2_NB_state_idle;
++ return -1;
++ }
++ LIBSSH2_FREE(session, channel->process_packet);
++ channel->process_packet = NULL;
++
++ libssh2_htonu32(channel->process_local_channel, channel->local.id);
++
++ channel->process_state = libssh2_NB_state_sent;
++ }
++
++ if (channel->process_state == libssh2_NB_state_sent) {
++ rc = libssh2_packet_requirev_ex(session, reply_codes, &data, &data_len,
++ 1, channel->process_local_channel, 4,
++ &channel->
++ process_packet_requirev_state);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ channel->process_state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ if (data[0] == SSH_MSG_CHANNEL_SUCCESS) {
++ LIBSSH2_FREE(session, data);
++ channel->process_state = libssh2_NB_state_idle;
++ return 0;
++ }
++ }
++
++ LIBSSH2_FREE(session, data);
++ libssh2_error(session, LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED,
++ "Unable to complete request for channel-process-startup", 0);
++ channel->process_state = libssh2_NB_state_idle;
++ return -1;
++}
++
++/* }}} */
++
++/* {{{ libssh2_channel_set_blocking
++ * Set a channel's blocking mode on or off, similar to a socket's
++ * fcntl(fd, F_SETFL, O_NONBLOCK); type command
++ */
++LIBSSH2_API void
++libssh2_channel_set_blocking(LIBSSH2_CHANNEL * channel, int blocking)
++{
++ (void) _libssh2_session_set_blocking(channel->session, blocking);
++}
++
++/* }}} */
++
++/* {{{ libssh2_channel_flush_ex
++ * Flush data from one (or all) stream
++ * Returns number of bytes flushed, or -1 on failure
++ */
++LIBSSH2_API int
++libssh2_channel_flush_ex(LIBSSH2_CHANNEL * channel, int streamid)
++{
++ LIBSSH2_PACKET *packet = channel->session->packets.head;
++
++ if (channel->flush_state == libssh2_NB_state_idle) {
++ channel->flush_refund_bytes = 0;
++ channel->flush_flush_bytes = 0;
++
++ while (packet) {
++ LIBSSH2_PACKET *next = packet->next;
++ unsigned char packet_type = packet->data[0];
++
++ if (((packet_type == SSH_MSG_CHANNEL_DATA)
++ || (packet_type == SSH_MSG_CHANNEL_EXTENDED_DATA))
++ && (libssh2_ntohu32(packet->data + 1) == channel->local.id)) {
++ /* It's our channel at least */
++ long packet_stream_id =
++ (packet_type ==
++ SSH_MSG_CHANNEL_DATA) ? 0 : libssh2_ntohu32(packet->data +
++ 5);
++ if ((streamid == LIBSSH2_CHANNEL_FLUSH_ALL)
++ || ((packet_type == SSH_MSG_CHANNEL_EXTENDED_DATA)
++ && ((streamid == LIBSSH2_CHANNEL_FLUSH_EXTENDED_DATA)
++ || (streamid == packet_stream_id)))
++ || ((packet_type == SSH_MSG_CHANNEL_DATA)
++ && (streamid == 0))) {
++ int bytes_to_flush = packet->data_len - packet->data_head;
++
++ _libssh2_debug(channel->session, LIBSSH2_DBG_CONN,
++ "Flushing %d bytes of data from stream "
++ "%lu on channel %lu/%lu",
++ bytes_to_flush, packet_stream_id,
++ channel->local.id, channel->remote.id);
++
++ /* It's one of the streams we wanted to flush */
++ channel->flush_refund_bytes += packet->data_len - 13;
++ channel->flush_flush_bytes += bytes_to_flush;
++
++ LIBSSH2_FREE(channel->session, packet->data);
++ if (packet->prev) {
++ packet->prev->next = packet->next;
++ } else {
++ channel->session->packets.head = packet->next;
++ }
++ if (packet->next) {
++ packet->next->prev = packet->prev;
++ } else {
++ channel->session->packets.tail = packet->prev;
++ }
++ LIBSSH2_FREE(channel->session, packet);
++ }
++ }
++ packet = next;
++ }
++
++ channel->flush_state = libssh2_NB_state_created;
++ }
++
++ if (channel->flush_refund_bytes) {
++ int rc;
++
++ rc = libssh2_channel_receive_window_adjust(channel,
++ channel->flush_refund_bytes,
++ 0);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ }
++ }
++
++ channel->flush_state = libssh2_NB_state_idle;
++
++ return channel->flush_flush_bytes;
++}
++
++/* }}} */
++
++/* {{{ libssh2_channel_get_exit_status
++ * Return the channel's program exit status
++ */
++LIBSSH2_API int
++libssh2_channel_get_exit_status(LIBSSH2_CHANNEL * channel)
++{
++ return channel->exit_status;
++}
++
++/* }}} */
++
++/* {{{ libssh2_channel_receive_window_adjust
++ * Adjust the receive window for a channel by adjustment bytes
++ * If the amount to be adjusted is less than LIBSSH2_CHANNEL_MINADJUST and
++ * force is 0 the adjustment amount will be queued for a later packet
++ *
++ * Returns the new size of the receive window (as understood by remote end)
++ */
++LIBSSH2_API unsigned long
++libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL * channel,
++ unsigned long adjustment,
++ unsigned char force)
++{
++ int rc;
++
++ if (channel->adjust_state == libssh2_NB_state_idle) {
++ if (!force
++ && (adjustment + channel->adjust_queue <
++ LIBSSH2_CHANNEL_MINADJUST)) {
++ _libssh2_debug(channel->session, LIBSSH2_DBG_CONN,
++ "Queueing %lu bytes for receive window adjustment "
++ "for channel %lu/%lu",
++ adjustment, channel->local.id, channel->remote.id);
++ channel->adjust_queue += adjustment;
++ return channel->remote.window_size;
++ }
++
++ if (!adjustment && !channel->adjust_queue) {
++ return channel->remote.window_size;
++ }
++
++ adjustment += channel->adjust_queue;
++ channel->adjust_queue = 0;
++
++
++ /* Adjust the window based on the block we just freed */
++ channel->adjust_adjust[0] = SSH_MSG_CHANNEL_WINDOW_ADJUST;
++ libssh2_htonu32(channel->adjust_adjust + 1, channel->remote.id);
++ libssh2_htonu32(channel->adjust_adjust + 5, adjustment);
++ _libssh2_debug(channel->session, LIBSSH2_DBG_CONN,
++ "Adjusting window %lu bytes for data flushed from "
++ "channel %lu/%lu",
++ adjustment, channel->local.id, channel->remote.id);
++
++ channel->adjust_state = libssh2_NB_state_created;
++ }
++
++ rc = libssh2_packet_write(channel->session, channel->adjust_adjust, 9);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(channel->session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send transfer-window adjustment packet, "
++ "deferring",
++ 0);
++ channel->adjust_queue = adjustment;
++ channel->adjust_state = libssh2_NB_state_idle;
++ } else {
++ channel->adjust_state = libssh2_NB_state_idle;
++ channel->remote.window_size += adjustment;
++ }
++
++ return channel->remote.window_size;
++}
++
++/* }}} */
++
++/* {{{ libssh2_channel_handle_extended_data
++ *
++ * How should extended data look to the calling app? Keep it in separate
++ * channels[_read() _read_stdder()]? (NORMAL) Merge the extended data to the
++ * standard data? [everything via _read()]? (MERGE) Ignore it entirely [toss
++ * out packets as they come in]? (IGNORE)
++ */
++LIBSSH2_API void
++libssh2_channel_handle_extended_data(LIBSSH2_CHANNEL * channel,
++ int ignore_mode)
++{
++ while (libssh2_channel_handle_extended_data2(channel, ignore_mode) ==
++ PACKET_EAGAIN);
++}
++
++LIBSSH2_API int
++libssh2_channel_handle_extended_data2(LIBSSH2_CHANNEL * channel,
++ int ignore_mode)
++{
++ if (channel->extData2_state == libssh2_NB_state_idle) {
++ _libssh2_debug(channel->session, LIBSSH2_DBG_CONN,
++ "Setting channel %lu/%lu handle_extended_data mode to %d",
++ channel->local.id, channel->remote.id, ignore_mode);
++ channel->remote.extended_data_ignore_mode = ignore_mode;
++
++ channel->extData2_state = libssh2_NB_state_created;
++ }
++
++ if (channel->extData2_state == libssh2_NB_state_idle) {
++ if (ignore_mode == LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE) {
++ if (libssh2_channel_flush_ex
++ (channel,
++ LIBSSH2_CHANNEL_FLUSH_EXTENDED_DATA) == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ }
++ }
++ }
++
++ channel->extData2_state = libssh2_NB_state_idle;
++ return 0;
++}
++
++/* }}} */
++
++/*
++ * {{{ libssh2_channel_read_ex
++ * Read data from a channel blocking or non-blocking depending on set state
++ *
++ * When this is done non-blocking, it is important to not return 0 until the
++ * currently read channel is complete. If we read stuff from the wire but it
++ * was no payload data to fill in the buffer with, we MUST make sure to return
++ * PACKET_EAGAIN.
++ */
++LIBSSH2_API ssize_t
++libssh2_channel_read_ex(LIBSSH2_CHANNEL * channel, int stream_id, char *buf,
++ size_t buflen)
++{
++ LIBSSH2_SESSION *session = channel->session;
++ libssh2pack_t rc = 0;
++
++ if (channel->read_state == libssh2_NB_state_idle) {
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Attempting to read %d bytes from channel %lu/%lu stream #%d",
++ (int) buflen, channel->local.id, channel->remote.id,
++ stream_id);
++
++ /* process all incoming packets */
++ do {
++ if (libssh2_waitsocket(session, 0) > 0) {
++ rc = libssh2_packet_read(session);
++ } else {
++ /* Set for PACKET_EAGAIN so we continue */
++ rc = PACKET_EAGAIN;
++ }
++ } while (rc > 0);
++
++ if ((rc < 0) && (rc != PACKET_EAGAIN)) {
++ return rc;
++ }
++ channel->read_bytes_read = 0;
++
++ channel->read_packet = session->packets.head;
++ channel->read_state = libssh2_NB_state_created;
++ }
++
++ /*
++ * =============================== NOTE ===============================
++ * I know this is very ugly and not a really good use of "goto", but
++ * this case statement would be even uglier to do it any other way
++ */
++ if (channel->read_state == libssh2_NB_state_jump1) {
++ goto channel_read_ex_point1;
++ }
++
++ rc = 0;
++ channel->read_block = 0;
++
++ do {
++ if (channel->read_block) {
++ /* in the second lap and onwards, do this...
++ * If we haven't yet filled our buffer, try to read more
++ * data. */
++ if ( channel->read_bytes_read < (int) buflen) {
++ rc = libssh2_packet_read(session);
++
++ /* If we didn't find any more data to read */
++ if (rc < 0) {
++ if ( channel->read_bytes_read > 0){
++ break; /* finish processing and return */
++ }
++
++ /* no packets available, no data read. */
++ channel->read_state = libssh2_NB_state_idle;
++ return rc;
++ }
++ /* We read more data, restart our processing at the beginning
++ * of our packet list. */
++ channel->read_packet = session->packets.head;
++ }
++ else { /* The read buffer is full, finish processing and return */
++ break;
++ }
++ }
++
++ while (channel->read_packet
++ && (channel->read_bytes_read < (int) buflen)) {
++ /* In case packet gets destroyed during this iteration */
++ channel->read_next = channel->read_packet->next;
++
++ channel->read_local_id =
++ libssh2_ntohu32(channel->read_packet->data + 1);
++
++ /*
++ * Either we asked for a specific extended data stream
++ * (and data was available),
++ * or the standard stream (and data was available),
++ * or the standard stream with extended_data_merge
++ * enabled and data was available
++ */
++ if ((stream_id
++ && (channel->read_packet->data[0] ==
++ SSH_MSG_CHANNEL_EXTENDED_DATA)
++ && (channel->local.id == channel->read_local_id)
++ && (stream_id ==
++ (int) libssh2_ntohu32(channel->read_packet->data + 5)))
++ || (!stream_id
++ && (channel->read_packet->data[0] == SSH_MSG_CHANNEL_DATA)
++ && (channel->local.id == channel->read_local_id))
++ || (!stream_id
++ && (channel->read_packet->data[0] ==
++ SSH_MSG_CHANNEL_EXTENDED_DATA)
++ && (channel->local.id == channel->read_local_id)
++ && (channel->remote.extended_data_ignore_mode ==
++ LIBSSH2_CHANNEL_EXTENDED_DATA_MERGE))) {
++
++ channel->read_want = buflen - channel->read_bytes_read;
++ channel->read_unlink_packet = 0;
++
++ if (channel->read_want >=
++ (int) (channel->read_packet->data_len -
++ channel->read_packet->data_head)) {
++ channel->read_want =
++ channel->read_packet->data_len -
++ channel->read_packet->data_head;
++ channel->read_unlink_packet = 1;
++ }
++
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Reading %d of buffered data from %lu/%lu/%d",
++ channel->read_want, channel->local.id,
++ channel->remote.id, stream_id);
++ memcpy(buf + channel->read_bytes_read,
++ channel->read_packet->data +
++ channel->read_packet->data_head, channel->read_want);
++ channel->read_packet->data_head += channel->read_want;
++ channel->read_bytes_read += channel->read_want;
++
++ if (channel->read_unlink_packet) {
++ if (channel->read_packet->prev) {
++ channel->read_packet->prev->next =
++ channel->read_packet->next;
++ } else {
++ session->packets.head = channel->read_packet->next;
++ }
++ if (channel->read_packet->next) {
++ channel->read_packet->next->prev =
++ channel->read_packet->prev;
++ } else {
++ session->packets.tail = channel->read_packet->prev;
++ }
++ LIBSSH2_FREE(session, channel->read_packet->data);
++
++
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Unlinking empty packet buffer from "
++ "channel %lu/%lu",
++ channel->local.id, channel->remote.id);
++ channel_read_ex_point1:
++ channel->read_state = libssh2_NB_state_jump1;
++ rc = libssh2_channel_receive_window_adjust(channel,
++ channel->
++ read_packet->
++ data_len -
++ (stream_id ? 13
++ : 9), 0);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ }
++ channel->read_state = libssh2_NB_state_created;
++ LIBSSH2_FREE(session, channel->read_packet);
++ channel->read_packet = NULL;
++ }
++ }
++ channel->read_packet = channel->read_next;
++ }
++ channel->read_block = 1;
++ } while ((channel->read_bytes_read == 0) && !channel->remote.close);
++
++ channel->read_state = libssh2_NB_state_idle;
++ if (channel->read_bytes_read == 0) {
++ if (channel->session->socket_block) {
++ libssh2_error(session, LIBSSH2_ERROR_CHANNEL_CLOSED,
++ "Remote end has closed this channel", 0);
++ } else {
++ /*
++ * when non-blocking, we must return PACKET_EAGAIN if we haven't
++ * completed reading the channel
++ */
++ if (!libssh2_channel_eof(channel)) {
++ return PACKET_EAGAIN;
++ }
++ }
++ }
++
++ channel->read_state = libssh2_NB_state_idle;
++ return channel->read_bytes_read;
++}
++
++/* }}} */
++
++/*
++ * {{{ libssh2_channel_packet_data_len
++ * Return the size of the data block of the current packet, or 0 if there
++ * isn't a packet.
++ */
++unsigned long
++libssh2_channel_packet_data_len(LIBSSH2_CHANNEL * channel, int stream_id)
++{
++ LIBSSH2_SESSION *session = channel->session;
++ LIBSSH2_PACKET *read_packet;
++ uint32_t read_local_id;
++
++ if ((read_packet = session->packets.head) == NULL) {
++ return 0;
++ }
++
++ while (read_packet) {
++ read_local_id = libssh2_ntohu32(read_packet->data + 1);
++
++ /*
++ * Either we asked for a specific extended data stream
++ * (and data was available),
++ * or the standard stream (and data was available),
++ * or the standard stream with extended_data_merge
++ * enabled and data was available
++ */
++ if ((stream_id
++ && (read_packet->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA)
++ && (channel->local.id == read_local_id)
++ && (stream_id == (int) libssh2_ntohu32(read_packet->data + 5)))
++ || (!stream_id && (read_packet->data[0] == SSH_MSG_CHANNEL_DATA)
++ && (channel->local.id == read_local_id)) ||
++ (!stream_id
++ && (read_packet->
++ data[0] ==
++ SSH_MSG_CHANNEL_EXTENDED_DATA)
++ && (channel->
++ local.id ==
++ read_local_id)
++ && (channel->
++ remote.
++ extended_data_ignore_mode
++ ==
++ LIBSSH2_CHANNEL_EXTENDED_DATA_MERGE)))
++ {
++ return (read_packet->data_len - read_packet->data_head);
++ }
++ read_packet = read_packet->next;
++ }
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_channel_write_ex
++ * Send data to a channel
++ */
++LIBSSH2_API ssize_t
++libssh2_channel_write_ex(LIBSSH2_CHANNEL * channel, int stream_id,
++ const char *buf, size_t buflen)
++{
++ LIBSSH2_SESSION *session = channel->session;
++ libssh2pack_t rc;
++
++ if (channel->write_state == libssh2_NB_state_idle) {
++ channel->write_bufwrote = 0;
++
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Writing %d bytes on channel %lu/%lu, stream #%d",
++ (int) buflen, channel->local.id, channel->remote.id,
++ stream_id);
++
++ if (channel->local.close) {
++ libssh2_error(session, LIBSSH2_ERROR_CHANNEL_CLOSED,
++ "We've already closed this channel", 0);
++ return -1;
++ }
++
++ if (channel->local.eof) {
++ libssh2_error(session, LIBSSH2_ERROR_CHANNEL_EOF_SENT,
++ "EOF has already been sight, data might be ignored",
++ 0);
++ }
++
++ /* [13] 9 = packet_type(1) + channelno(4) [ + streamid(4) ] +
++ buflen(4) */
++ channel->write_packet_len = buflen + (stream_id ? 13 : 9);
++ channel->write_packet =
++ LIBSSH2_ALLOC(session, channel->write_packet_len);
++ if (!channel->write_packet) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocte space for data transmission packet",
++ 0);
++ return -1;
++ }
++
++ channel->write_state = libssh2_NB_state_allocated;
++ }
++
++ while (buflen > 0) {
++ if (channel->write_state == libssh2_NB_state_allocated) {
++ channel->write_bufwrite = buflen;
++ channel->write_s = channel->write_packet;
++
++ *(channel->write_s++) =
++ stream_id ? SSH_MSG_CHANNEL_EXTENDED_DATA :
++ SSH_MSG_CHANNEL_DATA;
++ libssh2_htonu32(channel->write_s, channel->remote.id);
++ channel->write_s += 4;
++ if (stream_id) {
++ libssh2_htonu32(channel->write_s, stream_id);
++ channel->write_s += 4;
++ }
++
++ /* twiddle our thumbs until there's window space available */
++ while (channel->local.window_size <= 0) {
++ /* Don't worry -- This is never hit unless it's a
++ blocking channel anyway */
++ rc = libssh2_packet_read(session);
++
++ if (rc < 0) {
++ /* Error or EAGAIN occurred, disconnect? */
++ if (rc != PACKET_EAGAIN) {
++ channel->write_state = libssh2_NB_state_idle;
++ }
++ return rc;
++ }
++
++ if ((rc == 0) && (session->socket_block == 0)) {
++ /*
++ * if rc == 0 and in non-blocking, then fake EAGAIN
++ * to prevent busyloops until data arriaves on the network
++ * which seemed like a very bad idea
++ */
++ return PACKET_EAGAIN;
++ }
++ }
++
++ /* Don't exceed the remote end's limits */
++ /* REMEMBER local means local as the SOURCE of the data */
++ if (channel->write_bufwrite > channel->local.window_size) {
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Splitting write block due to %lu byte "
++ "window_size on %lu/%lu/%d",
++ channel->local.window_size, channel->local.id,
++ channel->remote.id, stream_id);
++ channel->write_bufwrite = channel->local.window_size;
++ }
++ if (channel->write_bufwrite > channel->local.packet_size) {
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Splitting write block due to %lu byte "
++ "packet_size on %lu/%lu/%d",
++ channel->local.packet_size, channel->local.id,
++ channel->remote.id, stream_id);
++ channel->write_bufwrite = channel->local.packet_size;
++ }
++ libssh2_htonu32(channel->write_s, channel->write_bufwrite);
++ channel->write_s += 4;
++ memcpy(channel->write_s, buf, channel->write_bufwrite);
++ channel->write_s += channel->write_bufwrite;
++
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Sending %d bytes on channel %lu/%lu, stream_id=%d",
++ (int) channel->write_bufwrite, channel->local.id,
++ channel->remote.id, stream_id);
++
++ channel->write_state = libssh2_NB_state_created;
++ }
++
++ if (channel->write_state == libssh2_NB_state_created) {
++ rc = libssh2_packet_write(session, channel->write_packet,
++ channel->write_s -
++ channel->write_packet);
++ if (rc == PACKET_EAGAIN) {
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "libssh2_packet_write returned EAGAIN");
++ return PACKET_EAGAIN;
++ }
++ else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send channel data", 0);
++ LIBSSH2_FREE(session, channel->write_packet);
++ channel->write_packet = NULL;
++ channel->write_state = libssh2_NB_state_idle;
++ return -1;
++ }
++ /* Shrink local window size */
++ channel->local.window_size -= channel->write_bufwrite;
++
++ /* Adjust buf for next iteration */
++ buflen -= channel->write_bufwrite;
++ buf += channel->write_bufwrite;
++ channel->write_bufwrote += channel->write_bufwrite;
++
++ channel->write_state = libssh2_NB_state_allocated;
++
++ /*
++ * Not sure this is still wanted
++ if (!channel->session->socket_block) {
++ break;
++ }
++ */
++ }
++ }
++
++ LIBSSH2_FREE(session, channel->write_packet);
++ channel->write_packet = NULL;
++
++ channel->write_state = libssh2_NB_state_idle;
++
++ return channel->write_bufwrote;
++}
++
++/* }}} */
++
++/* {{{ libssh2_channel_send_eof
++ * Send EOF on channel
++ */
++LIBSSH2_API int
++libssh2_channel_send_eof(LIBSSH2_CHANNEL * channel)
++{
++ LIBSSH2_SESSION *session = channel->session;
++ unsigned char packet[5]; /* packet_type(1) + channelno(4) */
++ int rc;
++
++ _libssh2_debug(session, LIBSSH2_DBG_CONN, "Sending EOF on channel %lu/%lu",
++ channel->local.id, channel->remote.id);
++ packet[0] = SSH_MSG_CHANNEL_EOF;
++ libssh2_htonu32(packet + 1, channel->remote.id);
++ rc = libssh2_packet_write(session, packet, 5);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send EOF on channel", 0);
++ return -1;
++ }
++ channel->local.eof = 1;
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_channel_eof
++ * Read channel's eof status
++ */
++LIBSSH2_API int
++libssh2_channel_eof(LIBSSH2_CHANNEL * channel)
++{
++ LIBSSH2_SESSION *session = channel->session;
++ LIBSSH2_PACKET *packet = session->packets.head;
++
++ while (packet) {
++ if (((packet->data[0] == SSH_MSG_CHANNEL_DATA)
++ || (packet->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA))
++ && (channel->local.id == libssh2_ntohu32(packet->data + 1))) {
++ /* There's data waiting to be read yet, mask the EOF status */
++ return 0;
++ }
++ packet = packet->next;
++ }
++
++ return channel->remote.eof;
++}
++
++/* }}} */
++
++/* {{{ libssh2_channel_wait_eof
++* Awaiting channel EOF
++*/
++LIBSSH2_API int
++libssh2_channel_wait_eof(LIBSSH2_CHANNEL * channel)
++{
++ LIBSSH2_SESSION *session = channel->session;
++ int rc;
++
++ if (channel->wait_eof_state == libssh2_NB_state_idle) {
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Awaiting close of channel %lu/%lu", channel->local.id,
++ channel->remote.id);
++
++ channel->wait_eof_state = libssh2_NB_state_created;
++ }
++
++ /*
++ * While channel is not eof, read more packets from the network.
++ * Either the EOF will be set or network timeout will occur.
++ */
++ do {
++ if (channel->remote.eof) {
++ break;
++ }
++ rc = libssh2_packet_read(session);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc < 0) {
++ channel->wait_eof_state = libssh2_NB_state_idle;
++ return -1;
++ }
++ } while (1);
++
++ channel->wait_eof_state = libssh2_NB_state_idle;
++
++ return 0;
++}
++
++/* }}} */
++
++
++/* {{{ libssh2_channel_close
++ * Close a channel
++ */
++LIBSSH2_API int
++libssh2_channel_close(LIBSSH2_CHANNEL * channel)
++{
++ LIBSSH2_SESSION *session = channel->session;
++ int rc = 0;
++ int retcode;
++
++ if (channel->local.close) {
++ /* Already closed, act like we sent another close,
++ * even though we didn't... shhhhhh */
++ channel->close_state = libssh2_NB_state_idle;
++ return 0;
++ }
++
++ if (channel->close_state == libssh2_NB_state_idle) {
++ _libssh2_debug(session, LIBSSH2_DBG_CONN, "Closing channel %lu/%lu",
++ channel->local.id, channel->remote.id);
++
++ if (channel->close_cb) {
++ LIBSSH2_CHANNEL_CLOSE(session, channel);
++ }
++ channel->local.close = 1;
++
++ channel->close_packet[0] = SSH_MSG_CHANNEL_CLOSE;
++ libssh2_htonu32(channel->close_packet + 1, channel->remote.id);
++
++ channel->close_state = libssh2_NB_state_created;
++ }
++
++ if (channel->close_state == libssh2_NB_state_created) {
++ retcode = libssh2_packet_write(session, channel->close_packet, 5);
++ if (retcode == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (retcode) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send close-channel request", 0);
++ channel->close_state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ channel->close_state = libssh2_NB_state_sent;
++ }
++
++ if (channel->close_state == libssh2_NB_state_sent) {
++ /* We must wait for the remote SSH_MSG_CHANNEL_CLOSE message */
++ if (!channel->remote.close) {
++ libssh2pack_t ret;
++
++ do {
++ ret = libssh2_packet_read(session);
++ if (ret == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (ret < 0) {
++ rc = -1;
++ }
++ } while ((ret != SSH_MSG_CHANNEL_CLOSE) && (rc == 0));
++ }
++ }
++
++ channel->close_state = libssh2_NB_state_idle;
++
++ return rc;
++}
++
++/* }}} */
++
++/* {{{ libssh2_channel_wait_closed
++ * Awaiting channel close after EOF
++ */
++LIBSSH2_API int
++libssh2_channel_wait_closed(LIBSSH2_CHANNEL * channel)
++{
++ LIBSSH2_SESSION *session = channel->session;
++ int rc;
++
++ if (!libssh2_channel_eof(channel)) {
++ libssh2_error(session, LIBSSH2_ERROR_INVAL,
++ "libssh2_channel_wait_closed() invoked when channel is "
++ "not in EOF state",
++ 0);
++ return -1;
++ }
++
++ if (channel->wait_closed_state == libssh2_NB_state_idle) {
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Awaiting close of channel %lu/%lu", channel->local.id,
++ channel->remote.id);
++
++ channel->wait_closed_state = libssh2_NB_state_created;
++ }
++
++ /*
++ * While channel is not closed, read more packets from the network.
++ * Either the channel will be closed or network timeout will occur.
++ */
++ do {
++ if (!channel->remote.close) {
++ break;
++ }
++ rc = libssh2_packet_read(session);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc <= 0) {
++ break;
++ }
++ } while (1);
++
++ channel->wait_closed_state = libssh2_NB_state_idle;
++
++ return 0;
++}
++
++/* }}} */
++
++
++/* {{{ libssh2_channel_free
++ * Make sure a channel is closed, then remove the channel from the session
++ * and free its resource(s)
++ *
++ * Returns 0 on success, -1 on failure
++ */
++LIBSSH2_API int
++libssh2_channel_free(LIBSSH2_CHANNEL * channel)
++{
++ LIBSSH2_SESSION *session = channel->session;
++ unsigned char channel_id[4];
++ unsigned char *data;
++ unsigned long data_len;
++ int rc;
++
++ if (channel->free_state == libssh2_NB_state_idle) {
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Freeing channel %lu/%lu resources", channel->local.id,
++ channel->remote.id);
++
++ channel->free_state = libssh2_NB_state_created;
++ }
++
++ /* Allow channel freeing even when the socket has lost its connection */
++ if (!channel->local.close
++ && (session->socket_state == LIBSSH2_SOCKET_CONNECTED)) {
++ while ((rc = libssh2_channel_close(channel)) == PACKET_EAGAIN);
++ if (rc) {
++ channel->free_state = libssh2_NB_state_idle;
++ return -1;
++ }
++ }
++
++ channel->free_state = libssh2_NB_state_idle;
++
++ /*
++ * channel->remote.close *might* not be set yet, Well...
++ * We've sent the close packet, what more do you want?
++ * Just let packet_add ignore it when it finally arrives
++ */
++
++ /* Clear out packets meant for this channel */
++ libssh2_htonu32(channel_id, channel->local.id);
++ while ((libssh2_packet_ask_ex
++ (session, SSH_MSG_CHANNEL_DATA, &data, &data_len, 1, channel_id, 4,
++ 0) >= 0)
++ ||
++ (libssh2_packet_ask_ex
++ (session, SSH_MSG_CHANNEL_EXTENDED_DATA, &data, &data_len, 1,
++ channel_id, 4, 0) >= 0)) {
++ LIBSSH2_FREE(session, data);
++ }
++
++ /* free "channel_type" */
++ if (channel->channel_type) {
++ LIBSSH2_FREE(session, channel->channel_type);
++ }
++
++ /* Unlink from channel brigade */
++ if (channel->prev) {
++ channel->prev->next = channel->next;
++ } else {
++ session->channels.head = channel->next;
++ }
++ if (channel->next) {
++ channel->next->prev = channel->prev;
++ } else {
++ session->channels.tail = channel->prev;
++ }
++
++ /*
++ * Make sure all memory used in the state variables are free
++ */
++ if (channel->setenv_packet) {
++ LIBSSH2_FREE(session, channel->setenv_packet);
++ }
++ if (channel->reqPTY_packet) {
++ LIBSSH2_FREE(session, channel->reqPTY_packet);
++ }
++ if (channel->reqX11_packet) {
++ LIBSSH2_FREE(session, channel->reqX11_packet);
++ }
++ if (channel->process_packet) {
++ LIBSSH2_FREE(session, channel->process_packet);
++ }
++ if (channel->write_packet) {
++ LIBSSH2_FREE(session, channel->write_packet);
++ }
++
++ LIBSSH2_FREE(session, channel);
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_channel_window_read_ex
++ *
++ * Check the status of the read window. Returns the number of bytes which the
++ * remote end may send without overflowing the window limit read_avail (if
++ * passed) will be populated with the number of bytes actually available to be
++ * read window_size_initial (if passed) will be populated with the
++ * window_size_initial as defined by the channel_open request
++ */
++LIBSSH2_API unsigned long
++libssh2_channel_window_read_ex(LIBSSH2_CHANNEL * channel,
++ unsigned long *read_avail,
++ unsigned long *window_size_initial)
++{
++ if (window_size_initial) {
++ *window_size_initial = channel->remote.window_size_initial;
++ }
++
++ if (read_avail) {
++ unsigned long bytes_queued = 0;
++ LIBSSH2_PACKET *packet = channel->session->packets.head;
++
++ while (packet) {
++ unsigned char packet_type = packet->data[0];
++
++ if (((packet_type == SSH_MSG_CHANNEL_DATA)
++ || (packet_type == SSH_MSG_CHANNEL_EXTENDED_DATA))
++ && (libssh2_ntohu32(packet->data + 1) == channel->local.id)) {
++ bytes_queued += packet->data_len - packet->data_head;
++ }
++
++ packet = packet->next;
++ }
++
++ *read_avail = bytes_queued;
++ }
++
++ return channel->remote.window_size;
++}
++
++/* }}} */
++
++/* {{{ libssh2_channel_window_write_ex
++ *
++ * Check the status of the write window Returns the number of bytes which may
++ * be safely writen on the channel without blocking window_size_initial (if
++ * passed) will be populated with the size of the initial window as defined by
++ * the channel_open request
++ */
++LIBSSH2_API unsigned long
++libssh2_channel_window_write_ex(LIBSSH2_CHANNEL * channel,
++ unsigned long *window_size_initial)
++{
++ if (window_size_initial) {
++ /* For locally initiated channels this is very often 0, so it's not
++ * *that* useful as information goes */
++ *window_size_initial = channel->local.window_size_initial;
++ }
++
++ return channel->local.window_size;
++}
++
++/* }}} */
+
+Property changes on: libssh2/src/channel.c
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.2
+Added: svn:eol-style
+ + native
+
+Index: libssh2/src/libssh2_priv.h
+===================================================================
+--- libssh2/src/libssh2_priv.h (.../tags/RELEASE_0_11_0)
++++ libssh2/src/libssh2_priv.h (.../trunk)
+@@ -0,0 +1,1211 @@
++/* Copyright (c) 2004-2008, Sara Golemon <sarag@libssh2.org>
++ * 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.
++ */
++
++#ifndef LIBSSH2_PRIV_H
++#define LIBSSH2_PRIV_H 1
++
++#define LIBSSH2_LIBRARY
++#include "libssh2_config.h"
++
++#ifdef HAVE_WINDOWS_H
++#include <windows.h>
++#endif
++
++#ifdef HAVE_WS2TCPIP_H
++#include <ws2tcpip.h>
++#endif
++
++#include <stdio.h>
++#include <time.h>
++
++/* The following CPP block should really only be in session.c and
++ packet.c. However, AIX have #define's for 'events' and 'revents'
++ and we are using those names in libssh2.h, so we need to include
++ the AIX headers first, to make sure all code is compiled with
++ consistent names of these fields. While arguable the best would to
++ change libssh2.h to use other names, that would break backwards
++ compatibility. For more information, see:
++ http://www.mail-archive.com/libssh2-devel%40lists.sourceforge.net/msg00003.html
++ http://www.mail-archive.com/libssh2-devel%40lists.sourceforge.net/msg00224.html
++*/
++#ifdef HAVE_POLL
++# include <sys/poll.h>
++#else
++# if defined(HAVE_SELECT) && !defined(WIN32)
++# ifdef HAVE_SYS_SELECT_H
++# include <sys/select.h>
++# else
++# include <sys/time.h>
++# include <sys/types.h>
++# endif
++# endif
++#endif
++
++#include "libssh2.h"
++#include "libssh2_publickey.h"
++#include "libssh2_sftp.h"
++
++/* Provide iovec / writev on WIN32 platform. */
++#ifdef WIN32
++
++/* same as WSABUF */
++struct iovec {
++ u_long iov_len;
++ char *iov_base;
++};
++
++#define inline __inline
++
++static inline int writev(int sock, struct iovec *iov, int nvecs)
++{
++ DWORD ret;
++ if (WSASend(sock, (LPWSABUF)iov, nvecs, &ret, 0, NULL, NULL) == 0) {
++ return ret;
++ }
++ return -1;
++}
++
++#endif /* WIN32 */
++
++/* Needed for struct iovec on some platforms */
++#ifdef HAVE_SYS_UIO_H
++#include <sys/uio.h>
++#endif
++
++#ifdef HAVE_SYS_SOCKET_H
++# include <sys/socket.h>
++#endif
++#ifdef HAVE_SYS_IOCTL_H
++# include <sys/ioctl.h>
++#endif
++#ifdef HAVE_INTTYPES_H
++#include <inttypes.h>
++#endif
++
++#ifdef LIBSSH2_LIBGCRYPT
++#include "libgcrypt.h"
++#else
++#include "openssl.h"
++#endif
++
++#ifdef HAVE_WINSOCK2_H
++
++#include <winsock2.h>
++#include <mswsock.h>
++#include <ws2tcpip.h>
++
++#ifdef _MSC_VER
++/* "inline" keyword is valid only with C++ engine! */
++#define inline __inline
++#endif
++
++/* not really usleep, but safe for the way we use it in this lib */
++static inline int usleep(int udelay)
++{
++ Sleep(udelay / 1000);
++ return 0;
++}
++
++#endif
++
++/* RFC4253 section 6.1 Maximum Packet Length says:
++ *
++ * "All implementations MUST be able to process packets with
++ * uncompressed payload length of 32768 bytes or less and
++ * total packet size of 35000 bytes or less (including length,
++ * padding length, payload, padding, and MAC.)."
++ */
++#define MAX_SSH_PACKET_LEN 35000
++
++#define LIBSSH2_ALLOC(session, count) session->alloc((count), &(session)->abstract)
++#define LIBSSH2_REALLOC(session, ptr, count) ((ptr) ? session->realloc((ptr), (count), &(session)->abstract) : session->alloc((count), &(session)->abstract))
++#define LIBSSH2_FREE(session, ptr) session->free((ptr), &(session)->abstract)
++
++#define LIBSSH2_IGNORE(session, data, datalen) session->ssh_msg_ignore((session), (data), (datalen), &(session)->abstract)
++#define LIBSSH2_DEBUG(session, always_display, message, message_len, language, language_len) \
++ session->ssh_msg_disconnect((session), (always_display), (message), (message_len), (language), (language_len), &(session)->abstract)
++#define LIBSSH2_DISCONNECT(session, reason, message, message_len, language, language_len) \
++ session->ssh_msg_disconnect((session), (reason), (message), (message_len), (language), (language_len), &(session)->abstract)
++
++#define LIBSSH2_MACERROR(session, data, datalen) session->macerror((session), (data), (datalen), &(session)->abstract)
++#define LIBSSH2_X11_OPEN(channel, shost, sport) channel->session->x11(((channel)->session), (channel), (shost), (sport), (&(channel)->session->abstract))
++
++#define LIBSSH2_CHANNEL_CLOSE(session, channel) channel->close_cb((session), &(session)->abstract, (channel), &(channel)->abstract)
++
++typedef struct _LIBSSH2_KEX_METHOD LIBSSH2_KEX_METHOD;
++typedef struct _LIBSSH2_HOSTKEY_METHOD LIBSSH2_HOSTKEY_METHOD;
++typedef struct _LIBSSH2_MAC_METHOD LIBSSH2_MAC_METHOD;
++typedef struct _LIBSSH2_CRYPT_METHOD LIBSSH2_CRYPT_METHOD;
++typedef struct _LIBSSH2_COMP_METHOD LIBSSH2_COMP_METHOD;
++
++typedef struct _LIBSSH2_PACKET LIBSSH2_PACKET;
++typedef struct _LIBSSH2_PACKET_BRIGADE LIBSSH2_PACKET_BRIGADE;
++typedef struct _LIBSSH2_CHANNEL_BRIGADE LIBSSH2_CHANNEL_BRIGADE;
++
++typedef int libssh2pack_t;
++
++typedef enum
++{
++ libssh2_NB_state_idle = 0,
++ libssh2_NB_state_allocated,
++ libssh2_NB_state_created,
++ libssh2_NB_state_sent,
++ libssh2_NB_state_sent1,
++ libssh2_NB_state_sent2,
++ libssh2_NB_state_sent3,
++ libssh2_NB_state_sent4,
++ libssh2_NB_state_sent5,
++ libssh2_NB_state_sent6,
++ libssh2_NB_state_sent7,
++ libssh2_NB_state_jump1,
++ libssh2_NB_state_jump2,
++ libssh2_NB_state_jump3
++} libssh2_nonblocking_states;
++
++typedef struct packet_require_state_t
++{
++ libssh2_nonblocking_states state;
++ time_t start;
++} packet_require_state_t;
++
++typedef struct packet_requirev_state_t
++{
++ time_t start;
++} packet_requirev_state_t;
++
++typedef struct kmdhgGPsha1kex_state_t
++{
++ libssh2_nonblocking_states state;
++ unsigned char *e_packet;
++ unsigned char *s_packet;
++ unsigned char *tmp;
++ unsigned char h_sig_comp[SHA_DIGEST_LENGTH];
++ unsigned char c;
++ unsigned long e_packet_len;
++ unsigned long s_packet_len;
++ unsigned long tmp_len;
++ _libssh2_bn_ctx *ctx;
++ _libssh2_bn *x;
++ _libssh2_bn *e;
++ _libssh2_bn *f;
++ _libssh2_bn *k;
++ unsigned char *s;
++ unsigned char *f_value;
++ unsigned char *k_value;
++ unsigned char *h_sig;
++ unsigned long f_value_len;
++ unsigned long k_value_len;
++ unsigned long h_sig_len;
++ libssh2_sha1_ctx exchange_hash;
++ packet_require_state_t req_state;
++ libssh2_nonblocking_states burn_state;
++} kmdhgGPsha1kex_state_t;
++
++typedef struct key_exchange_state_low_t
++{
++ libssh2_nonblocking_states state;
++ packet_require_state_t req_state;
++ kmdhgGPsha1kex_state_t exchange_state;
++ _libssh2_bn *p; /* SSH2 defined value (p_value) */
++ _libssh2_bn *g; /* SSH2 defined value (2) */
++ unsigned char request[13];
++ unsigned char *data;
++ unsigned long request_len;
++ unsigned long data_len;
++} key_exchange_state_low_t;
++
++typedef struct key_exchange_state_t
++{
++ libssh2_nonblocking_states state;
++ packet_require_state_t req_state;
++ key_exchange_state_low_t key_state_low;
++ unsigned char *data;
++ unsigned long data_len;
++ unsigned char *oldlocal;
++ unsigned long oldlocal_len;
++} key_exchange_state_t;
++
++#define FwdNotReq "Forward not requested"
++
++typedef struct packet_queue_listener_state_t
++{
++ libssh2_nonblocking_states state;
++ unsigned char packet[17 + (sizeof(FwdNotReq) - 1)];
++ unsigned char *host;
++ unsigned char *shost;
++ uint32_t sender_channel;
++ uint32_t initial_window_size;
++ uint32_t packet_size;
++ uint32_t port;
++ uint32_t sport;
++ uint32_t host_len;
++ uint32_t shost_len;
++} packet_queue_listener_state_t;
++
++#define X11FwdUnAvil "X11 Forward Unavailable"
++
++typedef struct packet_x11_open_state_t
++{
++ libssh2_nonblocking_states state;
++ unsigned char packet[17 + (sizeof(X11FwdUnAvil) - 1)];
++ unsigned char *shost;
++ uint32_t sender_channel;
++ uint32_t initial_window_size;
++ uint32_t packet_size;
++ uint32_t sport;
++ uint32_t shost_len;
++} packet_x11_open_state_t;
++
++struct _LIBSSH2_PACKET
++{
++ unsigned char type;
++
++ /* Unencrypted Payload (no type byte, no padding, just the facts ma'am) */
++ unsigned char *data;
++ unsigned long data_len;
++
++ /* Where to start reading data from,
++ * used for channel data that's been partially consumed */
++ unsigned long data_head;
++
++ /* Can the message be confirmed? */
++ int mac;
++
++ LIBSSH2_PACKET_BRIGADE *brigade;
++
++ LIBSSH2_PACKET *next, *prev;
++};
++
++struct _LIBSSH2_PACKET_BRIGADE
++{
++ LIBSSH2_PACKET *head, *tail;
++};
++
++typedef struct _libssh2_channel_data
++{
++ /* Identifier */
++ unsigned long id;
++
++ /* Limits and restrictions */
++ unsigned long window_size_initial, window_size, packet_size;
++
++ /* Set to 1 when CHANNEL_CLOSE / CHANNEL_EOF sent/received */
++ char close, eof, extended_data_ignore_mode;
++} libssh2_channel_data;
++
++struct _LIBSSH2_CHANNEL
++{
++ unsigned char *channel_type;
++ unsigned channel_type_len;
++
++ /* channel's program exit status */
++ int exit_status;
++
++ libssh2_channel_data local, remote;
++ /* Amount of bytes to be refunded to receive window (but not yet sent) */
++ unsigned long adjust_queue;
++
++ LIBSSH2_SESSION *session;
++
++ LIBSSH2_CHANNEL *next, *prev;
++
++ void *abstract;
++ LIBSSH2_CHANNEL_CLOSE_FUNC((*close_cb));
++
++ /* State variables used in libssh2_channel_setenv_ex() */
++ libssh2_nonblocking_states setenv_state;
++ unsigned char *setenv_packet;
++ unsigned long setenv_packet_len;
++ unsigned char setenv_local_channel[4];
++ packet_requirev_state_t setenv_packet_requirev_state;
++
++ /* State variables used in libssh2_channel_request_pty_ex() */
++ libssh2_nonblocking_states reqPTY_state;
++ unsigned char *reqPTY_packet;
++ unsigned long reqPTY_packet_len;
++ unsigned char reqPTY_local_channel[4];
++ packet_requirev_state_t reqPTY_packet_requirev_state;
++
++ /* State variables used in libssh2_channel_x11_req_ex() */
++ libssh2_nonblocking_states reqX11_state;
++ unsigned char *reqX11_packet;
++ unsigned long reqX11_packet_len;
++ unsigned char reqX11_local_channel[4];
++ packet_requirev_state_t reqX11_packet_requirev_state;
++
++ /* State variables used in libssh2_channel_process_startup() */
++ libssh2_nonblocking_states process_state;
++ unsigned char *process_packet;
++ unsigned long process_packet_len;
++ unsigned char process_local_channel[4];
++ packet_requirev_state_t process_packet_requirev_state;
++
++ /* State variables used in libssh2_channel_flush_ex() */
++ libssh2_nonblocking_states flush_state;
++ unsigned long flush_refund_bytes;
++ unsigned long flush_flush_bytes;
++
++ /* State variables used in libssh2_channel_receive_window_adjust() */
++ libssh2_nonblocking_states adjust_state;
++ unsigned char adjust_adjust[9]; /* packet_type(1) + channel(4) + adjustment(4) */
++
++ /* State variables used in libssh2_channel_read_ex() */
++ libssh2_nonblocking_states read_state;
++ LIBSSH2_PACKET *read_packet;
++ LIBSSH2_PACKET *read_next;
++ int read_block;
++ int read_bytes_read;
++ uint32_t read_local_id;
++ int read_want;
++ int read_unlink_packet;
++
++ /* State variables used in libssh2_channel_write_ex() */
++ libssh2_nonblocking_states write_state;
++ unsigned char *write_packet;
++ unsigned char *write_s;
++ unsigned long write_packet_len;
++ unsigned long write_bufwrote;
++ size_t write_bufwrite;
++
++ /* State variables used in libssh2_channel_close() */
++ libssh2_nonblocking_states close_state;
++ unsigned char close_packet[5];
++
++ /* State variables used in libssh2_channel_wait_closedeof() */
++ libssh2_nonblocking_states wait_eof_state;
++
++ /* State variables used in libssh2_channel_wait_closed() */
++ libssh2_nonblocking_states wait_closed_state;
++
++ /* State variables used in libssh2_channel_free() */
++ libssh2_nonblocking_states free_state;
++
++ /* State variables used in libssh2_channel_handle_extended_data2() */
++ libssh2_nonblocking_states extData2_state;
++};
++
++struct _LIBSSH2_CHANNEL_BRIGADE
++{
++ LIBSSH2_CHANNEL *head, *tail;
++};
++
++struct _LIBSSH2_LISTENER
++{
++ LIBSSH2_SESSION *session;
++
++ char *host;
++ int port;
++
++ LIBSSH2_CHANNEL *queue;
++ int queue_size;
++ int queue_maxsize;
++
++ LIBSSH2_LISTENER *prev, *next;
++
++ /* State variables used in libssh2_channel_forward_cancel() */
++ libssh2_nonblocking_states chanFwdCncl_state;
++ unsigned char *chanFwdCncl_data;
++ size_t chanFwdCncl_data_len;
++};
++
++typedef struct _libssh2_endpoint_data
++{
++ unsigned char *banner;
++
++ unsigned char *kexinit;
++ unsigned long kexinit_len;
++
++ const LIBSSH2_CRYPT_METHOD *crypt;
++ void *crypt_abstract;
++
++ const LIBSSH2_MAC_METHOD *mac;
++ unsigned long seqno;
++ void *mac_abstract;
++
++ const LIBSSH2_COMP_METHOD *comp;
++ void *comp_abstract;
++
++ /* Method Preferences -- NULL yields "load order" */
++ char *crypt_prefs;
++ char *mac_prefs;
++ char *comp_prefs;
++ char *lang_prefs;
++} libssh2_endpoint_data;
++
++#define PACKETBUFSIZE 4096
++
++struct transportpacket
++{
++ /* ------------- for incoming data --------------- */
++ unsigned char buf[PACKETBUFSIZE];
++ unsigned char init[5]; /* first 5 bytes of the incoming data stream,
++ still encrypted */
++ int writeidx; /* at what array index we do the next write into
++ the buffer */
++ int readidx; /* at what array index we do the next read from
++ the buffer */
++ int packet_length; /* the most recent packet_length as read from the
++ network data */
++ int padding_length; /* the most recent padding_length as read from the
++ network data */
++ int data_num; /* How much of the total package that has been read
++ so far. */
++ int total_num; /* How much a total package is supposed to be, in
++ number of bytes. A full package is
++ packet_length + padding_length + 4 +
++ mac_length. */
++ unsigned char *payload; /* this is a pointer to a LIBSSH2_ALLOC()
++ area to which we write decrypted data */
++ unsigned char *wptr; /* write pointer into the payload to where we
++ are currently writing decrypted data */
++
++ /* ------------- for outgoing data --------------- */
++ unsigned char *outbuf; /* pointer to a LIBSSH2_ALLOC() area for the
++ outgoing data */
++ int ototal_num; /* size of outbuf in number of bytes */
++ unsigned char *odata; /* original pointer to the data we stored in
++ outbuf */
++ unsigned long olen; /* original size of the data we stored in
++ outbuf */
++ unsigned long osent; /* number of bytes already sent */
++};
++
++struct _LIBSSH2_PUBLICKEY
++{
++ LIBSSH2_CHANNEL *channel;
++ unsigned long version;
++
++ /* State variables used in libssh2_publickey_packet_receive() */
++ libssh2_nonblocking_states receive_state;
++ unsigned char *receive_packet;
++ unsigned long receive_packet_len;
++
++ /* State variables used in libssh2_publickey_add_ex() */
++ libssh2_nonblocking_states add_state;
++ unsigned char *add_packet;
++ unsigned char *add_s;
++
++ /* State variables used in libssh2_publickey_remove_ex() */
++ libssh2_nonblocking_states remove_state;
++ unsigned char *remove_packet;
++ unsigned char *remove_s;
++
++ /* State variables used in libssh2_publickey_list_fetch() */
++ libssh2_nonblocking_states listFetch_state;
++ unsigned char *listFetch_s;
++ unsigned char listFetch_buffer[12];
++ unsigned char *listFetch_data;
++ unsigned long listFetch_data_len;
++};
++
++#define SFTP_HANDLE_MAXLEN 256 /* according to spec! */
++
++struct _LIBSSH2_SFTP_HANDLE
++{
++ LIBSSH2_SFTP *sftp;
++ LIBSSH2_SFTP_HANDLE *prev, *next;
++
++ /* This is a pre-allocated buffer used for sending SFTP requests as the
++ whole thing might not get sent in one go. This buffer is used for read,
++ write, close and MUST thus be big enough to suit all these. */
++ unsigned char request_packet[SFTP_HANDLE_MAXLEN + 25];
++
++ char handle[SFTP_HANDLE_MAXLEN];
++ int handle_len;
++
++ char handle_type;
++
++ union _libssh2_sftp_handle_data
++ {
++ struct _libssh2_sftp_handle_file_data
++ {
++ libssh2_uint64_t offset;
++ } file;
++ struct _libssh2_sftp_handle_dir_data
++ {
++ unsigned long names_left;
++ void *names_packet;
++ char *next_name;
++ } dir;
++ } u;
++
++ /* State variables used in libssh2_sftp_close_handle() */
++ libssh2_nonblocking_states close_state;
++ unsigned long close_request_id;
++ unsigned char *close_packet;
++};
++
++struct _LIBSSH2_SFTP
++{
++ LIBSSH2_CHANNEL *channel;
++
++ unsigned long request_id, version;
++
++ LIBSSH2_PACKET_BRIGADE packets;
++
++ LIBSSH2_SFTP_HANDLE *handles;
++
++ unsigned long last_errno;
++
++ /* Holder for partial packet, use in libssh2_sftp_packet_read() */
++ unsigned char *partial_packet; /* The data */
++ unsigned long partial_len; /* Desired number of bytes */
++ unsigned long partial_received; /* Bytes received so far */
++
++ /* Time that libssh2_sftp_packet_requirev() started reading */
++ time_t requirev_start;
++
++ /* State variables used in libssh2_sftp_open_ex() */
++ libssh2_nonblocking_states open_state;
++ unsigned char *open_packet;
++ ssize_t open_packet_len;
++ unsigned long open_request_id;
++
++ /* State variables used in libssh2_sftp_read() */
++ libssh2_nonblocking_states read_state;
++ unsigned char *read_packet;
++ unsigned long read_request_id;
++ size_t read_total_read;
++
++ /* State variables used in libssh2_sftp_readdir() */
++ libssh2_nonblocking_states readdir_state;
++ unsigned char *readdir_packet;
++ unsigned long readdir_request_id;
++
++ /* State variables used in libssh2_sftp_write() */
++ libssh2_nonblocking_states write_state;
++ unsigned char *write_packet;
++ unsigned long write_request_id;
++
++ /* State variables used in libssh2_sftp_fstat_ex() */
++ libssh2_nonblocking_states fstat_state;
++ unsigned char *fstat_packet;
++ unsigned long fstat_request_id;
++
++ /* State variables used in libssh2_sftp_unlink_ex() */
++ libssh2_nonblocking_states unlink_state;
++ unsigned char *unlink_packet;
++ unsigned long unlink_request_id;
++
++ /* State variables used in libssh2_sftp_rename_ex() */
++ libssh2_nonblocking_states rename_state;
++ unsigned char *rename_packet;
++ unsigned char *rename_s;
++ unsigned long rename_request_id;
++
++ /* State variables used in libssh2_sftp_mkdir() */
++ libssh2_nonblocking_states mkdir_state;
++ unsigned char *mkdir_packet;
++ unsigned long mkdir_request_id;
++
++ /* State variables used in libssh2_sftp_rmdir() */
++ libssh2_nonblocking_states rmdir_state;
++ unsigned char *rmdir_packet;
++ unsigned long rmdir_request_id;
++
++ /* State variables used in libssh2_sftp_stat() */
++ libssh2_nonblocking_states stat_state;
++ unsigned char *stat_packet;
++ unsigned long stat_request_id;
++
++ /* State variables used in libssh2_sftp_symlink() */
++ libssh2_nonblocking_states symlink_state;
++ unsigned char *symlink_packet;
++ unsigned long symlink_request_id;
++};
++
++#define LIBSSH2_SCP_RESPONSE_BUFLEN 256
++
++struct _LIBSSH2_SESSION
++{
++ /* Memory management callbacks */
++ void *abstract;
++ LIBSSH2_ALLOC_FUNC((*alloc));
++ LIBSSH2_REALLOC_FUNC((*realloc));
++ LIBSSH2_FREE_FUNC((*free));
++
++ /* Other callbacks */
++ LIBSSH2_IGNORE_FUNC((*ssh_msg_ignore));
++ LIBSSH2_DEBUG_FUNC((*ssh_msg_debug));
++ LIBSSH2_DISCONNECT_FUNC((*ssh_msg_disconnect));
++ LIBSSH2_MACERROR_FUNC((*macerror));
++ LIBSSH2_X11_OPEN_FUNC((*x11));
++
++ /* Method preferences -- NULL yields "load order" */
++ char *kex_prefs;
++ char *hostkey_prefs;
++
++ int state;
++ int flags;
++
++ /* Agreed Key Exchange Method */
++ const LIBSSH2_KEX_METHOD *kex;
++ int burn_optimistic_kexinit:1;
++
++ unsigned char *session_id;
++ unsigned long session_id_len;
++
++ /* Server's public key */
++ const LIBSSH2_HOSTKEY_METHOD *hostkey;
++ void *server_hostkey_abstract;
++
++ /* Either set with libssh2_session_hostkey() (for server mode)
++ * Or read from server in (eg) KEXDH_INIT (for client mode)
++ */
++ unsigned char *server_hostkey;
++ unsigned long server_hostkey_len;
++#if LIBSSH2_MD5
++ unsigned char server_hostkey_md5[MD5_DIGEST_LENGTH];
++#endif /* ! LIBSSH2_MD5 */
++ unsigned char server_hostkey_sha1[SHA_DIGEST_LENGTH];
++
++ /* (remote as source of data -- packet_read ) */
++ libssh2_endpoint_data remote;
++
++ /* (local as source of data -- packet_write ) */
++ libssh2_endpoint_data local;
++
++ /* Inbound Data buffer -- Sometimes the packet that comes in isn't the packet we're ready for */
++ LIBSSH2_PACKET_BRIGADE packets;
++
++ /* Active connection channels */
++ LIBSSH2_CHANNEL_BRIGADE channels;
++ unsigned long next_channel;
++
++ LIBSSH2_LISTENER *listeners;
++
++ /* Actual I/O socket */
++ int socket_fd;
++ int socket_block;
++ int socket_state;
++ int socket_block_directions;
++
++ /* Error tracking */
++ char *err_msg;
++ unsigned long err_msglen;
++ int err_should_free;
++ int err_code;
++
++ /* struct members for packet-level reading */
++ struct transportpacket packet;
++#ifdef LIBSSH2DEBUG
++ int showmask; /* what debug/trace messages to display */
++#endif
++
++ /* State variables used in libssh2_banner_send() */
++ libssh2_nonblocking_states banner_TxRx_state;
++ char banner_TxRx_banner[256];
++ ssize_t banner_TxRx_total_send;
++
++ /* State variables used in libssh2_kexinit() */
++ libssh2_nonblocking_states kexinit_state;
++ unsigned char *kexinit_data;
++ size_t kexinit_data_len;
++
++ /* State variables used in libssh2_session_startup() */
++ libssh2_nonblocking_states startup_state;
++ unsigned char *startup_data;
++ unsigned long startup_data_len;
++ unsigned char startup_service[sizeof("ssh-userauth") + 5 - 1];
++ unsigned long startup_service_length;
++ packet_require_state_t startup_req_state;
++ key_exchange_state_t startup_key_state;
++
++ /* State variables used in libssh2_session_free() */
++ libssh2_nonblocking_states free_state;
++
++ /* State variables used in libssh2_session_disconnect_ex() */
++ libssh2_nonblocking_states disconnect_state;
++ unsigned char *disconnect_data;
++ unsigned long disconnect_data_len;
++
++ /* State variables used in libssh2_packet_read() */
++ libssh2_nonblocking_states readPack_state;
++ int readPack_encrypted;
++
++ /* State variables used in libssh2_userauth_list() */
++ libssh2_nonblocking_states userauth_list_state;
++ unsigned char *userauth_list_data;
++ unsigned long userauth_list_data_len;
++ packet_requirev_state_t userauth_list_packet_requirev_state;
++
++ /* State variables used in libssh2_userauth_password_ex() */
++ libssh2_nonblocking_states userauth_pswd_state;
++ unsigned char *userauth_pswd_data;
++ unsigned char userauth_pswd_data0;
++ unsigned long userauth_pswd_data_len;
++ char *userauth_pswd_newpw;
++ int userauth_pswd_newpw_len;
++ packet_requirev_state_t userauth_pswd_packet_requirev_state;
++
++ /* State variables used in libssh2_userauth_hostbased_fromfile_ex() */
++ libssh2_nonblocking_states userauth_host_state;
++ unsigned char *userauth_host_data;
++ unsigned long userauth_host_data_len;
++ unsigned char *userauth_host_packet;
++ unsigned long userauth_host_packet_len;
++ unsigned char *userauth_host_method;
++ unsigned long userauth_host_method_len;
++ unsigned char *userauth_host_s;
++ packet_requirev_state_t userauth_host_packet_requirev_state;
++
++ /* State variables used in libssh2_userauth_publickey_fromfile_ex() */
++ libssh2_nonblocking_states userauth_pblc_state;
++ unsigned char *userauth_pblc_data;
++ unsigned long userauth_pblc_data_len;
++ unsigned char *userauth_pblc_packet;
++ unsigned long userauth_pblc_packet_len;
++ unsigned char *userauth_pblc_method;
++ unsigned long userauth_pblc_method_len;
++ unsigned char *userauth_pblc_s;
++ unsigned char *userauth_pblc_b;
++ packet_requirev_state_t userauth_pblc_packet_requirev_state;
++
++ /* State variables used in llibssh2_userauth_keyboard_interactive_ex() */
++ libssh2_nonblocking_states userauth_kybd_state;
++ unsigned char *userauth_kybd_data;
++ unsigned long userauth_kybd_data_len;
++ unsigned char *userauth_kybd_packet;
++ unsigned long userauth_kybd_packet_len;
++ unsigned int userauth_kybd_auth_name_len;
++ char *userauth_kybd_auth_name;
++ unsigned userauth_kybd_auth_instruction_len;
++ char *userauth_kybd_auth_instruction;
++ unsigned int userauth_kybd_num_prompts;
++ int userauth_kybd_auth_failure;
++ LIBSSH2_USERAUTH_KBDINT_PROMPT *userauth_kybd_prompts;
++ LIBSSH2_USERAUTH_KBDINT_RESPONSE *userauth_kybd_responses;
++ packet_requirev_state_t userauth_kybd_packet_requirev_state;
++
++ /* State variables used in libssh2_channel_open_ex() */
++ libssh2_nonblocking_states open_state;
++ packet_requirev_state_t open_packet_requirev_state;
++ LIBSSH2_CHANNEL *open_channel;
++ unsigned char *open_packet;
++ unsigned long open_packet_len;
++ unsigned char *open_data;
++ unsigned long open_data_len;
++ unsigned long open_local_channel;
++
++ /* State variables used in libssh2_channel_direct_tcpip_ex() */
++ libssh2_nonblocking_states direct_state;
++ unsigned char *direct_message;
++ unsigned long direct_host_len;
++ unsigned long direct_shost_len;
++ unsigned long direct_message_len;
++
++ /* State variables used in libssh2_channel_forward_listen_ex() */
++ libssh2_nonblocking_states fwdLstn_state;
++ unsigned char *fwdLstn_packet;
++ unsigned long fwdLstn_host_len;
++ unsigned long fwdLstn_packet_len;
++ packet_requirev_state_t fwdLstn_packet_requirev_state;
++
++ /* State variables used in libssh2_publickey_init() */
++ libssh2_nonblocking_states pkeyInit_state;
++ LIBSSH2_PUBLICKEY *pkeyInit_pkey;
++ LIBSSH2_CHANNEL *pkeyInit_channel;
++ unsigned char *pkeyInit_data;
++ unsigned long pkeyInit_data_len;
++
++ /* State variables used in libssh2_packet_add() */
++ libssh2_nonblocking_states packAdd_state;
++ LIBSSH2_PACKET *packAdd_packet;
++ LIBSSH2_CHANNEL *packAdd_channel;
++ unsigned long packAdd_data_head;
++ key_exchange_state_t packAdd_key_state;
++ packet_queue_listener_state_t packAdd_Qlstn_state;
++ packet_x11_open_state_t packAdd_x11open_state;
++
++ /* State variables used in fullpacket() */
++ libssh2_nonblocking_states fullpacket_state;
++ int fullpacket_macstate;
++ int fullpacket_payload_len;
++ libssh2pack_t fullpacket_packet_type;
++
++ /* State variables used in libssh2_sftp_init() */
++ libssh2_nonblocking_states sftpInit_state;
++ LIBSSH2_SFTP *sftpInit_sftp;
++ LIBSSH2_CHANNEL *sftpInit_channel;
++ unsigned char sftpInit_buffer[9]; /* sftp_header(5){excludes request_id} + version_id(4) */
++
++ /* State variables used in libssh2_scp_recv() */
++ libssh2_nonblocking_states scpRecv_state;
++ unsigned char *scpRecv_command;
++ unsigned long scpRecv_command_len;
++ unsigned char scpRecv_response[LIBSSH2_SCP_RESPONSE_BUFLEN];
++ unsigned long scpRecv_response_len;
++ long scpRecv_mode;
++#if defined(HAVE_LONGLONG) && defined(strtoll)
++ /* we have the type and we can parse such numbers */
++ long long scpRecv_size;
++#define scpsize_strtol strtoll
++#else
++ long scpRecv_size;
++#define scpsize_strtol strtol
++#endif
++ long scpRecv_mtime;
++ long scpRecv_atime;
++ char *scpRecv_err_msg;
++ long scpRecv_err_len;
++ LIBSSH2_CHANNEL *scpRecv_channel;
++
++ /* State variables used in libssh2_scp_send_ex() */
++ libssh2_nonblocking_states scpSend_state;
++ unsigned char *scpSend_command;
++ unsigned long scpSend_command_len;
++ unsigned char scpSend_response[LIBSSH2_SCP_RESPONSE_BUFLEN];
++ unsigned long scpSend_response_len;
++ char *scpSend_err_msg;
++ long scpSend_err_len;
++ LIBSSH2_CHANNEL *scpSend_channel;
++};
++
++/* session.state bits */
++#define LIBSSH2_STATE_EXCHANGING_KEYS 0x00000001
++#define LIBSSH2_STATE_NEWKEYS 0x00000002
++#define LIBSSH2_STATE_AUTHENTICATED 0x00000004
++#define LIBSSH2_STATE_KEX_ACTIVE 0x00000008
++
++/* session.flag helpers */
++#ifdef MSG_NOSIGNAL
++#define LIBSSH2_SOCKET_SEND_FLAGS(session) (((session)->flags & LIBSSH2_FLAG_SIGPIPE) ? 0 : MSG_NOSIGNAL)
++#define LIBSSH2_SOCKET_RECV_FLAGS(session) (((session)->flags & LIBSSH2_FLAG_SIGPIPE) ? 0 : MSG_NOSIGNAL)
++#else
++/* If MSG_NOSIGNAL isn't defined we're SOL on blocking SIGPIPE */
++#define LIBSSH2_SOCKET_SEND_FLAGS(session) 0
++#define LIBSSH2_SOCKET_RECV_FLAGS(session) 0
++#endif
++
++/* libssh2 extensible ssh api, ultimately I'd like to allow loading additional methods via .so/.dll */
++
++struct _LIBSSH2_KEX_METHOD
++{
++ const char *name;
++
++ /* Key exchange, populates session->* and returns 0 on success, non-0 on error */
++ int (*exchange_keys) (LIBSSH2_SESSION * session,
++ key_exchange_state_low_t * key_state);
++
++ long flags;
++};
++
++struct _LIBSSH2_HOSTKEY_METHOD
++{
++ const char *name;
++ unsigned long hash_len;
++
++ int (*init) (LIBSSH2_SESSION * session, const unsigned char *hostkey_data,
++ unsigned long hostkey_data_len, void **abstract);
++ int (*initPEM) (LIBSSH2_SESSION * session, const char *privkeyfile,
++ unsigned const char *passphrase, void **abstract);
++ int (*sig_verify) (LIBSSH2_SESSION * session, const unsigned char *sig,
++ unsigned long sig_len, const unsigned char *m,
++ unsigned long m_len, void **abstract);
++ int (*signv) (LIBSSH2_SESSION * session, unsigned char **signature,
++ unsigned long *signature_len, unsigned long veccount,
++ const struct iovec datavec[], void **abstract);
++ int (*encrypt) (LIBSSH2_SESSION * session, unsigned char **dst,
++ unsigned long *dst_len, const unsigned char *src,
++ unsigned long src_len, void **abstract);
++ int (*dtor) (LIBSSH2_SESSION * session, void **abstract);
++};
++
++struct _LIBSSH2_CRYPT_METHOD
++{
++ const char *name;
++
++ int blocksize;
++
++ /* iv and key sizes (-1 for variable length) */
++ int iv_len;
++ int secret_len;
++
++ long flags;
++
++ int (*init) (LIBSSH2_SESSION * session,
++ const LIBSSH2_CRYPT_METHOD * method, unsigned char *iv,
++ int *free_iv, unsigned char *secret, int *free_secret,
++ int encrypt, void **abstract);
++ int (*crypt) (LIBSSH2_SESSION * session, unsigned char *block,
++ void **abstract);
++ int (*dtor) (LIBSSH2_SESSION * session, void **abstract);
++
++ _libssh2_cipher_type(algo);
++};
++
++struct _LIBSSH2_COMP_METHOD
++{
++ const char *name;
++
++ int (*init) (LIBSSH2_SESSION * session, int compress, void **abstract);
++ int (*comp) (LIBSSH2_SESSION * session, int compress, unsigned char **dest,
++ unsigned long *dest_len, unsigned long payload_limit,
++ int *free_dest, const unsigned char *src,
++ unsigned long src_len, void **abstract);
++ int (*dtor) (LIBSSH2_SESSION * session, int compress, void **abstract);
++};
++
++struct _LIBSSH2_MAC_METHOD
++{
++ const char *name;
++
++ /* The length of a given MAC packet */
++ int mac_len;
++
++ /* integrity key length */
++ int key_len;
++
++ /* Message Authentication Code Hashing algo */
++ int (*init) (LIBSSH2_SESSION * session, unsigned char *key, int *free_key,
++ void **abstract);
++ int (*hash) (LIBSSH2_SESSION * session, unsigned char *buf,
++ unsigned long seqno, const unsigned char *packet,
++ unsigned long packet_len, const unsigned char *addtl,
++ unsigned long addtl_len, void **abstract);
++ int (*dtor) (LIBSSH2_SESSION * session, void **abstract);
++};
++
++#define LIBSSH2_DBG_TRANS 1
++#define LIBSSH2_DBG_KEX 2
++#define LIBSSH2_DBG_AUTH 3
++#define LIBSSH2_DBG_CONN 4
++#define LIBSSH2_DBG_SCP 5
++#define LIBSSH2_DBG_SFTP 6
++#define LIBSSH2_DBG_ERROR 7
++#define LIBSSH2_DBG_PUBLICKEY 8
++#ifdef LIBSSH2DEBUG
++void _libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format,
++ ...);
++#else
++#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
++/* C99 style */
++#define _libssh2_debug(x,y,z, __VA_ARGS__) do {} while (0)
++#elif defined(__GNUC__)
++/* GNU style */
++#define _libssh2_debug(x,y,z,...) do {} while (0)
++#else
++/* no gcc and not C99, do static and hopefully inline */
++static inline void
++_libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, ...)
++{
++}
++#endif
++#endif
++
++#ifdef LIBSSH2DEBUG
++#define libssh2_error(session, errcode, errmsg, should_free) \
++{ \
++ if (session->err_msg && session->err_should_free) { \
++ LIBSSH2_FREE(session, session->err_msg); \
++ } \
++ session->err_msg = (char *)errmsg; \
++ session->err_msglen = strlen(errmsg); \
++ session->err_should_free = should_free; \
++ session->err_code = errcode; \
++ _libssh2_debug(session, LIBSSH2_DBG_ERROR, "%d - %s", session->err_code, session->err_msg); \
++}
++
++#else /* ! LIBSSH2DEBUG */
++
++#define libssh2_error(session, errcode, errmsg, should_free) \
++{ \
++ if (session->err_msg && session->err_should_free) { \
++ LIBSSH2_FREE(session, session->err_msg); \
++ } \
++ session->err_msg = (char *)errmsg; \
++ session->err_msglen = strlen(errmsg); \
++ session->err_should_free = should_free; \
++ session->err_code = errcode; \
++}
++
++#endif /* ! LIBSSH2DEBUG */
++
++
++#define LIBSSH2_SOCKET_UNKNOWN 1
++#define LIBSSH2_SOCKET_CONNECTED 0
++#define LIBSSH2_SOCKET_DISCONNECTED -1
++
++/* Initial packet state, prior to MAC check */
++#define LIBSSH2_MAC_UNCONFIRMED 1
++/* When MAC type is "none" (proto initiation phase) all packets are deemed "confirmed" */
++#define LIBSSH2_MAC_CONFIRMED 0
++/* Something very bad is going on */
++#define LIBSSH2_MAC_INVALID -1
++
++/* SSH Packet Types -- Defined by internet draft */
++/* Transport Layer */
++#define SSH_MSG_DISCONNECT 1
++#define SSH_MSG_IGNORE 2
++#define SSH_MSG_UNIMPLEMENTED 3
++#define SSH_MSG_DEBUG 4
++#define SSH_MSG_SERVICE_REQUEST 5
++#define SSH_MSG_SERVICE_ACCEPT 6
++
++#define SSH_MSG_KEXINIT 20
++#define SSH_MSG_NEWKEYS 21
++
++/* diffie-hellman-group1-sha1 */
++#define SSH_MSG_KEXDH_INIT 30
++#define SSH_MSG_KEXDH_REPLY 31
++
++/* diffie-hellman-group-exchange-sha1 */
++#define SSH_MSG_KEX_DH_GEX_REQUEST_OLD 30
++#define SSH_MSG_KEX_DH_GEX_REQUEST 34
++#define SSH_MSG_KEX_DH_GEX_GROUP 31
++#define SSH_MSG_KEX_DH_GEX_INIT 32
++#define SSH_MSG_KEX_DH_GEX_REPLY 33
++
++/* User Authentication */
++#define SSH_MSG_USERAUTH_REQUEST 50
++#define SSH_MSG_USERAUTH_FAILURE 51
++#define SSH_MSG_USERAUTH_SUCCESS 52
++#define SSH_MSG_USERAUTH_BANNER 53
++
++/* "public key" method */
++#define SSH_MSG_USERAUTH_PK_OK 60
++/* "password" method */
++#define SSH_MSG_USERAUTH_PASSWD_CHANGEREQ 60
++/* "keyboard-interactive" method */
++#define SSH_MSG_USERAUTH_INFO_REQUEST 60
++#define SSH_MSG_USERAUTH_INFO_RESPONSE 61
++
++/* Channels */
++#define SSH_MSG_GLOBAL_REQUEST 80
++#define SSH_MSG_REQUEST_SUCCESS 81
++#define SSH_MSG_REQUEST_FAILURE 82
++
++#define SSH_MSG_CHANNEL_OPEN 90
++#define SSH_MSG_CHANNEL_OPEN_CONFIRMATION 91
++#define SSH_MSG_CHANNEL_OPEN_FAILURE 92
++#define SSH_MSG_CHANNEL_WINDOW_ADJUST 93
++#define SSH_MSG_CHANNEL_DATA 94
++#define SSH_MSG_CHANNEL_EXTENDED_DATA 95
++#define SSH_MSG_CHANNEL_EOF 96
++#define SSH_MSG_CHANNEL_CLOSE 97
++#define SSH_MSG_CHANNEL_REQUEST 98
++#define SSH_MSG_CHANNEL_SUCCESS 99
++#define SSH_MSG_CHANNEL_FAILURE 100
++
++void libssh2_session_shutdown(LIBSSH2_SESSION * session);
++
++unsigned long libssh2_ntohu32(const unsigned char *buf);
++libssh2_uint64_t libssh2_ntohu64(const unsigned char *buf);
++void libssh2_htonu32(unsigned char *buf, unsigned long val);
++void libssh2_htonu64(unsigned char *buf, libssh2_uint64_t val);
++
++#define LIBSSH2_READ_TIMEOUT 60 /* generic timeout in seconds used when
++ waiting for more data to arrive */
++int libssh2_waitsocket(LIBSSH2_SESSION * session, long seconds);
++
++
++/* CAUTION: some of these error codes are returned in the public API and is
++ there known with other #defined names from the public header file. They
++ should not be changed. */
++
++#define PACKET_TIMEOUT -7
++#define PACKET_BADUSE -6
++#define PACKET_COMPRESS -5
++#define PACKET_TOOBIG -4
++#define PACKET_ENOMEM -3
++#define PACKET_EAGAIN LIBSSH2_ERROR_EAGAIN
++#define PACKET_FAIL -1
++#define PACKET_NONE 0
++
++libssh2pack_t libssh2_packet_read(LIBSSH2_SESSION * session);
++
++int libssh2_packet_ask_ex(LIBSSH2_SESSION * session, unsigned char packet_type,
++ unsigned char **data, unsigned long *data_len,
++ unsigned long match_ofs,
++ const unsigned char *match_buf,
++ unsigned long match_len, int poll_socket);
++
++int libssh2_packet_askv_ex(LIBSSH2_SESSION * session,
++ const unsigned char *packet_types,
++ unsigned char **data, unsigned long *data_len,
++ unsigned long match_ofs,
++ const unsigned char *match_buf,
++ unsigned long match_len, int poll_socket);
++int libssh2_packet_require_ex(LIBSSH2_SESSION * session,
++ unsigned char packet_type, unsigned char **data,
++ unsigned long *data_len, unsigned long match_ofs,
++ const unsigned char *match_buf,
++ unsigned long match_len,
++ packet_require_state_t * state);
++int libssh2_packet_requirev_ex(LIBSSH2_SESSION * session,
++ const unsigned char *packet_types,
++ unsigned char **data, unsigned long *data_len,
++ unsigned long match_ofs,
++ const unsigned char *match_buf,
++ unsigned long match_len,
++ packet_requirev_state_t * state);
++int libssh2_packet_burn(LIBSSH2_SESSION * session,
++ libssh2_nonblocking_states * state);
++int libssh2_packet_write(LIBSSH2_SESSION * session, unsigned char *data,
++ unsigned long data_len);
++int libssh2_packet_add(LIBSSH2_SESSION * session, unsigned char *data,
++ size_t datalen, int macstate);
++int libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange,
++ key_exchange_state_t * state);
++unsigned long libssh2_channel_nextid(LIBSSH2_SESSION * session);
++LIBSSH2_CHANNEL *libssh2_channel_locate(LIBSSH2_SESSION * session,
++ unsigned long channel_id);
++unsigned long libssh2_channel_packet_data_len(LIBSSH2_CHANNEL * channel,
++ int stream_id);
++
++/* this is the lib-internal set blocking function */
++int _libssh2_session_set_blocking(LIBSSH2_SESSION * session, int blocking);
++
++/* Let crypt.c/hostkey.c/comp.c/mac.c expose their method structs */
++const LIBSSH2_CRYPT_METHOD **libssh2_crypt_methods(void);
++const LIBSSH2_HOSTKEY_METHOD **libssh2_hostkey_methods(void);
++const LIBSSH2_COMP_METHOD **libssh2_comp_methods(void);
++const LIBSSH2_MAC_METHOD **libssh2_mac_methods(void);
++
++/* Language API doesn't exist yet. Just act like we've agreed on a language */
++#define libssh2_kex_agree_lang(session, endpoint, str, str_len) 0
++
++/* pem.c */
++int _libssh2_pem_parse(LIBSSH2_SESSION * session,
++ const char *headerbegin,
++ const char *headerend,
++ FILE * fp, unsigned char **data, unsigned int *datalen);
++int _libssh2_pem_decode_sequence(unsigned char **data, unsigned int *datalen);
++int _libssh2_pem_decode_integer(unsigned char **data, unsigned int *datalen,
++ unsigned char **i, unsigned int *ilen);
++
++#endif /* LIBSSH2_H */
+
+Property changes on: libssh2/src/libssh2_priv.h
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.1
+Added: svn:eol-style
+ + native
+Added: svn:executable
+ + *
+
+Index: libssh2/src/sftp.c
+===================================================================
+--- libssh2/src/sftp.c (.../tags/RELEASE_0_11_0)
++++ libssh2/src/sftp.c (.../trunk)
+@@ -0,0 +1,2358 @@
++/* Copyright (c) 2004-2008, Sara Golemon <sarag@libssh2.org>
++ * 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
++
++/* {{{ sftp_packet_add
++ * Add a packet to the SFTP packet brigade
++ */
++static int
++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 (len %d)",
++ (int) data[0], data_len);
++ 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;
++}
++
++/* }}} */
++
++/* {{{ sftp_packet_read
++ * Frame an SFTP packet off the channel
++ */
++static int
++sftp_packet_read(LIBSSH2_SFTP * sftp)
++{
++ 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 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;
++
++ _libssh2_debug(session, LIBSSH2_DBG_SFTP,
++ "partial read cont, len: %lu", packet_len);
++ }
++ else {
++ rc = libssh2_channel_read_ex(channel, 0, (char *) buffer, 4);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ }
++ else if (4 != rc) {
++ /* TODO: this is stupid since we can in fact get 1-3 bytes in a
++ legitimate working case as well if the connection happens to be
++ super slow or something */
++ 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 (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 (sftp_packet_add(sftp, packet, packet_len)) {
++ LIBSSH2_FREE(session, packet);
++ return -1;
++ }
++
++ return packet[0];
++}
++
++/* }}} */
++
++/* {{{ sftp_packet_ask
++ * A la libssh2_packet_ask()
++ */
++static int
++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 = sftp_packet_read(sftp);
++ 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;
++}
++
++/* }}} */
++
++/* {{{ sftp_packet_require
++ * A la libssh2_packet_require
++ */
++static int
++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 (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 = sftp_packet_read(sftp);
++ 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 sftp_packet_ask(sftp, packet_type, request_id, data,
++ data_len, 0);
++ }
++ }
++
++ /* Only reached if the socket died */
++ return -1;
++}
++
++/* }}} */
++
++/* {{{ sftp_packet_requirev
++ * Require one of N possible reponses
++ */
++static int
++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 */
++ 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) == 0) {
++ /*
++ * Set to zero before all returns to say
++ * the timeout is not active
++ */
++ sftp->requirev_start = 0;
++ return 0;
++ }
++ }
++
++ ret = sftp_packet_read(sftp);
++ 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 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 = 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->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) {
++ /* TODO: partial writes should be fine too and is not a sign of
++ an error when in non-blocking mode! */
++
++ 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 = 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;
++
++ /* OPEN can basically get STATUS or HANDLE back, where HANDLE implies a
++ fine response while STATUS means error. It seems though that at times
++ we get an SSH_FX_OK back in a STATUS, followed the "real" HANDLE so
++ we need to properly deal with that. */
++ if (data[0] == SSH_FXP_STATUS) {
++ int badness = 1;
++ sftp->last_errno = libssh2_ntohu32(data + 5);
++
++ if(LIBSSH2_FX_OK == sftp->last_errno) {
++ _libssh2_debug(session, LIBSSH2_DBG_SFTP, "got HANDLE FXOK!");
++
++ /* silly situation, but check for a HANDLE */
++ rc = sftp_packet_require(sftp, SSH_FXP_HANDLE,
++ sftp->open_request_id, &data, &data_len);
++ if(rc == PACKET_EAGAIN) {
++ /* go back to sent state and wait for something else */
++ sftp->open_state = libssh2_NB_state_sent;
++ return NULL;
++ }
++ else if(!rc)
++ /* we got the handle so this is not a bad situation */
++ badness = 0;
++ }
++
++ if(badness) {
++ libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL,
++ "Failed opening remote file", 0);
++ _libssh2_debug(session, LIBSSH2_DBG_SFTP, "got FXP_STATUS %d",
++ sftp->last_errno);
++ 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 > SFTP_HANDLE_MAXLEN) {
++ /* SFTP doesn't allow handles longer than 256 characters */
++ fp->handle_len = SFTP_HANDLE_MAXLEN;
++ }
++
++ 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 = 0;
++ /* 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 = handle->request_packet;
++ 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)
++
++ 10 is changed to 13 below simple because it seems there's a
++ "GlobalScape" SFTP server that responds with a slightly too big
++ buffer at times and we can apparently compensate for that by doing
++ this trick.
++
++ Further details on this issue:
++
++ https://sourceforge.net/mailarchive/forum.php?thread_name=9c3275a90811261517v6c0b1da2u918cc1b8370abf83%40mail.gmail.com&forum_name=libssh2-devel
++
++ http://forums.globalscape.com/tm.aspx?m=15249
++
++ */
++ if (bytes_requested > LIBSSH2_SFTP_PACKET_MAXLEN - 13) {
++ bytes_requested = LIBSSH2_SFTP_PACKET_MAXLEN - 13;
++ }
++#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, bytes_requested);
++ 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) {
++ /* TODO: a partial write is not a critical error when in
++ non-blocking mode! */
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send FXP_READ command", 0);
++ 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 =
++ 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);
++ 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, 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)) {
++ 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;
++ }
++ }
++
++ 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 =
++ 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 = 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 ? "Unable to send FXP_FSETSTAT"
++ : "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 = 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_seek64
++ * Set the read/write pointer to an arbitrary position within the file
++ */
++LIBSSH2_API void
++libssh2_sftp_seek64(LIBSSH2_SFTP_HANDLE * handle, libssh2_uint64_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_tell64
++ * Return the current read/write pointer's offset
++ */
++LIBSSH2_API libssh2_uint64_t
++libssh2_sftp_tell64(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 = 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);
++
++ 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 = 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 = 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 = 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 = 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 = 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 = 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;
++}
++
++/* }}} */
+
+Property changes on: libssh2/src/sftp.c
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.2
+Added: svn:eol-style
+ + native
+
+Index: libssh2/src/libssh2_config.h.in.w32
+===================================================================
+--- libssh2/src/libssh2_config.h.in.w32 (.../tags/RELEASE_0_11_0)
++++ libssh2/src/libssh2_config.h.in.w32 (.../trunk)
+@@ -0,0 +1,44 @@
++#ifndef LIBSSH2_CONFIG_H
++#define LIBSSH2_CONFIG_H
++
++#ifndef WIN32
++#define WIN32
++#endif
++#include <winsock2.h>
++#include <mswsock.h>
++#include <ws2tcpip.h>
++
++#ifdef __MINGW32__
++#define HAVE_UNISTD_H
++#define HAVE_INTTYPES_H
++#define HAVE_SYS_TIME_H
++#endif
++
++#define HAVE_WINSOCK2_H
++#define HAVE_IOCTLSOCKET
++#define HAVE_SELECT
++
++#ifdef _MSC_VER
++#define snprintf _snprintf
++#if _MSC_VER < 1500
++#define vsnprintf _vsnprintf
++#else
++#define ssize_t SSIZE_T
++#define uint32_t UINT32
++#endif
++#define strncasecmp _strnicmp
++#define strcasecmp _stricmp
++#else
++#define strncasecmp strnicmp
++#define strcasecmp stricmp
++#endif /* _MSC_VER */
++
++/* Compile in zlib support */
++#define LIBSSH2_HAVE_ZLIB 1
++
++/* Enable newer diffie-hellman-group-exchange-sha1 syntax */
++#define LIBSSH2_DH_GEX_NEW 1
++
++#endif /* LIBSSH2_CONFIG_H */
++
++
+
+Property changes on: libssh2/src/libssh2_config.h.in.w32
+___________________________________________________________________
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.1
+Added: svn:eol-style
+ + native
+Added: svn:executable
+ + *
+
+Index: libssh2/src/pem.c
+===================================================================
+--- libssh2/src/pem.c (.../tags/RELEASE_0_11_0)
++++ libssh2/src/pem.c (.../trunk)
+@@ -0,0 +1,209 @@
++/* Copyright (C) 2007 The Written Word, Inc.
++ * Copyright (C) 2008, Simon Josefsson
++ * 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"
++
++static int
++readline(char *line, int line_size, FILE * fp)
++{
++ if (!fgets(line, line_size, fp)) {
++ return -1;
++ }
++ if (*line && line[strlen(line) - 1] == '\n') {
++ line[strlen(line) - 1] = '\0';
++ }
++ if (*line && line[strlen(line) - 1] == '\r') {
++ line[strlen(line) - 1] = '\0';
++ }
++ return 0;
++}
++
++#define LINE_SIZE 128
++
++int
++_libssh2_pem_parse(LIBSSH2_SESSION * session,
++ const char *headerbegin,
++ const char *headerend,
++ FILE * fp, unsigned char **data, unsigned int *datalen)
++{
++ char line[LINE_SIZE];
++ char *b64data = NULL;
++ unsigned int b64datalen = 0;
++ int ret;
++
++ do {
++ if (readline(line, LINE_SIZE, fp)) {
++ return -1;
++ }
++ }
++ while (strcmp(line, headerbegin) != 0);
++
++ *line = '\0';
++
++ do {
++ if (*line) {
++ char *tmp;
++ size_t linelen;
++
++ linelen = strlen(line);
++ tmp = LIBSSH2_REALLOC(session, b64data, b64datalen + linelen);
++ if (!tmp) {
++ ret = -1;
++ goto out;
++ }
++ memcpy(tmp + b64datalen, line, linelen);
++ b64data = tmp;
++ b64datalen += linelen;
++ }
++
++ if (readline(line, LINE_SIZE, fp)) {
++ ret = -1;
++ goto out;
++ }
++ } while (strcmp(line, headerend) != 0);
++
++ if (libssh2_base64_decode(session, (char**) data, datalen,
++ b64data, b64datalen)) {
++ ret = -1;
++ goto out;
++ }
++
++ ret = 0;
++ out:
++ if (b64data) {
++ LIBSSH2_FREE(session, b64data);
++ }
++ return ret;
++}
++
++static int
++read_asn1_length(const unsigned char *data,
++ unsigned int datalen, unsigned int *len)
++{
++ unsigned int lenlen;
++ int nextpos;
++
++ if (datalen < 1) {
++ return -1;
++ }
++ *len = data[0];
++
++ if (*len >= 0x80) {
++ lenlen = *len & 0x7F;
++ *len = data[1];
++ if (1 + lenlen > datalen) {
++ return -1;
++ }
++ if (lenlen > 1) {
++ *len <<= 8;
++ *len |= data[2];
++ }
++ } else {
++ lenlen = 0;
++ }
++
++ nextpos = 1 + lenlen;
++ if (lenlen > 2 || 1 + lenlen + *len > datalen) {
++ return -1;
++ }
++
++ return nextpos;
++}
++
++int
++_libssh2_pem_decode_sequence(unsigned char **data, unsigned int *datalen)
++{
++ unsigned int len;
++ int lenlen;
++
++ if (*datalen < 1) {
++ return -1;
++ }
++
++ if ((*data)[0] != '\x30') {
++ return -1;
++ }
++
++ (*data)++;
++ (*datalen)--;
++
++ lenlen = read_asn1_length(*data, *datalen, &len);
++ if (lenlen < 0 || lenlen + len != *datalen) {
++ return -1;
++ }
++
++ *data += lenlen;
++ *datalen -= lenlen;
++
++ return 0;
++}
++
++int
++_libssh2_pem_decode_integer(unsigned char **data, unsigned int *datalen,
++ unsigned char **i, unsigned int *ilen)
++{
++ unsigned int len;
++ int lenlen;
++
++ if (*datalen < 1) {
++ return -1;
++ }
++
++ if ((*data)[0] != '\x02') {
++ return -1;
++ }
++
++ (*data)++;
++ (*datalen)--;
++
++ lenlen = read_asn1_length(*data, *datalen, &len);
++ if (lenlen < 0 || lenlen + len > *datalen) {
++ return -1;
++ }
++
++ *data += lenlen;
++ *datalen -= lenlen;
++
++ *i = *data;
++ *ilen = len;
++
++ *data += len;
++ *datalen -= len;
++
++ return 0;
++}
+
+Property changes on: libssh2/src/pem.c
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.1
+Added: svn:eol-style
+ + native
+Added: svn:executable
+ + *
+
+Index: libssh2/src/session.c
+===================================================================
+--- libssh2/src/session.c (.../tags/RELEASE_0_11_0)
++++ libssh2/src/session.c (.../trunk)
+@@ -0,0 +1,1554 @@
++/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
++ * 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 <errno.h>
++#ifdef HAVE_UNISTD_H
++#include <unistd.h>
++#endif
++#include <stdlib.h>
++#include <fcntl.h>
++
++#ifdef HAVE_GETTIMEOFDAY
++#include <sys/time.h>
++#endif
++#ifdef HAVE_ALLOCA_H
++#include <alloca.h>
++#endif
++
++/* {{{ libssh2_default_alloc
++ */
++static
++LIBSSH2_ALLOC_FUNC(libssh2_default_alloc)
++{
++ (void) abstract;
++ return malloc(count);
++}
++
++/* }}} */
++
++/* {{{ libssh2_default_free
++ */
++static
++LIBSSH2_FREE_FUNC(libssh2_default_free)
++{
++ (void) abstract;
++ free(ptr);
++}
++
++/* }}} */
++
++/* {{{ libssh2_default_realloc
++ */
++static
++LIBSSH2_REALLOC_FUNC(libssh2_default_realloc)
++{
++ (void) abstract;
++ return realloc(ptr, count);
++}
++
++/* }}} */
++
++/* {{{ libssh2_banner_receive
++ * Wait for a hello from the remote host
++ * Allocate a buffer and store the banner in session->remote.banner
++ * Returns: 0 on success, PACKET_EAGAIN if read would block, 1 on failure
++ */
++static int
++libssh2_banner_receive(LIBSSH2_SESSION * session)
++{
++ int ret;
++ int banner_len;
++
++ if (session->banner_TxRx_state == libssh2_NB_state_idle) {
++ banner_len = 0;
++
++ session->banner_TxRx_state = libssh2_NB_state_created;
++ } else {
++ banner_len = session->banner_TxRx_total_send;
++ }
++
++ while ((banner_len < (int) sizeof(session->banner_TxRx_banner)) &&
++ ((banner_len == 0)
++ || (session->banner_TxRx_banner[banner_len - 1] != '\n'))) {
++ char c = '\0';
++
++ ret =
++ recv(session->socket_fd, &c, 1,
++ LIBSSH2_SOCKET_RECV_FLAGS(session));
++
++ if (ret < 0) {
++#ifdef WIN32
++ switch (WSAGetLastError()) {
++ case WSAEWOULDBLOCK:
++ errno = EAGAIN;
++ break;
++
++ case WSAENOTSOCK:
++ errno = EBADF;
++ break;
++
++ case WSAENOTCONN:
++ case WSAECONNABORTED:
++ errno = WSAENOTCONN;
++ break;
++
++ case WSAEINTR:
++ errno = EINTR;
++ break;
++ }
++#endif /* WIN32 */
++ if (errno == EAGAIN) {
++ session->socket_block_directions =
++ LIBSSH2_SESSION_BLOCK_INBOUND;
++ session->banner_TxRx_total_send = banner_len;
++ return PACKET_EAGAIN;
++ }
++
++ /* Some kinda error */
++ session->banner_TxRx_state = libssh2_NB_state_idle;
++ session->banner_TxRx_total_send = 0;
++ return 1;
++ }
++
++ if (ret == 0) {
++ session->socket_state = LIBSSH2_SOCKET_DISCONNECTED;
++ return PACKET_FAIL;
++ }
++
++ if (c == '\0') {
++ /* NULLs are not allowed in SSH banners */
++ session->banner_TxRx_state = libssh2_NB_state_idle;
++ session->banner_TxRx_total_send = 0;
++ return 1;
++ }
++
++ session->banner_TxRx_banner[banner_len++] = c;
++ }
++
++ while (banner_len &&
++ ((session->banner_TxRx_banner[banner_len - 1] == '\n') ||
++ (session->banner_TxRx_banner[banner_len - 1] == '\r'))) {
++ banner_len--;
++ }
++
++ /* From this point on, we are done here */
++ session->banner_TxRx_state = libssh2_NB_state_idle;
++ session->banner_TxRx_total_send = 0;
++
++ if (!banner_len)
++ return 1;
++
++ session->remote.banner = LIBSSH2_ALLOC(session, banner_len + 1);
++ if (!session->remote.banner) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Error allocating space for remote banner", 0);
++ return 1;
++ }
++ memcpy(session->remote.banner, session->banner_TxRx_banner, banner_len);
++ session->remote.banner[banner_len] = '\0';
++ _libssh2_debug(session, LIBSSH2_DBG_TRANS, "Received Banner: %s",
++ session->remote.banner);
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_banner_send
++ * Send the default banner, or the one set via libssh2_setopt_string
++ *
++ * Returns PACKET_EAGAIN if it would block - and if it does so, you should
++ * call this function again as soon as it is likely that more data can be
++ * sent, and this function should then be called with the same argument set
++ * (same data pointer and same data_len) until zero or failure is returned.
++ */
++static int
++libssh2_banner_send(LIBSSH2_SESSION * session)
++{
++ char *banner = (char *) LIBSSH2_SSH_DEFAULT_BANNER_WITH_CRLF;
++ int banner_len = sizeof(LIBSSH2_SSH_DEFAULT_BANNER_WITH_CRLF) - 1;
++ ssize_t ret;
++#ifdef LIBSSH2DEBUG
++ char banner_dup[256];
++#endif
++
++ if (session->banner_TxRx_state == libssh2_NB_state_idle) {
++ if (session->local.banner) {
++ /* setopt_string will have given us our \r\n characters */
++ banner_len = strlen((char *) session->local.banner);
++ banner = (char *) session->local.banner;
++ }
++#ifdef LIBSSH2DEBUG
++ /* Hack and slash to avoid sending CRLF in debug output */
++ if (banner_len < 256) {
++ memcpy(banner_dup, banner, banner_len - 2);
++ banner_dup[banner_len - 2] = '\0';
++ } else {
++ memcpy(banner_dup, banner, 255);
++ banner[255] = '\0';
++ }
++
++ _libssh2_debug(session, LIBSSH2_DBG_TRANS, "Sending Banner: %s",
++ banner_dup);
++#endif
++
++ session->banner_TxRx_state = libssh2_NB_state_created;
++ }
++
++ ret =
++ send(session->socket_fd, banner + session->banner_TxRx_total_send,
++ banner_len - session->banner_TxRx_total_send,
++ LIBSSH2_SOCKET_SEND_FLAGS(session));
++
++ if (ret != (banner_len - session->banner_TxRx_total_send)) {
++ if ((ret > 0) || ((ret == -1) && (errno == EAGAIN))) {
++ /* the whole packet could not be sent, save the what was */
++ session->socket_block_directions =
++ LIBSSH2_SESSION_BLOCK_OUTBOUND;
++ session->banner_TxRx_total_send += ret;
++ return PACKET_EAGAIN;
++ }
++ session->banner_TxRx_state = libssh2_NB_state_idle;
++ session->banner_TxRx_total_send = 0;
++ return PACKET_FAIL;
++ }
++
++ /* Set the state back to idle */
++ session->banner_TxRx_state = libssh2_NB_state_idle;
++ session->banner_TxRx_total_send = 0;
++
++ return 0;
++}
++
++/* }}} */
++
++/*
++ * _libssh2_nonblock() sets the given socket to either blocking or
++ * non-blocking mode based on the 'nonblock' boolean argument. This function
++ * is copied from the libcurl sources with permission.
++ */
++static int
++_libssh2_nonblock(int sockfd, /* operate on this */
++ int nonblock /* TRUE or FALSE */ )
++{
++#undef SETBLOCK
++#define SETBLOCK 0
++#ifdef HAVE_O_NONBLOCK
++ /* most recent unix versions */
++ int flags;
++
++ flags = fcntl(sockfd, F_GETFL, 0);
++ if (nonblock)
++ return fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
++ else
++ return fcntl(sockfd, F_SETFL, flags & (~O_NONBLOCK));
++#undef SETBLOCK
++#define SETBLOCK 1
++#endif
++
++#if defined(HAVE_FIONBIO) && (SETBLOCK == 0)
++ /* older unix versions */
++ int flags;
++
++ flags = nonblock;
++ return ioctl(sockfd, FIONBIO, &flags);
++#undef SETBLOCK
++#define SETBLOCK 2
++#endif
++
++#if defined(HAVE_IOCTLSOCKET) && (SETBLOCK == 0)
++ /* Windows? */
++ unsigned long flags;
++ flags = nonblock;
++
++ return ioctlsocket(sockfd, FIONBIO, &flags);
++#undef SETBLOCK
++#define SETBLOCK 3
++#endif
++
++#if defined(HAVE_IOCTLSOCKET_CASE) && (SETBLOCK == 0)
++ /* presumably for Amiga */
++ return IoctlSocket(sockfd, FIONBIO, (long) nonblock);
++#undef SETBLOCK
++#define SETBLOCK 4
++#endif
++
++#if defined(HAVE_SO_NONBLOCK) && (SETBLOCK == 0)
++ /* BeOS */
++ long b = nonblock ? 1 : 0;
++ return setsockopt(sockfd, SOL_SOCKET, SO_NONBLOCK, &b, sizeof(b));
++#undef SETBLOCK
++#define SETBLOCK 5
++#endif
++
++#ifdef HAVE_DISABLED_NONBLOCKING
++ return 0; /* returns success */
++#undef SETBLOCK
++#define SETBLOCK 6
++#endif
++
++#if (SETBLOCK == 0)
++#error "no non-blocking method was found/used/set"
++#endif
++}
++
++/*
++ * _libssh2_get_socket_nonblocking() gets the given blocking or non-blocking
++ * state of the socket.
++ */
++static int
++_libssh2_get_socket_nonblocking(int sockfd)
++{ /* operate on this */
++#undef GETBLOCK
++#define GETBLOCK 0
++#ifdef HAVE_O_NONBLOCK
++ /* most recent unix versions */
++ int flags;
++
++ if ((flags = fcntl(sockfd, F_GETFL, 0)) == -1) {
++ /* Assume blocking on error */
++ return 1;
++ }
++ return (flags & O_NONBLOCK);
++#undef GETBLOCK
++#define GETBLOCK 1
++#endif
++
++#if defined(WSAEWOULDBLOCK) && (GETBLOCK == 0)
++ /* Windows? */
++ unsigned int option_value;
++ socklen_t option_len = sizeof(option_value);
++
++ if (getsockopt
++ (sockfd, SOL_SOCKET, SO_ERROR, (void *) &option_value, &option_len)) {
++ /* Assume blocking on error */
++ return 1;
++ }
++ return (int) option_value;
++#undef GETBLOCK
++#define GETBLOCK 2
++#endif
++
++#if defined(HAVE_SO_NONBLOCK) && (GETBLOCK == 0)
++ /* BeOS */
++ long b;
++ if (getsockopt(sockfd, SOL_SOCKET, SO_NONBLOCK, &b, sizeof(b))) {
++ /* Assume blocking on error */
++ return 1;
++ }
++ return (int) b;
++#undef GETBLOCK
++#define GETBLOCK 5
++#endif
++
++#ifdef HAVE_DISABLED_NONBLOCKING
++ return 1; /* returns blocking */
++#undef GETBLOCK
++#define GETBLOCK 6
++#endif
++
++#if (GETBLOCK == 0)
++#error "no non-blocking method was found/used/get"
++#endif
++}
++
++/* {{{ libssh2_banner_set
++ * Set the local banner
++ */
++LIBSSH2_API int
++libssh2_banner_set(LIBSSH2_SESSION * session, const char *banner)
++{
++ int banner_len = banner ? strlen(banner) : 0;
++
++ if (session->local.banner) {
++ LIBSSH2_FREE(session, session->local.banner);
++ session->local.banner = NULL;
++ }
++
++ if (!banner_len) {
++ return 0;
++ }
++
++ session->local.banner = LIBSSH2_ALLOC(session, banner_len + 3);
++ if (!session->local.banner) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for local banner", 0);
++ return -1;
++ }
++
++ memcpy(session->local.banner, banner, banner_len);
++ session->local.banner[banner_len] = '\0';
++ _libssh2_debug(session, LIBSSH2_DBG_TRANS, "Setting local Banner: %s",
++ session->local.banner);
++ session->local.banner[banner_len++] = '\r';
++ session->local.banner[banner_len++] = '\n';
++ session->local.banner[banner_len++] = '\0';
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ proto libssh2_session_init
++ * Allocate and initialize a libssh2 session structure
++ * Allows for malloc callbacks in case the calling program has its own memory manager
++ * It's allowable (but unadvisable) to define some but not all of the malloc callbacks
++ * An additional pointer value may be optionally passed to be sent to the callbacks (so they know who's asking)
++ */
++LIBSSH2_API LIBSSH2_SESSION *
++libssh2_session_init_ex(LIBSSH2_ALLOC_FUNC((*my_alloc)),
++ LIBSSH2_FREE_FUNC((*my_free)),
++ LIBSSH2_REALLOC_FUNC((*my_realloc)), void *abstract)
++{
++ LIBSSH2_ALLOC_FUNC((*local_alloc)) = libssh2_default_alloc;
++ LIBSSH2_FREE_FUNC((*local_free)) = libssh2_default_free;
++ LIBSSH2_REALLOC_FUNC((*local_realloc)) = libssh2_default_realloc;
++ LIBSSH2_SESSION *session;
++
++ if (my_alloc) {
++ local_alloc = my_alloc;
++ }
++ if (my_free) {
++ local_free = my_free;
++ }
++ if (my_realloc) {
++ local_realloc = my_realloc;
++ }
++
++ session = local_alloc(sizeof(LIBSSH2_SESSION), abstract);
++ if (session) {
++ memset(session, 0, sizeof(LIBSSH2_SESSION));
++ session->alloc = local_alloc;
++ session->free = local_free;
++ session->realloc = local_realloc;
++ session->abstract = abstract;
++ _libssh2_debug(session, LIBSSH2_DBG_TRANS,
++ "New session resource allocated");
++ libssh2_crypto_init();
++ }
++ return session;
++}
++
++/* }}} */
++
++/* {{{ libssh2_session_callback_set
++ * Set (or reset) a callback function
++ * Returns the prior address
++ *
++ * FIXME: this function relies on that we can typecast function pointers
++ * to void pointers, which isn't allowed in ISO C!
++ */
++LIBSSH2_API void *
++libssh2_session_callback_set(LIBSSH2_SESSION * session,
++ int cbtype, void *callback)
++{
++ void *oldcb;
++
++ switch (cbtype) {
++ case LIBSSH2_CALLBACK_IGNORE:
++ oldcb = session->ssh_msg_ignore;
++ session->ssh_msg_ignore = callback;
++ return oldcb;
++
++ case LIBSSH2_CALLBACK_DEBUG:
++ oldcb = session->ssh_msg_debug;
++ session->ssh_msg_debug = callback;
++ return oldcb;
++
++ case LIBSSH2_CALLBACK_DISCONNECT:
++ oldcb = session->ssh_msg_disconnect;
++ session->ssh_msg_disconnect = callback;
++ return oldcb;
++
++ case LIBSSH2_CALLBACK_MACERROR:
++ oldcb = session->macerror;
++ session->macerror = callback;
++ return oldcb;
++
++ case LIBSSH2_CALLBACK_X11:
++ oldcb = session->x11;
++ session->x11 = callback;
++ return oldcb;
++
++ }
++ _libssh2_debug(session, LIBSSH2_DBG_TRANS, "Setting Callback %d", cbtype);
++
++ return NULL;
++}
++
++/* }}} */
++
++/* {{{ proto libssh2_session_startup
++ * session: LIBSSH2_SESSION struct allocated and owned by the calling program
++ * Returns: 0 on success, or non-zero on failure
++ * Any memory allocated by libssh2 will use alloc/realloc/free
++ * callbacks in session
++ * socket *must* be populated with an opened and connected socket.
++ */
++LIBSSH2_API int
++libssh2_session_startup(LIBSSH2_SESSION * session, int sock)
++{
++ int rc;
++
++ if (session->startup_state == libssh2_NB_state_idle) {
++ _libssh2_debug(session, LIBSSH2_DBG_TRANS,
++ "session_startup for socket %d", sock);
++ /* FIXME: on some platforms (like win32) sockets are unsigned */
++ if (sock < 0) {
++ /* Did we forget something? */
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_NONE,
++ "Bad socket provided", 0);
++ return LIBSSH2_ERROR_SOCKET_NONE;
++ }
++ session->socket_fd = sock;
++
++ session->socket_block =
++ !_libssh2_get_socket_nonblocking(session->socket_fd);
++ if (session->socket_block) {
++ /*
++ * Since we can't be sure that we are in blocking or there
++ * was an error detecting the state, so set to blocking to
++ * be sure
++ */
++ _libssh2_nonblock(session->socket_fd, 0);
++ }
++
++ session->startup_state = libssh2_NB_state_created;
++ }
++
++ /* TODO: Liveness check */
++
++ if (session->startup_state == libssh2_NB_state_created) {
++ rc = libssh2_banner_send(session);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block sending banner to remote host", 0);
++ return LIBSSH2_ERROR_EAGAIN;
++ } else if (rc) {
++ /* Unable to send banner? */
++ libssh2_error(session, LIBSSH2_ERROR_BANNER_SEND,
++ "Error sending banner to remote host", 0);
++ return LIBSSH2_ERROR_BANNER_SEND;
++ }
++
++ session->startup_state = libssh2_NB_state_sent;
++ }
++
++ if (session->startup_state == libssh2_NB_state_sent) {
++ rc = libssh2_banner_receive(session);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block waiting for banner", 0);
++ return LIBSSH2_ERROR_EAGAIN;
++ } else if (rc) {
++ /* Unable to receive banner from remote */
++ libssh2_error(session, LIBSSH2_ERROR_BANNER_NONE,
++ "Timeout waiting for banner", 0);
++ return LIBSSH2_ERROR_BANNER_NONE;
++ }
++
++ session->startup_state = libssh2_NB_state_sent1;
++ }
++
++ if (session->startup_state == libssh2_NB_state_sent1) {
++ rc = libssh2_kex_exchange(session, 0, &session->startup_key_state);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block exchanging encryption keys", 0);
++ return LIBSSH2_ERROR_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_KEX_FAILURE,
++ "Unable to exchange encryption keys", 0);
++ return LIBSSH2_ERROR_KEX_FAILURE;
++ }
++
++ session->startup_state = libssh2_NB_state_sent2;
++ }
++
++ if (session->startup_state == libssh2_NB_state_sent2) {
++ _libssh2_debug(session, LIBSSH2_DBG_TRANS,
++ "Requesting userauth service");
++
++ /* Request the userauth service */
++ session->startup_service[0] = SSH_MSG_SERVICE_REQUEST;
++ libssh2_htonu32(session->startup_service + 1,
++ sizeof("ssh-userauth") - 1);
++ memcpy(session->startup_service + 5, "ssh-userauth",
++ sizeof("ssh-userauth") - 1);
++
++ session->startup_state = libssh2_NB_state_sent3;
++ }
++
++ if (session->startup_state == libssh2_NB_state_sent3) {
++ rc = libssh2_packet_write(session, session->startup_service,
++ sizeof("ssh-userauth") + 5 - 1);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block asking for ssh-userauth service", 0);
++ return LIBSSH2_ERROR_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to ask for ssh-userauth service", 0);
++ return LIBSSH2_ERROR_SOCKET_SEND;
++ }
++
++ session->startup_state = libssh2_NB_state_sent4;
++ }
++
++ if (session->startup_state == libssh2_NB_state_sent4) {
++ rc = libssh2_packet_require_ex(session, SSH_MSG_SERVICE_ACCEPT,
++ &session->startup_data,
++ &session->startup_data_len, 0, NULL, 0,
++ &session->startup_req_state);
++ if (rc == PACKET_EAGAIN) {
++ return LIBSSH2_ERROR_EAGAIN;
++ } else if (rc) {
++ return LIBSSH2_ERROR_SOCKET_DISCONNECT;
++ }
++ session->startup_service_length =
++ libssh2_ntohu32(session->startup_data + 1);
++
++ if ((session->startup_service_length != (sizeof("ssh-userauth") - 1))
++ || strncmp("ssh-userauth", (char *) session->startup_data + 5,
++ session->startup_service_length)) {
++ LIBSSH2_FREE(session, session->startup_data);
++ session->startup_data = NULL;
++ libssh2_error(session, LIBSSH2_ERROR_PROTO,
++ "Invalid response received from server", 0);
++ return LIBSSH2_ERROR_PROTO;
++ }
++ LIBSSH2_FREE(session, session->startup_data);
++ session->startup_data = NULL;
++
++ session->startup_state = libssh2_NB_state_idle;
++
++ return 0;
++ }
++
++ /* just for safety return some error */
++ return LIBSSH2_ERROR_INVAL;
++}
++
++/* }}} */
++
++/* {{{ proto libssh2_session_free
++ * Frees the memory allocated to the session
++ * Also closes and frees any channels attached to this session
++ */
++LIBSSH2_API int
++libssh2_session_free(LIBSSH2_SESSION * session)
++{
++ int rc;
++
++ if (session->free_state == libssh2_NB_state_idle) {
++ _libssh2_debug(session, LIBSSH2_DBG_TRANS, "Freeing session resource",
++ session->remote.banner);
++
++ session->state = libssh2_NB_state_created;
++ }
++
++ if (session->free_state == libssh2_NB_state_created) {
++ while (session->channels.head) {
++ LIBSSH2_CHANNEL *tmp = session->channels.head;
++
++ rc = libssh2_channel_free(session->channels.head);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ }
++ if (tmp == session->channels.head) {
++ /* channel_free couldn't do it's job, perform a messy cleanup */
++ tmp = session->channels.head;
++
++ /* unlink */
++ session->channels.head = tmp->next;
++
++ /* free */
++ LIBSSH2_FREE(session, tmp);
++
++ /* reverse linking isn't important here, we're killing the structure */
++ }
++ }
++
++ session->state = libssh2_NB_state_sent;
++ }
++
++ if (session->state == libssh2_NB_state_sent) {
++ while (session->listeners) {
++ rc = libssh2_channel_forward_cancel(session->listeners);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ }
++ }
++
++ session->state = libssh2_NB_state_sent1;
++ }
++
++ if (session->state & LIBSSH2_STATE_NEWKEYS) {
++ /* hostkey */
++ if (session->hostkey && session->hostkey->dtor) {
++ session->hostkey->dtor(session, &session->server_hostkey_abstract);
++ }
++
++ /* Client to Server */
++ /* crypt */
++ if (session->local.crypt && session->local.crypt->dtor) {
++ session->local.crypt->dtor(session,
++ &session->local.crypt_abstract);
++ }
++ /* comp */
++ if (session->local.comp && session->local.comp->dtor) {
++ session->local.comp->dtor(session, 1,
++ &session->local.comp_abstract);
++ }
++ /* mac */
++ if (session->local.mac && session->local.mac->dtor) {
++ session->local.mac->dtor(session, &session->local.mac_abstract);
++ }
++
++ /* Server to Client */
++ /* crypt */
++ if (session->remote.crypt && session->remote.crypt->dtor) {
++ session->remote.crypt->dtor(session,
++ &session->remote.crypt_abstract);
++ }
++ /* comp */
++ if (session->remote.comp && session->remote.comp->dtor) {
++ session->remote.comp->dtor(session, 0,
++ &session->remote.comp_abstract);
++ }
++ /* mac */
++ if (session->remote.mac && session->remote.mac->dtor) {
++ session->remote.mac->dtor(session, &session->remote.mac_abstract);
++ }
++
++ /* session_id */
++ if (session->session_id) {
++ LIBSSH2_FREE(session, session->session_id);
++ }
++ }
++
++ /* Free banner(s) */
++ if (session->remote.banner) {
++ LIBSSH2_FREE(session, session->remote.banner);
++ }
++ if (session->local.banner) {
++ LIBSSH2_FREE(session, session->local.banner);
++ }
++
++ /* Free preference(s) */
++ if (session->kex_prefs) {
++ LIBSSH2_FREE(session, session->kex_prefs);
++ }
++ if (session->hostkey_prefs) {
++ LIBSSH2_FREE(session, session->hostkey_prefs);
++ }
++
++ if (session->local.crypt_prefs) {
++ LIBSSH2_FREE(session, session->local.crypt_prefs);
++ }
++ if (session->local.mac_prefs) {
++ LIBSSH2_FREE(session, session->local.mac_prefs);
++ }
++ if (session->local.comp_prefs) {
++ LIBSSH2_FREE(session, session->local.comp_prefs);
++ }
++ if (session->local.lang_prefs) {
++ LIBSSH2_FREE(session, session->local.lang_prefs);
++ }
++
++ if (session->remote.crypt_prefs) {
++ LIBSSH2_FREE(session, session->remote.crypt_prefs);
++ }
++ if (session->remote.mac_prefs) {
++ LIBSSH2_FREE(session, session->remote.mac_prefs);
++ }
++ if (session->remote.comp_prefs) {
++ LIBSSH2_FREE(session, session->remote.comp_prefs);
++ }
++ if (session->remote.lang_prefs) {
++ LIBSSH2_FREE(session, session->remote.lang_prefs);
++ }
++
++ /*
++ * Make sure all memory used in the state variables are free
++ */
++ if (session->startup_data) {
++ LIBSSH2_FREE(session, session->startup_data);
++ }
++ if (session->disconnect_data) {
++ LIBSSH2_FREE(session, session->disconnect_data);
++ }
++ if (session->userauth_list_data) {
++ LIBSSH2_FREE(session, session->userauth_list_data);
++ }
++ if (session->userauth_pswd_data) {
++ LIBSSH2_FREE(session, session->userauth_pswd_data);
++ }
++ if (session->userauth_pswd_newpw) {
++ LIBSSH2_FREE(session, session->userauth_pswd_newpw);
++ }
++ if (session->userauth_host_packet) {
++ LIBSSH2_FREE(session, session->userauth_host_packet);
++ }
++ if (session->userauth_host_method) {
++ LIBSSH2_FREE(session, session->userauth_host_method);
++ }
++ if (session->userauth_host_data) {
++ LIBSSH2_FREE(session, session->userauth_host_data);
++ }
++ if (session->userauth_pblc_data) {
++ LIBSSH2_FREE(session, session->userauth_pblc_data);
++ }
++ if (session->userauth_pblc_packet) {
++ LIBSSH2_FREE(session, session->userauth_pblc_packet);
++ }
++ if (session->userauth_pblc_method) {
++ LIBSSH2_FREE(session, session->userauth_pblc_method);
++ }
++ if (session->userauth_kybd_data) {
++ LIBSSH2_FREE(session, session->userauth_kybd_data);
++ }
++ if (session->userauth_kybd_packet) {
++ LIBSSH2_FREE(session, session->userauth_kybd_packet);
++ }
++ if (session->userauth_kybd_auth_instruction) {
++ LIBSSH2_FREE(session, session->userauth_kybd_auth_instruction);
++ }
++ if (session->open_packet) {
++ LIBSSH2_FREE(session, session->open_packet);
++ }
++ if (session->open_data) {
++ LIBSSH2_FREE(session, session->open_data);
++ }
++ if (session->direct_message) {
++ LIBSSH2_FREE(session, session->direct_message);
++ }
++ if (session->fwdLstn_packet) {
++ LIBSSH2_FREE(session, session->fwdLstn_packet);
++ }
++ if (session->pkeyInit_data) {
++ LIBSSH2_FREE(session, session->pkeyInit_data);
++ }
++ if (session->scpRecv_command) {
++ LIBSSH2_FREE(session, session->scpRecv_command);
++ }
++ if (session->scpSend_command) {
++ LIBSSH2_FREE(session, session->scpSend_command);
++ }
++ if (session->scpRecv_err_msg) {
++ LIBSSH2_FREE(session, session->scpRecv_err_msg);
++ }
++ if (session->scpSend_err_msg) {
++ LIBSSH2_FREE(session, session->scpSend_err_msg);
++ }
++
++ /* Free the error message, if we ar supposed to */
++ if (session->err_msg && session->err_should_free) {
++ LIBSSH2_FREE(session, session->err_msg);
++ }
++
++ /* Cleanup any remaining packets */
++ while (session->packets.head) {
++ LIBSSH2_PACKET *tmp = session->packets.head;
++
++ /* unlink */
++ session->packets.head = tmp->next;
++
++ /* free */
++ LIBSSH2_FREE(session, tmp->data);
++ LIBSSH2_FREE(session, tmp);
++ }
++
++ LIBSSH2_FREE(session, session);
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_session_disconnect_ex
++ */
++LIBSSH2_API int
++libssh2_session_disconnect_ex(LIBSSH2_SESSION * session, int reason,
++ const char *description, const char *lang)
++{
++ unsigned char *s;
++ unsigned long descr_len = 0, lang_len = 0;
++ int rc;
++
++ if (session->disconnect_state == libssh2_NB_state_idle) {
++ _libssh2_debug(session, LIBSSH2_DBG_TRANS,
++ "Disconnecting: reason=%d, desc=%s, lang=%s", reason,
++ description, lang);
++ if (description) {
++ descr_len = strlen(description);
++ }
++ if (lang) {
++ lang_len = strlen(lang);
++ }
++ /* 13 = packet_type(1) + reason code(4) + descr_len(4) + lang_len(4) */
++ session->disconnect_data_len = descr_len + lang_len + 13;
++
++ s = session->disconnect_data =
++ LIBSSH2_ALLOC(session, session->disconnect_data_len);
++ if (!session->disconnect_data) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for disconnect packet",
++ 0);
++ session->disconnect_state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ *(s++) = SSH_MSG_DISCONNECT;
++ libssh2_htonu32(s, reason);
++ s += 4;
++
++ libssh2_htonu32(s, descr_len);
++ s += 4;
++ if (description) {
++ memcpy(s, description, descr_len);
++ s += descr_len;
++ }
++
++ libssh2_htonu32(s, lang_len);
++ s += 4;
++ if (lang) {
++ memcpy(s, lang, lang_len);
++ s += lang_len;
++ }
++
++ session->disconnect_state = libssh2_NB_state_created;
++ }
++
++ rc = libssh2_packet_write(session, session->disconnect_data,
++ session->disconnect_data_len);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ }
++
++ LIBSSH2_FREE(session, session->disconnect_data);
++ session->disconnect_data = NULL;
++ session->disconnect_state = libssh2_NB_state_idle;
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_session_methods
++ * Return the currently active methods for method_type
++ * NOTE: Currently lang_cs and lang_sc are ALWAYS set to empty string regardless of actual negotiation
++ * Strings should NOT be freed
++ */
++LIBSSH2_API const char *
++libssh2_session_methods(LIBSSH2_SESSION * session, int method_type)
++{
++ /* All methods have char *name as their first element */
++ const LIBSSH2_KEX_METHOD *method = NULL;
++
++ switch (method_type) {
++ case LIBSSH2_METHOD_KEX:
++ method = session->kex;
++ break;
++
++ case LIBSSH2_METHOD_HOSTKEY:
++ method = (LIBSSH2_KEX_METHOD *) session->hostkey;
++ break;
++
++ case LIBSSH2_METHOD_CRYPT_CS:
++ method = (LIBSSH2_KEX_METHOD *) session->local.crypt;
++ break;
++
++ case LIBSSH2_METHOD_CRYPT_SC:
++ method = (LIBSSH2_KEX_METHOD *) session->remote.crypt;
++ break;
++
++ case LIBSSH2_METHOD_MAC_CS:
++ method = (LIBSSH2_KEX_METHOD *) session->local.mac;
++ break;
++
++ case LIBSSH2_METHOD_MAC_SC:
++ method = (LIBSSH2_KEX_METHOD *) session->remote.mac;
++ break;
++
++ case LIBSSH2_METHOD_COMP_CS:
++ method = (LIBSSH2_KEX_METHOD *) session->local.comp;
++ break;
++
++ case LIBSSH2_METHOD_COMP_SC:
++ method = (LIBSSH2_KEX_METHOD *) session->remote.comp;
++ break;
++
++ case LIBSSH2_METHOD_LANG_CS:
++ return "";
++ break;
++
++ case LIBSSH2_METHOD_LANG_SC:
++ return "";
++ break;
++
++ default:
++ libssh2_error(session, LIBSSH2_ERROR_INVAL,
++ "Invalid parameter specified for method_type", 0);
++ return NULL;
++ break;
++ }
++
++ if (!method) {
++ libssh2_error(session, LIBSSH2_ERROR_METHOD_NONE,
++ "No method negotiated", 0);
++ return NULL;
++ }
++
++ return method->name;
++}
++
++/* }}} */
++
++/* {{{ libssh2_session_abstract
++ * Retrieve a pointer to the abstract property
++ */
++LIBSSH2_API void **
++libssh2_session_abstract(LIBSSH2_SESSION * session)
++{
++ return &session->abstract;
++}
++
++/* }}} */
++
++/* {{{ libssh2_session_last_error
++ * Returns error code and populates an error string into errmsg
++ * If want_buf is non-zero then the string placed into errmsg must be freed by the calling program
++ * Otherwise it is assumed to be owned by libssh2
++ */
++LIBSSH2_API int
++libssh2_session_last_error(LIBSSH2_SESSION * session, char **errmsg,
++ int *errmsg_len, int want_buf)
++{
++ /* No error to report */
++ if (!session->err_code) {
++ if (errmsg) {
++ if (want_buf) {
++ *errmsg = LIBSSH2_ALLOC(session, 1);
++ if (*errmsg) {
++ **errmsg = 0;
++ }
++ } else {
++ *errmsg = (char *) "";
++ }
++ }
++ if (errmsg_len) {
++ *errmsg_len = 0;
++ }
++ return 0;
++ }
++
++ if (errmsg) {
++ char *serrmsg = session->err_msg ? session->err_msg : (char *) "";
++ int ownbuf = session->err_msg ? session->err_should_free : 0;
++
++ if (want_buf) {
++ if (ownbuf) {
++ /* Just give the calling program the buffer */
++ *errmsg = serrmsg;
++ session->err_should_free = 0;
++ } else {
++ /* Make a copy so the calling program can own it */
++ *errmsg = LIBSSH2_ALLOC(session, session->err_msglen + 1);
++ if (*errmsg) {
++ memcpy(*errmsg, session->err_msg, session->err_msglen);
++ (*errmsg)[session->err_msglen] = 0;
++ }
++ }
++ } else {
++ *errmsg = serrmsg;
++ }
++ }
++
++ if (errmsg_len) {
++ *errmsg_len = session->err_msglen;
++ }
++
++ return session->err_code;
++}
++
++/* }}} */
++
++/* {{{ libssh2_session_last_error
++* Returns error code
++*/
++LIBSSH2_API int
++libssh2_session_last_errno(LIBSSH2_SESSION * session)
++{
++ return session->err_code;
++}
++
++/* }}} */
++
++/* {{{ libssh2_session_flag
++ * Set/Get session flags
++ * Passing flag==0 will avoid changing session->flags while still returning its current value
++ */
++LIBSSH2_API int
++libssh2_session_flag(LIBSSH2_SESSION * session, int flag, int value)
++{
++ if (value) {
++ session->flags |= flag;
++ } else {
++ session->flags &= ~flag;
++ }
++
++ return session->flags;
++}
++
++/* }}} */
++
++/* {{{ _libssh2_session_set_blocking
++ * Set a session's blocking mode on or off, return the previous status
++ * when this function is called.
++ */
++int
++_libssh2_session_set_blocking(LIBSSH2_SESSION * session, int blocking)
++{
++ int bl = session->socket_block;
++ _libssh2_debug(session, LIBSSH2_DBG_CONN,
++ "Setting blocking mode on session %d", blocking);
++ if (blocking == session->socket_block) {
++ /* avoid if already correct */
++ return bl;
++ }
++ session->socket_block = blocking;
++
++ _libssh2_nonblock(session->socket_fd, !blocking);
++
++ return bl;
++}
++
++/* }}} */
++
++/* {{{ libssh2_session_set_blocking
++ * Set a channel's blocking mode on or off, similar to a socket's
++ * fcntl(fd, F_SETFL, O_NONBLOCK); type command
++ */
++LIBSSH2_API void
++libssh2_session_set_blocking(LIBSSH2_SESSION * session, int blocking)
++{
++ (void) _libssh2_session_set_blocking(session, blocking);
++}
++
++/* }}} */
++
++/* {{{ libssh2_session_get_blocking
++* Returns a session's blocking mode on or off
++*/
++LIBSSH2_API int
++libssh2_session_get_blocking(LIBSSH2_SESSION * session)
++{
++ return session->socket_block;
++}
++
++/* }}} */
++
++/* {{{ libssh2_poll_channel_read
++ * Returns 0 if no data is waiting on channel,
++ * non-0 if data is available
++ */
++LIBSSH2_API int
++libssh2_poll_channel_read(LIBSSH2_CHANNEL * channel, int extended)
++{
++ LIBSSH2_SESSION *session = channel->session;
++ LIBSSH2_PACKET *packet = session->packets.head;
++
++ while (packet)
++ {
++ if ( channel->local.id == libssh2_ntohu32(packet->data + 1)) {
++ if ( extended == 1 &&
++ (packet->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA
++ || packet->data[0] == SSH_MSG_CHANNEL_DATA )) {
++ return 1;
++ } else if ( extended == 0 &&
++ packet->data[0] == SSH_MSG_CHANNEL_DATA) {
++ return 1;
++ }
++ /* else - no data of any type is ready to be read */
++ }
++ packet = packet->next;
++ }
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_poll_channel_write
++ * Returns 0 if writing to channel would block,
++ * non-0 if data can be written without blocking
++ */
++static inline int
++libssh2_poll_channel_write(LIBSSH2_CHANNEL * channel)
++{
++ return channel->local.window_size ? 1 : 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_poll_listener_queued
++ * Returns 0 if no connections are waiting to be accepted
++ * non-0 if one or more connections are available
++ */
++static inline int
++libssh2_poll_listener_queued(LIBSSH2_LISTENER * listener)
++{
++ return listener->queue ? 1 : 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_poll
++ * Poll sockets, channels, and listeners for activity
++ */
++LIBSSH2_API int
++libssh2_poll(LIBSSH2_POLLFD * fds, unsigned int nfds, long timeout)
++{
++ long timeout_remaining;
++ unsigned int i, active_fds;
++#ifdef HAVE_POLL
++ LIBSSH2_SESSION *session = NULL;
++#ifdef HAVE_ALLOCA
++ struct pollfd *sockets = alloca(sizeof(struct pollfd) * nfds);
++#else
++ struct pollfd sockets[256];
++
++ if (nfds > 256)
++ /* systems without alloca use a fixed-size array, this can be fixed
++ if we really want to, at least if the compiler is a C99 capable one */
++ return -1;
++#endif
++ /* Setup sockets for polling */
++ for(i = 0; i < nfds; i++) {
++ fds[i].revents = 0;
++ switch (fds[i].type) {
++ case LIBSSH2_POLLFD_SOCKET:
++ sockets[i].fd = fds[i].fd.socket;
++ sockets[i].events = fds[i].events;
++ sockets[i].revents = 0;
++ break;
++
++ case LIBSSH2_POLLFD_CHANNEL:
++ sockets[i].fd = fds[i].fd.channel->session->socket_fd;
++ sockets[i].events = POLLIN;
++ sockets[i].revents = 0;
++ if (!session)
++ session = fds[i].fd.channel->session;
++ break;
++
++ case LIBSSH2_POLLFD_LISTENER:
++ sockets[i].fd = fds[i].fd.listener->session->socket_fd;
++ sockets[i].events = POLLIN;
++ sockets[i].revents = 0;
++ if (!session)
++ session = fds[i].fd.listener->session;
++ break;
++
++ default:
++ if (session)
++ libssh2_error(session, LIBSSH2_ERROR_INVALID_POLL_TYPE,
++ "Invalid descriptor passed to libssh2_poll()",
++ 0);
++ return -1;
++ }
++ }
++#elif defined(HAVE_SELECT)
++ LIBSSH2_SESSION *session = NULL;
++ int maxfd = 0;
++ fd_set rfds, wfds;
++ struct timeval tv;
++
++ FD_ZERO(&rfds);
++ FD_ZERO(&wfds);
++ for(i = 0; i < nfds; i++) {
++ fds[i].revents = 0;
++ switch (fds[i].type) {
++ case LIBSSH2_POLLFD_SOCKET:
++ if (fds[i].events & LIBSSH2_POLLFD_POLLIN) {
++ FD_SET(fds[i].fd.socket, &rfds);
++ if (fds[i].fd.socket > maxfd)
++ maxfd = fds[i].fd.socket;
++ }
++ if (fds[i].events & LIBSSH2_POLLFD_POLLOUT) {
++ FD_SET(fds[i].fd.socket, &wfds);
++ if (fds[i].fd.socket > maxfd)
++ maxfd = fds[i].fd.socket;
++ }
++ break;
++
++ case LIBSSH2_POLLFD_CHANNEL:
++ FD_SET(fds[i].fd.channel->session->socket_fd, &rfds);
++ if (fds[i].fd.channel->session->socket_fd > maxfd)
++ maxfd = fds[i].fd.channel->session->socket_fd;
++ if (!session)
++ session = fds[i].fd.channel->session;
++ break;
++
++ case LIBSSH2_POLLFD_LISTENER:
++ FD_SET(fds[i].fd.listener->session->socket_fd, &rfds);
++ if (fds[i].fd.listener->session->socket_fd > maxfd)
++ maxfd = fds[i].fd.listener->session->socket_fd;
++ if (!session)
++ session = fds[i].fd.listener->session;
++ break;
++
++ default:
++ if (session)
++ libssh2_error(session, LIBSSH2_ERROR_INVALID_POLL_TYPE,
++ "Invalid descriptor passed to libssh2_poll()",
++ 0);
++ return -1;
++ }
++ }
++#else
++ /* No select() or poll()
++ * no sockets sturcture to setup
++ */
++
++ timeout = 0;
++#endif /* HAVE_POLL or HAVE_SELECT */
++
++ timeout_remaining = timeout;
++ do {
++#if defined(HAVE_POLL) || defined(HAVE_SELECT)
++ int sysret;
++#endif
++
++ active_fds = 0;
++
++ for(i = 0; i < nfds; i++) {
++ if (fds[i].events != fds[i].revents) {
++ switch (fds[i].type) {
++ case LIBSSH2_POLLFD_CHANNEL:
++ if ((fds[i].events & LIBSSH2_POLLFD_POLLIN) && /* Want to be ready for read */
++ ((fds[i].revents & LIBSSH2_POLLFD_POLLIN) == 0)) { /* Not yet known to be ready for read */
++ fds[i].revents |=
++ libssh2_poll_channel_read(fds[i].fd.channel,
++ 0) ?
++ LIBSSH2_POLLFD_POLLIN : 0;
++ }
++ if ((fds[i].events & LIBSSH2_POLLFD_POLLEXT) && /* Want to be ready for extended read */
++ ((fds[i].revents & LIBSSH2_POLLFD_POLLEXT) == 0)) { /* Not yet known to be ready for extended read */
++ fds[i].revents |=
++ libssh2_poll_channel_read(fds[i].fd.channel,
++ 1) ?
++ LIBSSH2_POLLFD_POLLEXT : 0;
++ }
++ if ((fds[i].events & LIBSSH2_POLLFD_POLLOUT) && /* Want to be ready for write */
++ ((fds[i].revents & LIBSSH2_POLLFD_POLLOUT) == 0)) { /* Not yet known to be ready for write */
++ fds[i].revents |=
++ libssh2_poll_channel_write(fds[i].fd.
++ channel) ?
++ LIBSSH2_POLLFD_POLLOUT : 0;
++ }
++ if (fds[i].fd.channel->remote.close
++ || fds[i].fd.channel->local.close) {
++ fds[i].revents |= LIBSSH2_POLLFD_CHANNEL_CLOSED;
++ }
++ if (fds[i].fd.channel->session->socket_state ==
++ LIBSSH2_SOCKET_DISCONNECTED) {
++ fds[i].revents |=
++ LIBSSH2_POLLFD_CHANNEL_CLOSED |
++ LIBSSH2_POLLFD_SESSION_CLOSED;
++ }
++ break;
++
++ case LIBSSH2_POLLFD_LISTENER:
++ if ((fds[i].events & LIBSSH2_POLLFD_POLLIN) && /* Want a connection */
++ ((fds[i].revents & LIBSSH2_POLLFD_POLLIN) == 0)) { /* No connections known of yet */
++ fds[i].revents |=
++ libssh2_poll_listener_queued(fds[i].fd.
++ listener) ?
++ LIBSSH2_POLLFD_POLLIN : 0;
++ }
++ if (fds[i].fd.listener->session->socket_state ==
++ LIBSSH2_SOCKET_DISCONNECTED) {
++ fds[i].revents |=
++ LIBSSH2_POLLFD_LISTENER_CLOSED |
++ LIBSSH2_POLLFD_SESSION_CLOSED;
++ }
++ break;
++ }
++ }
++ if (fds[i].revents) {
++ active_fds++;
++ }
++ }
++
++ if (active_fds) {
++ /* Don't block on the sockets if we have channels/listeners which are ready */
++ timeout_remaining = 0;
++ }
++#ifdef HAVE_POLL
++
++#ifdef HAVE_GETTIMEOFDAY
++ {
++ struct timeval tv_begin, tv_end;
++
++ gettimeofday((struct timeval *) &tv_begin, NULL);
++ sysret = poll(sockets, nfds, timeout_remaining);
++ gettimeofday((struct timeval *) &tv_end, NULL);
++ timeout_remaining -= (tv_end.tv_sec - tv_begin.tv_sec) * 1000;
++ timeout_remaining -= (tv_end.tv_usec - tv_begin.tv_usec) / 1000;
++ }
++#else
++ /* If the platform doesn't support gettimeofday,
++ * then just make the call non-blocking and walk away
++ */
++ sysret = poll(sockets, nfds, timeout_remaining);
++ timeout_remaining = 0;
++#endif /* HAVE_GETTIMEOFDAY */
++
++ if (sysret > 0) {
++ for(i = 0; i < nfds; i++) {
++ switch (fds[i].type) {
++ case LIBSSH2_POLLFD_SOCKET:
++ fds[i].revents = sockets[i].revents;
++ sockets[i].revents = 0; /* In case we loop again, be nice */
++ if (fds[i].revents) {
++ active_fds++;
++ }
++ break;
++ case LIBSSH2_POLLFD_CHANNEL:
++ if (sockets[i].events & POLLIN) {
++ /* Spin session until no data available */
++ while (libssh2_packet_read(fds[i].fd.channel->session)
++ > 0);
++ }
++ if (sockets[i].revents & POLLHUP) {
++ fds[i].revents |=
++ LIBSSH2_POLLFD_CHANNEL_CLOSED |
++ LIBSSH2_POLLFD_SESSION_CLOSED;
++ }
++ sockets[i].revents = 0;
++ break;
++ case LIBSSH2_POLLFD_LISTENER:
++ if (sockets[i].events & POLLIN) {
++ /* Spin session until no data available */
++ while (libssh2_packet_read(fds[i].fd.listener->session)
++ > 0);
++ }
++ if (sockets[i].revents & POLLHUP) {
++ fds[i].revents |=
++ LIBSSH2_POLLFD_LISTENER_CLOSED |
++ LIBSSH2_POLLFD_SESSION_CLOSED;
++ }
++ sockets[i].revents = 0;
++ break;
++ }
++ }
++ }
++#elif defined(HAVE_SELECT)
++ tv.tv_sec = timeout_remaining / 1000;
++ tv.tv_usec = (timeout_remaining % 1000) * 1000;
++#ifdef HAVE_GETTIMEOFDAY
++ {
++ struct timeval tv_begin, tv_end;
++
++ gettimeofday((struct timeval *) &tv_begin, NULL);
++ sysret = select(maxfd+1, &rfds, &wfds, NULL, &tv);
++ gettimeofday((struct timeval *) &tv_end, NULL);
++
++ timeout_remaining -= (tv_end.tv_sec - tv_begin.tv_sec) * 1000;
++ timeout_remaining -= (tv_end.tv_usec - tv_begin.tv_usec) / 1000;
++ }
++#else
++ /* If the platform doesn't support gettimeofday,
++ * then just make the call non-blocking and walk away
++ */
++ sysret = select(maxfd+1, &rfds, &wfds, NULL, &tv);
++ timeout_remaining = 0;
++#endif
++
++ if (sysret > 0) {
++ for(i = 0; i < nfds; i++) {
++ switch (fds[i].type) {
++ case LIBSSH2_POLLFD_SOCKET:
++ if (FD_ISSET(fds[i].fd.socket, &rfds)) {
++ fds[i].revents |= LIBSSH2_POLLFD_POLLIN;
++ }
++ if (FD_ISSET(fds[i].fd.socket, &wfds)) {
++ fds[i].revents |= LIBSSH2_POLLFD_POLLOUT;
++ }
++ if (fds[i].revents) {
++ active_fds++;
++ }
++ break;
++
++ case LIBSSH2_POLLFD_CHANNEL:
++ if (FD_ISSET(fds[i].fd.channel->session->socket_fd, &rfds)) {
++ /* Spin session until no data available */
++ while (libssh2_packet_read(fds[i].fd.channel->session)
++ > 0);
++ }
++ break;
++
++ case LIBSSH2_POLLFD_LISTENER:
++ if (FD_ISSET
++ (fds[i].fd.listener->session->socket_fd, &rfds)) {
++ /* Spin session until no data available */
++ while (libssh2_packet_read(fds[i].fd.listener->session)
++ > 0);
++ }
++ break;
++ }
++ }
++ }
++#endif /* else no select() or poll() -- timeout (and by extension timeout_remaining) will be equal to 0 */
++ } while ((timeout_remaining > 0) && !active_fds);
++
++ return active_fds;
++}
++
++/* {{{ libssh2_session_block_direction
++ * Get blocked direction when a function returns LIBSSH2_ERROR_EAGAIN
++ * Returns LIBSSH2_SOCKET_BLOCK_INBOUND if recv() blocked
++ * or LIBSSH2_SOCKET_BLOCK_OUTBOUND if send() blocked
++ */
++LIBSSH2_API int
++libssh2_session_block_directions(LIBSSH2_SESSION *session)
++{
++ return session->socket_block_directions;
++}
++
++/* }}} */
+
+Property changes on: libssh2/src/session.c
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.3
+Added: svn:eol-style
+ + native
+
+Index: libssh2/src/openssl.c
+===================================================================
+--- libssh2/src/openssl.c (.../tags/RELEASE_0_11_0)
++++ libssh2/src/openssl.c (.../trunk)
+@@ -0,0 +1,316 @@
++/* Copyright (C) 2006, 2007 The Written Word, Inc. All rights reserved.
++ * Author: Simon Josefsson
++ * Copyright (c) 2004-2006, Sara Golemon <sarag@libssh2.org>
++ *
++ * 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 <string.h>
++
++#ifndef EVP_MAX_BLOCK_LENGTH
++#define EVP_MAX_BLOCK_LENGTH 32
++#endif
++
++int
++_libssh2_rsa_new(libssh2_rsa_ctx ** rsa,
++ const unsigned char *edata,
++ unsigned long elen,
++ const unsigned char *ndata,
++ unsigned long nlen,
++ const unsigned char *ddata,
++ unsigned long dlen,
++ const unsigned char *pdata,
++ unsigned long plen,
++ const unsigned char *qdata,
++ unsigned long qlen,
++ const unsigned char *e1data,
++ unsigned long e1len,
++ const unsigned char *e2data,
++ unsigned long e2len,
++ const unsigned char *coeffdata, unsigned long coefflen)
++{
++ *rsa = RSA_new();
++
++ (*rsa)->e = BN_new();
++ BN_bin2bn(edata, elen, (*rsa)->e);
++
++ (*rsa)->n = BN_new();
++ BN_bin2bn(ndata, nlen, (*rsa)->n);
++
++ if (ddata) {
++ (*rsa)->d = BN_new();
++ BN_bin2bn(ddata, dlen, (*rsa)->d);
++
++ (*rsa)->p = BN_new();
++ BN_bin2bn(pdata, plen, (*rsa)->p);
++
++ (*rsa)->q = BN_new();
++ BN_bin2bn(qdata, qlen, (*rsa)->q);
++
++ (*rsa)->dmp1 = BN_new();
++ BN_bin2bn(e1data, e1len, (*rsa)->dmp1);
++
++ (*rsa)->dmq1 = BN_new();
++ BN_bin2bn(e2data, e2len, (*rsa)->dmq1);
++
++ (*rsa)->iqmp = BN_new();
++ BN_bin2bn(coeffdata, coefflen, (*rsa)->iqmp);
++ }
++ return 0;
++}
++
++int
++_libssh2_rsa_sha1_verify(libssh2_rsa_ctx * rsactx,
++ const unsigned char *sig,
++ unsigned long sig_len,
++ const unsigned char *m, unsigned long m_len)
++{
++ unsigned char hash[SHA_DIGEST_LENGTH];
++ int ret;
++
++ SHA1(m, m_len, hash);
++ ret = RSA_verify(NID_sha1, hash, SHA_DIGEST_LENGTH,
++ (unsigned char *) sig, sig_len, rsactx);
++ return (ret == 1) ? 0 : -1;
++}
++
++int
++_libssh2_dsa_new(libssh2_dsa_ctx ** dsactx,
++ const unsigned char *p,
++ unsigned long p_len,
++ const unsigned char *q,
++ unsigned long q_len,
++ const unsigned char *g,
++ unsigned long g_len,
++ const unsigned char *y,
++ unsigned long y_len,
++ const unsigned char *x, unsigned long x_len)
++{
++ *dsactx = DSA_new();
++
++ (*dsactx)->p = BN_new();
++ BN_bin2bn(p, p_len, (*dsactx)->p);
++
++ (*dsactx)->q = BN_new();
++ BN_bin2bn(q, q_len, (*dsactx)->q);
++
++ (*dsactx)->g = BN_new();
++ BN_bin2bn(g, g_len, (*dsactx)->g);
++
++ (*dsactx)->pub_key = BN_new();
++ BN_bin2bn(y, y_len, (*dsactx)->pub_key);
++
++ if (x_len) {
++ (*dsactx)->priv_key = BN_new();
++ BN_bin2bn(x, x_len, (*dsactx)->priv_key);
++ }
++
++ return 0;
++}
++
++int
++_libssh2_dsa_sha1_verify(libssh2_dsa_ctx * dsactx,
++ const unsigned char *sig,
++ const unsigned char *m, unsigned long m_len)
++{
++ unsigned char hash[SHA_DIGEST_LENGTH];
++ DSA_SIG dsasig;
++ int ret;
++
++ dsasig.r = BN_new();
++ BN_bin2bn(sig, 20, dsasig.r);
++ dsasig.s = BN_new();
++ BN_bin2bn(sig + 20, 20, dsasig.s);
++
++ libssh2_sha1(m, m_len, hash);
++ ret = DSA_do_verify(hash, SHA_DIGEST_LENGTH, &dsasig, dsactx);
++ BN_clear_free(dsasig.s);
++ BN_clear_free(dsasig.r);
++
++ return (ret == 1) ? 0 : -1;
++}
++
++int
++_libssh2_cipher_init(_libssh2_cipher_ctx * h,
++ _libssh2_cipher_type(algo),
++ unsigned char *iv, unsigned char *secret, int encrypt)
++{
++ EVP_CIPHER_CTX_init(h);
++ EVP_CipherInit(h, algo(), secret, iv, encrypt);
++ return 0;
++}
++
++int
++_libssh2_cipher_crypt(_libssh2_cipher_ctx * ctx,
++ _libssh2_cipher_type(algo),
++ int encrypt, unsigned char *block)
++{
++ int blocksize = ctx->cipher->block_size;
++ unsigned char buf[EVP_MAX_BLOCK_LENGTH];
++ int ret;
++ (void) algo;
++ (void) encrypt;
++
++ if (blocksize == 1) {
++/* Hack for arcfour. */
++ blocksize = 8;
++ }
++ ret = EVP_Cipher(ctx, buf, block, blocksize);
++ if (ret == 1) {
++ memcpy(block, buf, blocksize);
++ }
++ return ret == 1 ? 0 : 1;
++}
++
++/* TODO: Optionally call a passphrase callback specified by the
++ * calling program
++ */
++static int
++passphrase_cb(char *buf, int size, int rwflag, char *passphrase)
++{
++ int passphrase_len = strlen(passphrase);
++ (void) rwflag;
++
++ if (passphrase_len > (size - 1)) {
++ passphrase_len = size - 1;
++ }
++ memcpy(buf, passphrase, passphrase_len);
++ buf[passphrase_len] = '\0';
++
++ return passphrase_len;
++}
++
++int
++_libssh2_rsa_new_private(libssh2_rsa_ctx ** rsa,
++ LIBSSH2_SESSION * session,
++ FILE * fp, unsigned const char *passphrase)
++{
++ (void) session;
++ if (!EVP_get_cipherbyname("des")) {
++/* If this cipher isn't loaded it's a pretty good indication that none are.
++ * I have *NO DOUBT* that there's a better way to deal with this ($#&%#$(%$#(
++ * Someone buy me an OpenSSL manual and I'll read up on it.
++ */
++ OpenSSL_add_all_ciphers();
++ }
++ *rsa = PEM_read_RSAPrivateKey(fp, NULL, (void *) passphrase_cb,
++ (void *) passphrase);
++ if (!*rsa) {
++ return -1;
++ }
++ return 0;
++}
++
++int
++_libssh2_dsa_new_private(libssh2_dsa_ctx ** dsa,
++ LIBSSH2_SESSION * session,
++ FILE * fp, unsigned const char *passphrase)
++{
++ (void) session;
++ if (!EVP_get_cipherbyname("des")) {
++/* If this cipher isn't loaded it's a pretty good indication that none are.
++ * I have *NO DOUBT* that there's a better way to deal with this ($#&%#$(%$#(
++ * Someone buy me an OpenSSL manual and I'll read up on it.
++ */
++ OpenSSL_add_all_ciphers();
++ }
++ *dsa = PEM_read_DSAPrivateKey(fp, NULL, (void *) passphrase_cb,
++ (void *) passphrase);
++ if (!*dsa) {
++ return -1;
++ }
++ return 0;
++}
++
++int
++_libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
++ libssh2_rsa_ctx * rsactx,
++ const unsigned char *hash,
++ unsigned long hash_len,
++ unsigned char **signature, unsigned long *signature_len)
++{
++ int ret;
++ unsigned char *sig;
++ unsigned int sig_len;
++
++ sig_len = RSA_size(rsactx);
++ sig = LIBSSH2_ALLOC(session, sig_len);
++
++ if (!sig) {
++ return -1;
++ }
++
++ ret = RSA_sign(NID_sha1, hash, hash_len, sig, &sig_len, rsactx);
++
++ if (!ret) {
++ LIBSSH2_FREE(session, sig);
++ return -1;
++ }
++
++ *signature = sig;
++ *signature_len = sig_len;
++
++ return 0;
++}
++
++int
++_libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
++ const unsigned char *hash,
++ unsigned long hash_len, unsigned char *signature)
++{
++ DSA_SIG *sig;
++ int r_len, s_len, rs_pad;
++ (void) hash_len;
++
++ sig = DSA_do_sign(hash, SHA_DIGEST_LENGTH, dsactx);
++ if (!sig) {
++ return -1;
++ }
++
++ r_len = BN_num_bytes(sig->r);
++ s_len = BN_num_bytes(sig->s);
++ rs_pad = (2 * SHA_DIGEST_LENGTH) - (r_len + s_len);
++ if (rs_pad < 0) {
++ DSA_SIG_free(sig);
++ return -1;
++ }
++
++ BN_bn2bin(sig->r, signature + rs_pad);
++ BN_bn2bin(sig->s, signature + rs_pad + r_len);
++
++ DSA_SIG_free(sig);
++
++ return 0;
++}
+
+Property changes on: libssh2/src/openssl.c
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.1
+Added: svn:eol-style
+ + native
+Added: svn:executable
+ + *
+
+Index: libssh2/src/scp.c
+===================================================================
+--- libssh2/src/scp.c (.../tags/RELEASE_0_11_0)
++++ libssh2/src/scp.c (.../trunk)
+@@ -0,0 +1,811 @@
++/* Copyright (c) 2004-2008, Sara Golemon <sarag@libssh2.org>
++ * 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 <errno.h>
++#include <stdlib.h>
++
++/* {{{ libssh2_scp_recv
++ * Open a channel and request a remote file via SCP
++ *
++ * 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_CHANNEL *
++libssh2_scp_recv(LIBSSH2_SESSION * session, const char *path, struct stat * sb)
++{
++ int path_len = strlen(path);
++ int rc;
++
++ if (session->scpRecv_state == libssh2_NB_state_idle) {
++ session->scpRecv_mode = 0;
++ session->scpRecv_size = 0;
++ session->scpRecv_mtime = 0;
++ session->scpRecv_atime = 0;
++
++ session->scpRecv_command_len = path_len + sizeof("scp -f ");
++
++ if (sb) {
++ session->scpRecv_command_len++;
++ }
++
++ session->scpRecv_command =
++ LIBSSH2_ALLOC(session, session->scpRecv_command_len);
++ if (!session->scpRecv_command) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate a command buffer for SCP session",
++ 0);
++ return NULL;
++ }
++ if (sb) {
++ memcpy(session->scpRecv_command, "scp -pf ",
++ sizeof("scp -pf ") - 1);
++ memcpy(session->scpRecv_command + sizeof("scp -pf ") - 1, path,
++ path_len);
++ } else {
++ memcpy(session->scpRecv_command, "scp -f ", sizeof("scp -f ") - 1);
++ memcpy(session->scpRecv_command + sizeof("scp -f ") - 1, path,
++ path_len);
++ }
++ session->scpRecv_command[session->scpRecv_command_len - 1] = '\0';
++
++ _libssh2_debug(session, LIBSSH2_DBG_SCP,
++ "Opening channel for SCP receive");
++
++ session->scpRecv_state = libssh2_NB_state_created;
++ }
++
++ if (session->scpRecv_state == libssh2_NB_state_created) {
++ /* Allocate a channel */
++ do {
++ session->scpRecv_channel =
++ libssh2_channel_open_ex(session, "session",
++ sizeof("session") - 1,
++ LIBSSH2_CHANNEL_WINDOW_DEFAULT,
++ LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL,
++ 0);
++ if (!session->scpRecv_channel) {
++ if (libssh2_session_last_errno(session) !=
++ LIBSSH2_ERROR_EAGAIN) {
++ LIBSSH2_FREE(session, session->scpRecv_command);
++ session->scpRecv_command = NULL;
++ session->scpRecv_state = libssh2_NB_state_idle;
++ return NULL;
++ } else if (libssh2_session_last_errno(session) ==
++ LIBSSH2_ERROR_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block starting up channel", 0);
++ return NULL;
++ }
++ }
++ } while (!session->scpRecv_channel);
++
++ session->scpRecv_state = libssh2_NB_state_sent;
++ }
++
++ if (session->scpRecv_state == libssh2_NB_state_sent) {
++ /* Request SCP for the desired file */
++ rc = libssh2_channel_process_startup(session->scpRecv_channel, "exec",
++ sizeof("exec") - 1,
++ (char *) session->scpRecv_command,
++ session->scpRecv_command_len);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block requesting SCP startup", 0);
++ return NULL;
++ } else if (rc) {
++ LIBSSH2_FREE(session, session->scpRecv_command);
++ session->scpRecv_command = NULL;
++ goto scp_recv_error;
++ }
++ LIBSSH2_FREE(session, session->scpRecv_command);
++ session->scpRecv_command = NULL;
++
++ _libssh2_debug(session, LIBSSH2_DBG_SCP, "Sending initial wakeup");
++ /* SCP ACK */
++ session->scpRecv_response[0] = '\0';
++
++ session->scpRecv_state = libssh2_NB_state_sent1;
++ }
++
++ if (session->scpRecv_state == libssh2_NB_state_sent1) {
++ rc = libssh2_channel_write_ex(session->scpRecv_channel, 0,
++ (char *) session->scpRecv_response, 1);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block sending initial wakeup", 0);
++ return NULL;
++ } else if (rc != 1) {
++ goto scp_recv_error;
++ }
++
++ /* Parse SCP response */
++ session->scpRecv_response_len = 0;
++
++ session->scpRecv_state = libssh2_NB_state_sent2;
++ }
++
++ if ((session->scpRecv_state == libssh2_NB_state_sent2)
++ || (session->scpRecv_state == libssh2_NB_state_sent3)) {
++ while (sb
++ && (session->scpRecv_response_len <
++ LIBSSH2_SCP_RESPONSE_BUFLEN)) {
++ unsigned char *s, *p;
++
++ if (session->scpRecv_state == libssh2_NB_state_sent2) {
++ rc = libssh2_channel_read_ex(session->scpRecv_channel, 0,
++ (char *) session->
++ scpRecv_response +
++ session->scpRecv_response_len, 1);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block waiting for SCP response", 0);
++ return NULL;
++ } else if (rc <= 0) {
++ /* Timeout, give up */
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Timed out waiting for SCP response", 0);
++ goto scp_recv_error;
++ }
++ session->scpRecv_response_len++;
++
++ if (session->scpRecv_response[0] != 'T') {
++ /*
++ * Set this as the default error for here, if
++ * we are successful it will be replaced
++ */
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Invalid data in SCP response, missing Time data",
++ 0);
++
++ session->scpRecv_err_len =
++ libssh2_channel_packet_data_len(session->
++ scpRecv_channel, 0);
++ session->scpRecv_err_msg =
++ LIBSSH2_ALLOC(session, session->scpRecv_err_len + 1);
++ if (!session->scpRecv_err_msg) {
++ goto scp_recv_error;
++ }
++ memset(session->scpRecv_err_msg, 0,
++ session->scpRecv_err_len + 1);
++
++ /* Read the remote error message */
++ rc = libssh2_channel_read_ex(session->scpRecv_channel, 0,
++ session->scpRecv_err_msg,
++ session->scpRecv_err_len);
++ if (rc <= 0) {
++ /*
++ * Since we have alread started reading this packet, it is
++ * already in the systems so it can't return PACKET_EAGAIN
++ */
++ LIBSSH2_FREE(session, session->scpRecv_err_msg);
++ session->scpRecv_err_msg = NULL;
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Unknown error while getting error string",
++ 0);
++ goto scp_recv_error;
++ }
++
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ session->scpRecv_err_msg, 1);
++ session->scpRecv_err_msg = NULL;
++ goto scp_recv_error;
++ }
++
++ if ((session->scpRecv_response_len > 1) &&
++ ((session->
++ scpRecv_response[session->scpRecv_response_len - 1] <
++ '0')
++ || (session->
++ scpRecv_response[session->scpRecv_response_len - 1] >
++ '9'))
++ && (session->
++ scpRecv_response[session->scpRecv_response_len - 1] !=
++ ' ')
++ && (session->
++ scpRecv_response[session->scpRecv_response_len - 1] !=
++ '\r')
++ && (session->
++ scpRecv_response[session->scpRecv_response_len - 1] !=
++ '\n')) {
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Invalid data in SCP response", 0);
++ goto scp_recv_error;
++ }
++
++ if ((session->scpRecv_response_len < 9)
++ || (session->
++ scpRecv_response[session->scpRecv_response_len - 1] !=
++ '\n')) {
++ if (session->scpRecv_response_len ==
++ LIBSSH2_SCP_RESPONSE_BUFLEN) {
++ /* You had your chance */
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Unterminated response from SCP server",
++ 0);
++ goto scp_recv_error;
++ }
++ /* Way too short to be an SCP response, or not done yet, short circuit */
++ continue;
++ }
++
++ /* We're guaranteed not to go under response_len == 0 by the logic above */
++ while ((session->
++ scpRecv_response[session->scpRecv_response_len - 1] ==
++ '\r')
++ || (session->
++ scpRecv_response[session->scpRecv_response_len -
++ 1] == '\n'))
++ session->scpRecv_response_len--;
++ session->scpRecv_response[session->scpRecv_response_len] =
++ '\0';
++
++ if (session->scpRecv_response_len < 8) {
++ /* EOL came too soon */
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Invalid response from SCP server, too short",
++ 0);
++ goto scp_recv_error;
++ }
++
++ s = session->scpRecv_response + 1;
++
++ p = (unsigned char *) strchr((char *) s, ' ');
++ if (!p || ((p - s) <= 0)) {
++ /* No spaces or space in the wrong spot */
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Invalid response from SCP server, malformed mtime",
++ 0);
++ goto scp_recv_error;
++ }
++
++ *(p++) = '\0';
++ /* Make sure we don't get fooled by leftover values */
++ errno = 0;
++ session->scpRecv_mtime = strtol((char *) s, NULL, 10);
++ if (errno) {
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Invalid response from SCP server, invalid mtime",
++ 0);
++ goto scp_recv_error;
++ }
++ s = (unsigned char *) strchr((char *) p, ' ');
++ if (!s || ((s - p) <= 0)) {
++ /* No spaces or space in the wrong spot */
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Invalid response from SCP server, malformed mtime.usec",
++ 0);
++ goto scp_recv_error;
++ }
++
++ /* Ignore mtime.usec */
++ s++;
++ p = (unsigned char *) strchr((char *) s, ' ');
++ if (!p || ((p - s) <= 0)) {
++ /* No spaces or space in the wrong spot */
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Invalid response from SCP server, too short or malformed",
++ 0);
++ goto scp_recv_error;
++ }
++
++ *(p++) = '\0';
++ /* Make sure we don't get fooled by leftover values */
++ errno = 0;
++ session->scpRecv_atime = strtol((char *) s, NULL, 10);
++ if (errno) {
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Invalid response from SCP server, invalid atime",
++ 0);
++ goto scp_recv_error;
++ }
++
++ /* SCP ACK */
++ session->scpRecv_response[0] = '\0';
++
++ session->scpRecv_state = libssh2_NB_state_sent3;
++ }
++
++ if (session->scpRecv_state == libssh2_NB_state_sent3) {
++ rc = libssh2_channel_write_ex(session->scpRecv_channel, 0,
++ (char *) session->
++ scpRecv_response, 1);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block waiting to send SCP ACK", 0);
++ return NULL;
++ } else if (rc != 1) {
++ goto scp_recv_error;
++ }
++
++ _libssh2_debug(session, LIBSSH2_DBG_SCP,
++ "mtime = %ld, atime = %ld",
++ session->scpRecv_mtime, session->scpRecv_atime);
++
++ /* We *should* check that atime.usec is valid, but why let that stop use? */
++ break;
++ }
++ }
++
++ session->scpRecv_state = libssh2_NB_state_sent4;
++ }
++
++ if (session->scpRecv_state == libssh2_NB_state_sent4) {
++ session->scpRecv_response_len = 0;
++
++ session->scpRecv_state = libssh2_NB_state_sent5;
++ }
++
++ if ((session->scpRecv_state == libssh2_NB_state_sent5)
++ || (session->scpRecv_state == libssh2_NB_state_sent6)) {
++ while (session->scpRecv_response_len < LIBSSH2_SCP_RESPONSE_BUFLEN) {
++ char *s, *p, *e = NULL;
++
++ if (session->scpRecv_state == libssh2_NB_state_sent5) {
++ rc = libssh2_channel_read_ex(session->scpRecv_channel, 0,
++ (char *) session->
++ scpRecv_response +
++ session->scpRecv_response_len, 1);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block waiting for SCP response", 0);
++ return NULL;
++ } else if (rc <= 0) {
++ /* Timeout, give up */
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Timed out waiting for SCP response", 0);
++ goto scp_recv_error;
++ }
++ session->scpRecv_response_len++;
++
++ if (session->scpRecv_response[0] != 'C') {
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Invalid response from SCP server", 0);
++ goto scp_recv_error;
++ }
++
++ if ((session->scpRecv_response_len > 1) &&
++ (session->
++ scpRecv_response[session->scpRecv_response_len - 1] !=
++ '\r')
++ && (session->
++ scpRecv_response[session->scpRecv_response_len - 1] !=
++ '\n')
++ &&
++ ((session->
++ scpRecv_response[session->scpRecv_response_len - 1] < 32)
++ || (session->
++ scpRecv_response[session->scpRecv_response_len - 1] >
++ 126))) {
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Invalid data in SCP response", 0);
++ goto scp_recv_error;
++ }
++
++ if ((session->scpRecv_response_len < 7)
++ || (session->
++ scpRecv_response[session->scpRecv_response_len - 1] !=
++ '\n')) {
++ if (session->scpRecv_response_len ==
++ LIBSSH2_SCP_RESPONSE_BUFLEN) {
++ /* You had your chance */
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Unterminated response from SCP server",
++ 0);
++ goto scp_recv_error;
++ }
++ /* Way too short to be an SCP response, or not done yet, short circuit */
++ continue;
++ }
++
++ /* We're guaranteed not to go under response_len == 0 by the logic above */
++ while ((session->
++ scpRecv_response[session->scpRecv_response_len - 1] ==
++ '\r')
++ || (session->
++ scpRecv_response[session->scpRecv_response_len -
++ 1] == '\n')) {
++ session->scpRecv_response_len--;
++ }
++ session->scpRecv_response[session->scpRecv_response_len] =
++ '\0';
++
++ if (session->scpRecv_response_len < 6) {
++ /* EOL came too soon */
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Invalid response from SCP server, too short",
++ 0);
++ goto scp_recv_error;
++ }
++
++ s = (char *) session->scpRecv_response + 1;
++
++ p = strchr(s, ' ');
++ if (!p || ((p - s) <= 0)) {
++ /* No spaces or space in the wrong spot */
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Invalid response from SCP server, malformed mode",
++ 0);
++ goto scp_recv_error;
++ }
++
++ *(p++) = '\0';
++ /* Make sure we don't get fooled by leftover values */
++ errno = 0;
++ session->scpRecv_mode = strtol(s, &e, 8);
++ if ((e && *e) || errno) {
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Invalid response from SCP server, invalid mode",
++ 0);
++ goto scp_recv_error;
++ }
++
++ s = strchr(p, ' ');
++ if (!s || ((s - p) <= 0)) {
++ /* No spaces or space in the wrong spot */
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Invalid response from SCP server, too short or malformed",
++ 0);
++ goto scp_recv_error;
++ }
++
++ *(s++) = '\0';
++ /* Make sure we don't get fooled by leftover values */
++ errno = 0;
++ session->scpRecv_size = scpsize_strtol(p, &e, 10);
++ if ((e && *e) || errno) {
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Invalid response from SCP server, invalid size",
++ 0);
++ goto scp_recv_error;
++ }
++
++ /* SCP ACK */
++ session->scpRecv_response[0] = '\0';
++
++ session->scpRecv_state = libssh2_NB_state_sent6;
++ }
++
++ if (session->scpRecv_state == libssh2_NB_state_sent6) {
++ rc = libssh2_channel_write_ex(session->scpRecv_channel, 0,
++ (char *) session->
++ scpRecv_response, 1);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block sending SCP ACK", 0);
++ return NULL;
++ } else if (rc != 1) {
++ goto scp_recv_error;
++ }
++ _libssh2_debug(session, LIBSSH2_DBG_SCP,
++ "mode = 0%lo size = %ld", session->scpRecv_mode,
++ session->scpRecv_size);
++
++ /* We *should* check that basename is valid, but why let that stop us? */
++ break;
++ }
++ }
++
++ session->scpRecv_state = libssh2_NB_state_sent7;
++ }
++
++ if (sb) {
++ memset(sb, 0, sizeof(struct stat));
++
++ sb->st_mtime = session->scpRecv_mtime;
++ sb->st_atime = session->scpRecv_atime;
++ sb->st_size = session->scpRecv_size;
++ sb->st_mode = session->scpRecv_mode;
++ }
++
++ session->scpRecv_state = libssh2_NB_state_idle;
++ return session->scpRecv_channel;
++
++ scp_recv_error:
++ while (libssh2_channel_free(session->scpRecv_channel) == PACKET_EAGAIN);
++ session->scpRecv_channel = NULL;
++ session->scpRecv_state = libssh2_NB_state_idle;
++ return NULL;
++}
++
++/* }}} */
++
++/* {{{ libssh2_scp_send_ex
++ * Send a file using SCP
++ *
++ * 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_CHANNEL *
++libssh2_scp_send_ex(LIBSSH2_SESSION * session, const char *path, int mode,
++ size_t size, long mtime, long atime)
++{
++ int path_len = strlen(path);
++ unsigned const char *base;
++ int rc;
++
++ if (session->scpSend_state == libssh2_NB_state_idle) {
++ session->scpSend_command_len = path_len + sizeof("scp -t ");
++
++ if (mtime || atime) {
++ session->scpSend_command_len++;
++ }
++
++ session->scpSend_command =
++ LIBSSH2_ALLOC(session, session->scpSend_command_len);
++ if (!session->scpSend_command) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate a command buffer for scp session",
++ 0);
++ return NULL;
++ }
++
++ if (mtime || atime) {
++ memcpy(session->scpSend_command, "scp -pt ",
++ sizeof("scp -pt ") - 1);
++ memcpy(session->scpSend_command + sizeof("scp -pt ") - 1, path,
++ path_len);
++ } else {
++ memcpy(session->scpSend_command, "scp -t ", sizeof("scp -t ") - 1);
++ memcpy(session->scpSend_command + sizeof("scp -t ") - 1, path,
++ path_len);
++ }
++ session->scpSend_command[session->scpSend_command_len - 1] = '\0';
++
++ _libssh2_debug(session, LIBSSH2_DBG_SCP,
++ "Opening channel for SCP send");
++ /* Allocate a channel */
++
++ session->scpSend_state = libssh2_NB_state_created;
++ }
++
++ if (session->scpSend_state == libssh2_NB_state_created) {
++ session->scpSend_channel =
++ libssh2_channel_open_ex(session, "session", sizeof("session") - 1,
++ LIBSSH2_CHANNEL_WINDOW_DEFAULT,
++ LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL, 0);
++ if (!session->scpSend_channel) {
++ if (libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN) {
++ /* previous call set libssh2_session_last_error(), pass it through */
++ LIBSSH2_FREE(session, session->scpSend_command);
++ session->scpSend_command = NULL;
++ session->scpSend_state = libssh2_NB_state_idle;
++ return NULL;
++ } else if (libssh2_session_last_errno(session) ==
++ LIBSSH2_ERROR_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block starting up channel", 0);
++ return NULL;
++ }
++ }
++
++ session->scpSend_state = libssh2_NB_state_sent;
++ }
++
++ if (session->scpSend_state == libssh2_NB_state_sent) {
++ /* Request SCP for the desired file */
++ rc = libssh2_channel_process_startup(session->scpSend_channel, "exec",
++ sizeof("exec") - 1,
++ (char *) session->scpSend_command,
++ session->scpSend_command_len);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block requesting SCP startup", 0);
++ return NULL;
++ } else if (rc) {
++ /* previous call set libssh2_session_last_error(), pass it through */
++ LIBSSH2_FREE(session, session->scpSend_command);
++ session->scpSend_command = NULL;
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Unknown error while getting error string", 0);
++ goto scp_send_error;
++ }
++ LIBSSH2_FREE(session, session->scpSend_command);
++ session->scpSend_command = NULL;
++
++ session->scpSend_state = libssh2_NB_state_sent1;
++ }
++
++ if (session->scpSend_state == libssh2_NB_state_sent1) {
++ /* Wait for ACK */
++ rc = libssh2_channel_read_ex(session->scpSend_channel, 0,
++ (char *) session->scpSend_response, 1);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block waiting for response from remote", 0);
++ return NULL;
++ } else if ((rc <= 0) || (session->scpSend_response[0] != 0)) {
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Invalid ACK response from remote", 0);
++ goto scp_send_error;
++ }
++
++ if (mtime || atime) {
++ /* Send mtime and atime to be used for file */
++ session->scpSend_response_len =
++ snprintf((char *) session->scpSend_response,
++ LIBSSH2_SCP_RESPONSE_BUFLEN, "T%ld 0 %ld 0\n", mtime,
++ atime);
++ _libssh2_debug(session, LIBSSH2_DBG_SCP, "Sent %s",
++ session->scpSend_response);
++ }
++
++ session->scpSend_state = libssh2_NB_state_sent2;
++ }
++
++ /* Send mtime and atime to be used for file */
++ if (mtime || atime) {
++ if (session->scpSend_state == libssh2_NB_state_sent2) {
++ rc = libssh2_channel_write_ex(session->scpSend_channel, 0,
++ (char *) session->scpSend_response,
++ session->scpSend_response_len);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block sending time data for SCP file", 0);
++ return NULL;
++ } else if (rc != session->scpSend_response_len) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send time data for SCP file", 0);
++ goto scp_send_error;
++ }
++
++ session->scpSend_state = libssh2_NB_state_sent3;
++ }
++
++ if (session->scpSend_state == libssh2_NB_state_sent3) {
++ /* Wait for ACK */
++ rc = libssh2_channel_read_ex(session->scpSend_channel, 0,
++ (char *) session->scpSend_response,
++ 1);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block waiting for response", 0);
++ return NULL;
++ } else if ((rc <= 0) || (session->scpSend_response[0] != 0)) {
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Invalid ACK response from remote", 0);
++ goto scp_send_error;
++ }
++
++ session->scpSend_state = libssh2_NB_state_sent4;
++ }
++ } else {
++ if (session->scpSend_state == libssh2_NB_state_sent2) {
++ session->scpSend_state = libssh2_NB_state_sent4;
++ }
++ }
++
++ if (session->scpSend_state == libssh2_NB_state_sent4) {
++ /* Send mode, size, and basename */
++ base = (unsigned char *) strrchr(path, '/');
++ if (base) {
++ base++;
++ } else {
++ base = (unsigned char *) path;
++ }
++
++ session->scpSend_response_len =
++ snprintf((char *) session->scpSend_response,
++ LIBSSH2_SCP_RESPONSE_BUFLEN, "C0%o %lu %s\n", mode,
++ (unsigned long) size, base);
++ _libssh2_debug(session, LIBSSH2_DBG_SCP, "Sent %s",
++ session->scpSend_response);
++
++ session->scpSend_state = libssh2_NB_state_sent5;
++ }
++
++ if (session->scpSend_state == libssh2_NB_state_sent5) {
++ rc = libssh2_channel_write_ex(session->scpSend_channel, 0,
++ (char *) session->scpSend_response,
++ session->scpSend_response_len);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block send core file data for SCP file", 0);
++ return NULL;
++ } else if (rc != session->scpSend_response_len) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send core file data for SCP file", 0);
++ goto scp_send_error;
++ }
++
++ session->scpSend_state = libssh2_NB_state_sent6;
++ }
++
++ if (session->scpSend_state == libssh2_NB_state_sent6) {
++ /* Wait for ACK */
++ rc = libssh2_channel_read_ex(session->scpSend_channel, 0,
++ (char *) session->scpSend_response, 1);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block waiting for response", 0);
++ return NULL;
++ } else if (rc <= 0) {
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Invalid ACK response from remote", 0);
++ goto scp_send_error;
++ } else if (session->scpSend_response[0] != 0) {
++ /*
++ * Set this as the default error for here, if
++ * we are successful it will be replaced
++ */
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ "Invalid ACK response from remote", 0);
++
++ session->scpSend_err_len =
++ libssh2_channel_packet_data_len(session->scpSend_channel, 0);
++ session->scpSend_err_msg =
++ LIBSSH2_ALLOC(session, session->scpSend_err_len + 1);
++ if (!session->scpSend_err_msg) {
++ goto scp_send_error;
++ }
++ memset(session->scpSend_err_msg, 0, session->scpSend_err_len + 1);
++
++ /* Read the remote error message */
++ rc = libssh2_channel_read_ex(session->scpSend_channel, 0,
++ session->scpSend_err_msg,
++ session->scpSend_err_len);
++ if (rc <= 0) {
++ /*
++ * Since we have alread started reading this packet, it is
++ * already in the systems so it can't return PACKET_EAGAIN
++ */
++ LIBSSH2_FREE(session, session->scpSend_err_msg);
++ session->scpSend_err_msg = NULL;
++ goto scp_send_error;
++ }
++
++ libssh2_error(session, LIBSSH2_ERROR_SCP_PROTOCOL,
++ session->scpSend_err_msg, 1);
++ session->scpSend_err_msg = NULL;
++ goto scp_send_error;
++ }
++ }
++
++ session->scpSend_state = libssh2_NB_state_idle;
++
++ return session->scpSend_channel;
++
++ scp_send_error:
++ while (libssh2_channel_free(session->scpSend_channel) == PACKET_EAGAIN);
++ session->scpSend_channel = NULL;
++ session->scpSend_state = libssh2_NB_state_idle;
++ return NULL;
++}
++
++/* }}} */
+
+Property changes on: libssh2/src/scp.c
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.2
+Added: svn:eol-style
+ + native
+
+Index: libssh2/src/hostkey.c
+===================================================================
+--- libssh2/src/hostkey.c (.../tags/RELEASE_0_11_0)
++++ libssh2/src/hostkey.c (.../trunk)
+@@ -0,0 +1,455 @@
++/* Copyright (c) 2004-2006, Sara Golemon <sarag@libssh2.org>
++ * 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"
++
++/* Needed for struct iovec on some platforms */
++#ifdef HAVE_SYS_UIO_H
++#include <sys/uio.h>
++#endif
++
++#if LIBSSH2_RSA
++/* ***********
++ * ssh-rsa *
++ *********** */
++
++static int libssh2_hostkey_method_ssh_rsa_dtor(LIBSSH2_SESSION * session,
++ void **abstract);
++
++/* {{{ libssh2_hostkey_method_ssh_rsa_init
++ * Initialize the server hostkey working area with e/n pair
++ */
++static int
++libssh2_hostkey_method_ssh_rsa_init(LIBSSH2_SESSION * session,
++ const unsigned char *hostkey_data,
++ unsigned long hostkey_data_len,
++ void **abstract)
++{
++ libssh2_rsa_ctx *rsactx;
++ const unsigned char *s, *e, *n;
++ unsigned long len, e_len, n_len;
++
++ (void) hostkey_data_len;
++
++ if (*abstract) {
++ libssh2_hostkey_method_ssh_rsa_dtor(session, abstract);
++ *abstract = NULL;
++ }
++
++ s = hostkey_data;
++ len = libssh2_ntohu32(s);
++ s += 4;
++
++ if (len != 7 || strncmp((char *) s, "ssh-rsa", 7) != 0) {
++ return -1;
++ }
++ s += 7;
++
++ e_len = libssh2_ntohu32(s);
++ s += 4;
++
++ e = s;
++ s += e_len;
++ n_len = libssh2_ntohu32(s);
++ s += 4;
++ n = s;
++ s += n_len;
++
++ if (_libssh2_rsa_new(&rsactx, e, e_len, n, n_len, NULL, 0,
++ NULL, 0, NULL, 0, NULL, 0, NULL, 0, NULL, 0))
++ return -1;
++
++ *abstract = rsactx;
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_hostkey_method_ssh_rsa_initPEM
++ * Load a Private Key from a PEM file
++ */
++static int
++libssh2_hostkey_method_ssh_rsa_initPEM(LIBSSH2_SESSION * session,
++ const char *privkeyfile,
++ unsigned const char *passphrase,
++ void **abstract)
++{
++ libssh2_rsa_ctx *rsactx;
++ FILE *fp;
++ int ret;
++
++ if (*abstract) {
++ libssh2_hostkey_method_ssh_rsa_dtor(session, abstract);
++ *abstract = NULL;
++ }
++
++ fp = fopen(privkeyfile, "r");
++ if (!fp) {
++ return -1;
++ }
++
++ ret = _libssh2_rsa_new_private(&rsactx, session, fp, passphrase);
++ fclose(fp);
++ if (ret) {
++ return -1;
++ }
++
++ *abstract = rsactx;
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_hostkey_method_ssh_rsa_sign
++ * Verify signature created by remote
++ */
++static int
++libssh2_hostkey_method_ssh_rsa_sig_verify(LIBSSH2_SESSION * session,
++ const unsigned char *sig,
++ unsigned long sig_len,
++ const unsigned char *m,
++ unsigned long m_len, void **abstract)
++{
++ libssh2_rsa_ctx *rsactx = (libssh2_rsa_ctx *) (*abstract);
++ (void) session;
++
++ /* Skip past keyname_len(4) + keyname(7){"ssh-rsa"} + signature_len(4) */
++ sig += 15;
++ sig_len -= 15;
++ return _libssh2_rsa_sha1_verify(rsactx, sig, sig_len, m, m_len);
++}
++
++/* }}} */
++
++/* {{{ libssh2_hostkey_method_ssh_rsa_signv
++ * Construct a signature from an array of vectors
++ */
++static int
++libssh2_hostkey_method_ssh_rsa_signv(LIBSSH2_SESSION * session,
++ unsigned char **signature,
++ unsigned long *signature_len,
++ unsigned long veccount,
++ const struct iovec datavec[],
++ void **abstract)
++{
++ libssh2_rsa_ctx *rsactx = (libssh2_rsa_ctx *) (*abstract);
++ int ret;
++ unsigned int i;
++ unsigned char hash[SHA_DIGEST_LENGTH];
++ libssh2_sha1_ctx ctx;
++
++ libssh2_sha1_init(&ctx);
++ for(i = 0; i < veccount; i++) {
++ libssh2_sha1_update(ctx, datavec[i].iov_base, datavec[i].iov_len);
++ }
++ libssh2_sha1_final(ctx, hash);
++
++ ret = _libssh2_rsa_sha1_sign(session, rsactx, hash, SHA_DIGEST_LENGTH,
++ signature, signature_len);
++ if (ret) {
++ return -1;
++ }
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_hostkey_method_ssh_rsa_dtor
++ * Shutdown the hostkey
++ */
++static int
++libssh2_hostkey_method_ssh_rsa_dtor(LIBSSH2_SESSION * session, void **abstract)
++{
++ libssh2_rsa_ctx *rsactx = (libssh2_rsa_ctx *) (*abstract);
++ (void) session;
++
++ _libssh2_rsa_free(rsactx);
++
++ *abstract = NULL;
++
++ return 0;
++}
++
++/* }}} */
++
++static const LIBSSH2_HOSTKEY_METHOD libssh2_hostkey_method_ssh_rsa = {
++ "ssh-rsa",
++ MD5_DIGEST_LENGTH,
++ libssh2_hostkey_method_ssh_rsa_init,
++ libssh2_hostkey_method_ssh_rsa_initPEM,
++ libssh2_hostkey_method_ssh_rsa_sig_verify,
++ libssh2_hostkey_method_ssh_rsa_signv,
++ NULL, /* encrypt */
++ libssh2_hostkey_method_ssh_rsa_dtor,
++};
++#endif /* LIBSSH2_RSA */
++
++#if LIBSSH2_DSA
++/* ***********
++ * ssh-dss *
++ *********** */
++
++static int libssh2_hostkey_method_ssh_dss_dtor(LIBSSH2_SESSION * session,
++ void **abstract);
++
++/* {{{ libssh2_hostkey_method_ssh_dss_init
++ * Initialize the server hostkey working area with p/q/g/y set
++ */
++static int
++libssh2_hostkey_method_ssh_dss_init(LIBSSH2_SESSION * session,
++ const unsigned char *hostkey_data,
++ unsigned long hostkey_data_len,
++ void **abstract)
++{
++ libssh2_dsa_ctx *dsactx;
++ const unsigned char *p, *q, *g, *y, *s;
++ unsigned long p_len, q_len, g_len, y_len, len;
++ (void) hostkey_data_len;
++
++ if (*abstract) {
++ libssh2_hostkey_method_ssh_dss_dtor(session, abstract);
++ *abstract = NULL;
++ }
++
++ s = hostkey_data;
++ len = libssh2_ntohu32(s);
++ s += 4;
++ if (len != 7 || strncmp((char *) s, "ssh-dss", 7) != 0) {
++ return -1;
++ }
++ s += 7;
++
++ p_len = libssh2_ntohu32(s);
++ s += 4;
++ p = s;
++ s += p_len;
++ q_len = libssh2_ntohu32(s);
++ s += 4;
++ q = s;
++ s += q_len;
++ g_len = libssh2_ntohu32(s);
++ s += 4;
++ g = s;
++ s += g_len;
++ y_len = libssh2_ntohu32(s);
++ s += 4;
++ y = s;
++ s += y_len;
++
++ _libssh2_dsa_new(&dsactx, p, p_len, q, q_len, g, g_len, y, y_len, NULL, 0);
++
++ *abstract = dsactx;
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_hostkey_method_ssh_dss_initPEM
++ * Load a Private Key from a PEM file
++ */
++static int
++libssh2_hostkey_method_ssh_dss_initPEM(LIBSSH2_SESSION * session,
++ const char *privkeyfile,
++ unsigned const char *passphrase,
++ void **abstract)
++{
++ libssh2_dsa_ctx *dsactx;
++ FILE *fp;
++ int ret;
++
++ if (*abstract) {
++ libssh2_hostkey_method_ssh_dss_dtor(session, abstract);
++ *abstract = NULL;
++ }
++
++ fp = fopen(privkeyfile, "r");
++ if (!fp) {
++ return -1;
++ }
++
++ ret = _libssh2_dsa_new_private(&dsactx, session, fp, passphrase);
++ fclose(fp);
++ if (ret) {
++ return -1;
++ }
++
++ *abstract = dsactx;
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_hostkey_method_ssh_dss_sign
++ * Verify signature created by remote
++ */
++static int
++libssh2_hostkey_method_ssh_dss_sig_verify(LIBSSH2_SESSION * session,
++ const unsigned char *sig,
++ unsigned long sig_len,
++ const unsigned char *m,
++ unsigned long m_len, void **abstract)
++{
++ libssh2_dsa_ctx *dsactx = (libssh2_dsa_ctx *) (*abstract);
++
++ /* Skip past keyname_len(4) + keyname(7){"ssh-dss"} + signature_len(4) */
++ sig += 15;
++ sig_len -= 15;
++ if (sig_len != 40) {
++ libssh2_error(session, LIBSSH2_ERROR_PROTO,
++ "Invalid DSS signature length", 0);
++ return -1;
++ }
++ return _libssh2_dsa_sha1_verify(dsactx, sig, m, m_len);
++}
++
++/* }}} */
++
++/* {{{ libssh2_hostkey_method_ssh_dss_signv
++ * Construct a signature from an array of vectors
++ */
++static int
++libssh2_hostkey_method_ssh_dss_signv(LIBSSH2_SESSION * session,
++ unsigned char **signature,
++ unsigned long *signature_len,
++ unsigned long veccount,
++ const struct iovec datavec[],
++ void **abstract)
++{
++ libssh2_dsa_ctx *dsactx = (libssh2_dsa_ctx *) (*abstract);
++ unsigned char hash[SHA_DIGEST_LENGTH];
++ libssh2_sha1_ctx ctx;
++ unsigned int i;
++
++ *signature = LIBSSH2_ALLOC(session, 2 * SHA_DIGEST_LENGTH);
++ if (!*signature) {
++ return -1;
++ }
++
++ *signature_len = 2 * SHA_DIGEST_LENGTH;
++ memset(*signature, 0, 2 * SHA_DIGEST_LENGTH);
++
++ libssh2_sha1_init(&ctx);
++ for(i = 0; i < veccount; i++) {
++ libssh2_sha1_update(ctx, datavec[i].iov_base, datavec[i].iov_len);
++ }
++ libssh2_sha1_final(ctx, hash);
++
++ if (_libssh2_dsa_sha1_sign(dsactx, hash, SHA_DIGEST_LENGTH, *signature)) {
++ LIBSSH2_FREE(session, *signature);
++ return -1;
++ }
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_hostkey_method_ssh_dss_dtor
++ * Shutdown the hostkey method
++ */
++static int
++libssh2_hostkey_method_ssh_dss_dtor(LIBSSH2_SESSION * session, void **abstract)
++{
++ libssh2_dsa_ctx *dsactx = (libssh2_dsa_ctx *) (*abstract);
++ (void) session;
++
++ _libssh2_dsa_free(dsactx);
++
++ *abstract = NULL;
++
++ return 0;
++}
++
++/* }}} */
++
++static const LIBSSH2_HOSTKEY_METHOD libssh2_hostkey_method_ssh_dss = {
++ "ssh-dss",
++ MD5_DIGEST_LENGTH,
++ libssh2_hostkey_method_ssh_dss_init,
++ libssh2_hostkey_method_ssh_dss_initPEM,
++ libssh2_hostkey_method_ssh_dss_sig_verify,
++ libssh2_hostkey_method_ssh_dss_signv,
++ NULL, /* encrypt */
++ libssh2_hostkey_method_ssh_dss_dtor,
++};
++#endif /* LIBSSH2_DSA */
++
++static const LIBSSH2_HOSTKEY_METHOD *_libssh2_hostkey_methods[] = {
++#if LIBSSH2_RSA
++ &libssh2_hostkey_method_ssh_rsa,
++#endif /* LIBSSH2_RSA */
++#if LIBSSH2_DSA
++ &libssh2_hostkey_method_ssh_dss,
++#endif /* LIBSSH2_DSA */
++ NULL
++};
++
++const LIBSSH2_HOSTKEY_METHOD **
++libssh2_hostkey_methods(void)
++{
++ return _libssh2_hostkey_methods;
++}
++
++/* {{{ libssh2_hostkey_hash
++ * Returns hash signature
++ * Returned buffer should NOT be freed
++ * Length of buffer is determined by hash type
++ * i.e. MD5 == 16, SHA1 == 20
++ */
++LIBSSH2_API const char *
++libssh2_hostkey_hash(LIBSSH2_SESSION * session, int hash_type)
++{
++ switch (hash_type) {
++#if LIBSSH2_MD5
++ case LIBSSH2_HOSTKEY_HASH_MD5:
++ return (char *) session->server_hostkey_md5;
++ break;
++#endif /* LIBSSH2_MD5 */
++ case LIBSSH2_HOSTKEY_HASH_SHA1:
++ return (char *) session->server_hostkey_sha1;
++ break;
++ default:
++ return NULL;
++ }
++}
++
++/* }}} */
+
+Property changes on: libssh2/src/hostkey.c
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.2
+Added: svn:eol-style
+ + native
+
+Index: libssh2/src/publickey.c
+===================================================================
+--- libssh2/src/publickey.c (.../tags/RELEASE_0_11_0)
++++ libssh2/src/publickey.c (.../trunk)
+@@ -0,0 +1,1094 @@
++/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
++ * 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_publickey.h"
++
++#define LIBSSH2_PUBLICKEY_VERSION 2
++
++/* Numericised response codes -- Not IETF standard, just a local representation */
++#define LIBSSH2_PUBLICKEY_RESPONSE_STATUS 0
++#define LIBSSH2_PUBLICKEY_RESPONSE_VERSION 1
++#define LIBSSH2_PUBLICKEY_RESPONSE_PUBLICKEY 2
++
++typedef struct _LIBSSH2_PUBLICKEY_CODE_LIST
++{
++ int code;
++ const char *name;
++ int name_len;
++} LIBSSH2_PUBLICKEY_CODE_LIST;
++
++static const LIBSSH2_PUBLICKEY_CODE_LIST libssh2_publickey_response_codes[] = {
++ {LIBSSH2_PUBLICKEY_RESPONSE_STATUS, "status", sizeof("status") - 1}
++ ,
++ {LIBSSH2_PUBLICKEY_RESPONSE_VERSION, "version", sizeof("version") - 1}
++ ,
++ {LIBSSH2_PUBLICKEY_RESPONSE_PUBLICKEY, "publickey", sizeof("publickey") - 1}
++ ,
++ {0, NULL, 0}
++};
++
++/* PUBLICKEY status codes -- IETF defined */
++#define LIBSSH2_PUBLICKEY_SUCCESS 0
++#define LIBSSH2_PUBLICKEY_ACCESS_DENIED 1
++#define LIBSSH2_PUBLICKEY_STORAGE_EXCEEDED 2
++#define LIBSSH2_PUBLICKEY_VERSION_NOT_SUPPORTED 3
++#define LIBSSH2_PUBLICKEY_KEY_NOT_FOUND 4
++#define LIBSSH2_PUBLICKEY_KEY_NOT_SUPPORTED 5
++#define LIBSSH2_PUBLICKEY_KEY_ALREADY_PRESENT 6
++#define LIBSSH2_PUBLICKEY_GENERAL_FAILURE 7
++#define LIBSSH2_PUBLICKEY_REQUEST_NOT_SUPPORTED 8
++
++#define LIBSSH2_PUBLICKEY_STATUS_CODE_MAX 8
++
++static const LIBSSH2_PUBLICKEY_CODE_LIST libssh2_publickey_status_codes[] = {
++ {LIBSSH2_PUBLICKEY_SUCCESS, "success", sizeof("success") - 1}
++ ,
++ {LIBSSH2_PUBLICKEY_ACCESS_DENIED, "access denied",
++ sizeof("access denied") - 1}
++ ,
++ {LIBSSH2_PUBLICKEY_STORAGE_EXCEEDED, "storage exceeded",
++ sizeof("storage exceeded") - 1}
++ ,
++ {LIBSSH2_PUBLICKEY_VERSION_NOT_SUPPORTED, "version not supported",
++ sizeof("version not supported") - 1}
++ ,
++ {LIBSSH2_PUBLICKEY_KEY_NOT_FOUND, "key not found",
++ sizeof("key not found") - 1}
++ ,
++ {LIBSSH2_PUBLICKEY_KEY_NOT_SUPPORTED, "key not supported",
++ sizeof("key not supported") - 1}
++ ,
++ {LIBSSH2_PUBLICKEY_KEY_ALREADY_PRESENT, "key already present",
++ sizeof("key already present") - 1}
++ ,
++ {LIBSSH2_PUBLICKEY_GENERAL_FAILURE, "general failure",
++ sizeof("general failure") - 1}
++ ,
++ {LIBSSH2_PUBLICKEY_REQUEST_NOT_SUPPORTED, "request not supported",
++ sizeof("request not supported") - 1}
++ ,
++ {0, NULL, 0}
++};
++
++/* {{{ libssh2_publickey_status_error
++ * Format an error message from a status code
++ */
++#define LIBSSH2_PUBLICKEY_STATUS_TEXT_START "Publickey Subsystem Error: \""
++#define LIBSSH2_PUBLICKEY_STATUS_TEXT_MID "\" Server Reports: \""
++#define LIBSSH2_PUBLICKEY_STATUS_TEXT_END "\""
++static void
++libssh2_publickey_status_error(const LIBSSH2_PUBLICKEY * pkey,
++ LIBSSH2_SESSION * session, int status,
++ const unsigned char *message, int message_len)
++{
++ const char *status_text;
++ int status_text_len;
++ char *m, *s;
++ int m_len;
++
++ /* GENERAL_FAILURE got remapped between version 1 and 2 */
++ if (status == 6 && pkey && pkey->version == 1) {
++ status = 7;
++ }
++
++ if (status < 0 || status > LIBSSH2_PUBLICKEY_STATUS_CODE_MAX) {
++ status_text = "unknown";
++ status_text_len = sizeof("unknown") - 1;
++ } else {
++ status_text = libssh2_publickey_status_codes[status].name;
++ status_text_len = libssh2_publickey_status_codes[status].name_len;
++ }
++
++ m_len =
++ (sizeof(LIBSSH2_PUBLICKEY_STATUS_TEXT_START) - 1) + status_text_len +
++ (sizeof(LIBSSH2_PUBLICKEY_STATUS_TEXT_MID) - 1) + message_len +
++ (sizeof(LIBSSH2_PUBLICKEY_STATUS_TEXT_END) - 1);
++ m = LIBSSH2_ALLOC(session, m_len + 1);
++ if (!m) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for status message", 0);
++ return;
++ }
++ s = m;
++ memcpy(s, LIBSSH2_PUBLICKEY_STATUS_TEXT_START,
++ sizeof(LIBSSH2_PUBLICKEY_STATUS_TEXT_START) - 1);
++ s += sizeof(LIBSSH2_PUBLICKEY_STATUS_TEXT_START) - 1;
++ memcpy(s, status_text, status_text_len);
++ s += status_text_len;
++ memcpy(s, LIBSSH2_PUBLICKEY_STATUS_TEXT_MID,
++ sizeof(LIBSSH2_PUBLICKEY_STATUS_TEXT_MID) - 1);
++ s += sizeof(LIBSSH2_PUBLICKEY_STATUS_TEXT_MID) - 1;
++ memcpy(s, message, message_len);
++ s += message_len;
++ memcpy(s, LIBSSH2_PUBLICKEY_STATUS_TEXT_END,
++ sizeof(LIBSSH2_PUBLICKEY_STATUS_TEXT_END) - 1);
++ s += sizeof(LIBSSH2_PUBLICKEY_STATUS_TEXT_END);
++ libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL, m, 1);
++}
++
++/* }}} */
++
++/* {{{ libssh2_publickey_packet_receive
++ * Read a packet from the subsystem
++ */
++static int
++libssh2_publickey_packet_receive(LIBSSH2_PUBLICKEY * pkey,
++ unsigned char **data, unsigned long *data_len)
++{
++ LIBSSH2_CHANNEL *channel = pkey->channel;
++ LIBSSH2_SESSION *session = channel->session;
++ unsigned char buffer[4];
++ int rc;
++
++ if (pkey->receive_state == libssh2_NB_state_idle) {
++ rc = libssh2_channel_read_ex(channel, 0, (char *) buffer, 4);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc != 4) {
++ libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
++ "Invalid response from publickey subsystem", 0);
++ return -1;
++ }
++
++ pkey->receive_packet_len = libssh2_ntohu32(buffer);
++ pkey->receive_packet =
++ LIBSSH2_ALLOC(session, pkey->receive_packet_len);
++ if (!pkey->receive_packet) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate publickey response buffer", 0);
++ return -1;
++ }
++
++ pkey->receive_state = libssh2_NB_state_sent;
++ }
++
++ if (pkey->receive_state == libssh2_NB_state_sent) {
++ rc = libssh2_channel_read_ex(channel, 0, (char *) pkey->receive_packet,
++ pkey->receive_packet_len);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc != (int)pkey->receive_packet_len) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT,
++ "Timeout waiting for publickey subsystem response packet",
++ 0);
++ LIBSSH2_FREE(session, pkey->receive_packet);
++ pkey->receive_packet = NULL;
++ pkey->receive_state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ *data = pkey->receive_packet;
++ *data_len = pkey->receive_packet_len;
++ }
++
++ pkey->receive_state = libssh2_NB_state_idle;
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_publickey_response_id
++ * Translate a string response name to a numeric code
++ * Data will be incremented by 4 + response_len on success only
++ */
++static int
++libssh2_publickey_response_id(unsigned char **pdata, int data_len)
++{
++ unsigned long response_len;
++ unsigned char *data = *pdata;
++ const LIBSSH2_PUBLICKEY_CODE_LIST *codes =
++ libssh2_publickey_response_codes;
++
++ if (data_len < 4) {
++ /* Malformed response */
++ return -1;
++ }
++ response_len = libssh2_ntohu32(data);
++ data += 4;
++ data_len -= 4;
++ if (data_len < (int)response_len) {
++ /* Malformed response */
++ return -1;
++ }
++
++ while (codes->name) {
++ if ((unsigned long)codes->name_len == response_len &&
++ strncmp(codes->name, (char *) data, response_len) == 0) {
++ *pdata = data + response_len;
++ return codes->code;
++ }
++ codes++;
++ }
++
++ return -1;
++}
++
++/* }}} */
++
++/* {{{ libssh2_publickey_response_success
++ * Generic helper routine to wait for success response and nothing else
++ */
++static int
++libssh2_publickey_response_success(LIBSSH2_PUBLICKEY * pkey)
++{
++ LIBSSH2_SESSION *session = pkey->channel->session;
++ unsigned char *data, *s;
++ unsigned long data_len;
++ int response;
++ int rc;
++
++ while (1) {
++ rc = libssh2_publickey_packet_receive(pkey, &data, &data_len);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT,
++ "Timeout waiting for response from publickey subsystem",
++ 0);
++ return -1;
++ }
++
++ s = data;
++ if ((response = libssh2_publickey_response_id(&s, data_len)) < 0) {
++ libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
++ "Invalid publickey subsystem response code", 0);
++ LIBSSH2_FREE(session, data);
++ return -1;
++ }
++
++ switch (response) {
++ case LIBSSH2_PUBLICKEY_RESPONSE_STATUS:
++ /* Error, or processing complete */
++ {
++ unsigned long status, descr_len, lang_len;
++ unsigned char *descr, *lang;
++
++ status = libssh2_ntohu32(s);
++ s += 4;
++ descr_len = libssh2_ntohu32(s);
++ s += 4;
++ descr = s;
++ s += descr_len;
++ lang_len = libssh2_ntohu32(s);
++ s += 4;
++ lang = s;
++ s += lang_len;
++
++ if (s > data + data_len) {
++ libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
++ "Malformed publickey subsystem packet", 0);
++ LIBSSH2_FREE(session, data);
++ return -1;
++ }
++
++ if (status == LIBSSH2_PUBLICKEY_SUCCESS) {
++ LIBSSH2_FREE(session, data);
++ return 0;
++ }
++
++ libssh2_publickey_status_error(pkey, session, status, descr,
++ descr_len);
++ LIBSSH2_FREE(session, data);
++ return -1;
++ }
++ default:
++ /* Unknown/Unexpected */
++ libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
++ "Unexpected publickey subsystem response, ignoring",
++ 0);
++ LIBSSH2_FREE(session, data);
++ data = NULL;
++ }
++ }
++ /* never reached, but include `return` to silence compiler warnings */
++ return -1;
++}
++
++/* }}} */
++
++
++/* *****************
++ * Publickey API *
++ ***************** */
++
++/* {{{ libssh2_publickey_init
++ * Startup the publickey subsystem
++ */
++LIBSSH2_API LIBSSH2_PUBLICKEY *
++libssh2_publickey_init(LIBSSH2_SESSION * session)
++{
++ /* 19 = packet_len(4) + version_len(4) + "version"(7) + version_num(4) */
++ unsigned char buffer[19];
++ unsigned char *s;
++ int response;
++ int rc;
++
++ if (session->pkeyInit_state == libssh2_NB_state_idle) {
++ session->pkeyInit_data = NULL;
++ session->pkeyInit_pkey = NULL;
++ session->pkeyInit_channel = NULL;
++
++ _libssh2_debug(session, LIBSSH2_DBG_PUBLICKEY,
++ "Initializing publickey subsystem");
++
++ session->pkeyInit_state = libssh2_NB_state_allocated;
++ }
++
++ if (session->pkeyInit_state == libssh2_NB_state_allocated) {
++ do {
++ session->pkeyInit_channel =
++ libssh2_channel_open_ex(session, "session",
++ sizeof("session") - 1,
++ LIBSSH2_CHANNEL_WINDOW_DEFAULT,
++ LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL,
++ 0);
++ if (!session->pkeyInit_channel
++ && (libssh2_session_last_errno(session) ==
++ LIBSSH2_ERROR_EAGAIN)) {
++ /* The error state is already set, so leave it */
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block to startup channel", 0);
++ return NULL;
++ } else if (!session->pkeyInit_channel
++ && (libssh2_session_last_errno(session) !=
++ LIBSSH2_ERROR_EAGAIN)) {
++ libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE,
++ "Unable to startup channel", 0);
++ goto err_exit;
++ }
++ } while (!session->pkeyInit_channel);
++
++ session->pkeyInit_state = libssh2_NB_state_sent;
++ }
++
++ if (session->pkeyInit_state == libssh2_NB_state_sent) {
++ rc = libssh2_channel_process_startup(session->pkeyInit_channel,
++ "subsystem",
++ sizeof("subsystem") - 1,
++ "publickey", strlen("publickey"));
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block starting publickey subsystem", 0);
++ return NULL;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE,
++ "Unable to request publickey subsystem", 0);
++ goto err_exit;
++ }
++
++ session->pkeyInit_state = libssh2_NB_state_sent1;
++ }
++
++ if (session->pkeyInit_state == libssh2_NB_state_sent1) {
++ rc = libssh2_channel_handle_extended_data2(session->pkeyInit_channel,
++ LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block starting publickey subsystem", 0);
++ return NULL;
++ }
++
++ session->pkeyInit_pkey =
++ LIBSSH2_ALLOC(session, sizeof(LIBSSH2_PUBLICKEY));
++ if (!session->pkeyInit_pkey) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate a new publickey structure", 0);
++ goto err_exit;
++ }
++ memset(session->pkeyInit_pkey, 0, sizeof(LIBSSH2_PUBLICKEY));
++ session->pkeyInit_pkey->channel = session->pkeyInit_channel;
++ session->pkeyInit_pkey->version = 0;
++
++ s = buffer;
++ libssh2_htonu32(s, 4 + (sizeof("version") - 1) + 4);
++ s += 4;
++ libssh2_htonu32(s, sizeof("version") - 1);
++ s += 4;
++ memcpy(s, "version", sizeof("version") - 1);
++ s += sizeof("version") - 1;
++ libssh2_htonu32(s, LIBSSH2_PUBLICKEY_VERSION);
++ s += 4;
++
++ _libssh2_debug(session, LIBSSH2_DBG_PUBLICKEY,
++ "Sending publickey version packet advertising version %d support",
++ (int) LIBSSH2_PUBLICKEY_VERSION);
++
++ session->pkeyInit_state = libssh2_NB_state_sent2;
++ }
++
++ if (session->pkeyInit_state == libssh2_NB_state_sent2) {
++ rc = libssh2_channel_write_ex(session->pkeyInit_channel, 0,
++ (char *) buffer, (s - buffer));
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block sending publickey version packet", 0);
++ return NULL;
++ } else if ((s - buffer) != rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send publickey version packet", 0);
++ goto err_exit;
++ }
++
++ session->pkeyInit_state = libssh2_NB_state_sent3;
++ }
++
++ if (session->pkeyInit_state == libssh2_NB_state_sent3) {
++ while (1) {
++ rc = libssh2_publickey_packet_receive(session->pkeyInit_pkey,
++ &session->pkeyInit_data,
++ &session->pkeyInit_data_len);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block waiting for response from publickey subsystem",
++ 0);
++ return NULL;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT,
++ "Timeout waiting for response from publickey subsystem",
++ 0);
++ goto err_exit;
++ }
++
++ s = session->pkeyInit_data;
++ if ((response =
++ libssh2_publickey_response_id(&s,
++ session->pkeyInit_data_len)) <
++ 0) {
++ libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
++ "Invalid publickey subsystem response code", 0);
++ goto err_exit;
++ }
++
++ switch (response) {
++ case LIBSSH2_PUBLICKEY_RESPONSE_STATUS:
++ /* Error */
++ {
++ unsigned long status, descr_len, lang_len;
++ unsigned char *descr, *lang;
++
++ status = libssh2_ntohu32(s);
++ s += 4;
++ descr_len = libssh2_ntohu32(s);
++ s += 4;
++ descr = s;
++ s += descr_len;
++ lang_len = libssh2_ntohu32(s);
++ s += 4;
++ lang = s;
++ s += lang_len;
++
++ if (s >
++ session->pkeyInit_data + session->pkeyInit_data_len) {
++ libssh2_error(session,
++ LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
++ "Malformed publickey subsystem packet",
++ 0);
++ goto err_exit;
++ }
++
++ libssh2_publickey_status_error(NULL, session, status,
++ descr, descr_len);
++ goto err_exit;
++ }
++
++ case LIBSSH2_PUBLICKEY_RESPONSE_VERSION:
++ /* What we want */
++ session->pkeyInit_pkey->version = libssh2_ntohu32(s);
++ if (session->pkeyInit_pkey->version >
++ LIBSSH2_PUBLICKEY_VERSION) {
++ _libssh2_debug(session, LIBSSH2_DBG_PUBLICKEY,
++ "Truncating remote publickey version from %lu",
++ session->pkeyInit_pkey->version);
++ session->pkeyInit_pkey->version =
++ LIBSSH2_PUBLICKEY_VERSION;
++ }
++ _libssh2_debug(session, LIBSSH2_DBG_PUBLICKEY,
++ "Enabling publickey subsystem version %lu",
++ session->pkeyInit_pkey->version);
++ LIBSSH2_FREE(session, session->pkeyInit_data);
++ session->pkeyInit_data = NULL;
++ session->pkeyInit_state = libssh2_NB_state_idle;
++ return session->pkeyInit_pkey;
++
++ default:
++ /* Unknown/Unexpected */
++ libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
++ "Unexpected publickey subsystem response, ignoring",
++ 0);
++ LIBSSH2_FREE(session, session->pkeyInit_data);
++ session->pkeyInit_data = NULL;
++ }
++ }
++ }
++
++ /* Never reached except by direct goto */
++ err_exit:
++ session->pkeyInit_state = libssh2_NB_state_sent4;
++ if (session->pkeyInit_channel) {
++ rc = libssh2_channel_close(session->pkeyInit_channel);
++ if (rc == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block closing channel", 0);
++ return NULL;
++ }
++ }
++ if (session->pkeyInit_pkey) {
++ LIBSSH2_FREE(session, session->pkeyInit_pkey);
++ session->pkeyInit_pkey = NULL;
++ }
++ if (session->pkeyInit_data) {
++ LIBSSH2_FREE(session, session->pkeyInit_data);
++ session->pkeyInit_data = NULL;
++ }
++ session->pkeyInit_state = libssh2_NB_state_idle;
++ return NULL;
++}
++
++/* }}} */
++
++/* {{{ libssh2_publickey_add_ex
++ * Add a new public key entry
++ */
++LIBSSH2_API int
++libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY * pkey, const unsigned char *name,
++ unsigned long name_len, const unsigned char *blob,
++ unsigned long blob_len, char overwrite,
++ unsigned long num_attrs,
++ const libssh2_publickey_attribute attrs[])
++{
++ LIBSSH2_CHANNEL *channel = pkey->channel;
++ LIBSSH2_SESSION *session = channel->session;
++ /* 19 = packet_len(4) + add_len(4) + "add"(3) + name_len(4) + {name} blob_len(4) + {blob} */
++ unsigned long i, packet_len = 19 + name_len + blob_len;
++ unsigned char *comment = NULL;
++ unsigned long comment_len = 0;
++ int rc;
++
++ if (pkey->add_state == libssh2_NB_state_idle) {
++ pkey->add_packet = NULL;
++
++ _libssh2_debug(session, LIBSSH2_DBG_PUBLICKEY, "Adding %s publickey",
++ name);
++
++ if (pkey->version == 1) {
++ for(i = 0; i < num_attrs; i++) {
++ /* Search for a comment attribute */
++ if (attrs[i].name_len == (sizeof("comment") - 1) &&
++ strncmp(attrs[i].name, "comment",
++ sizeof("comment") - 1) == 0) {
++ comment = (unsigned char *) attrs[i].value;
++ comment_len = attrs[i].value_len;
++ break;
++ }
++ }
++ packet_len += 4 + comment_len;
++ } else {
++ packet_len += 5; /* overwrite(1) + attribute_count(4) */
++ for(i = 0; i < num_attrs; i++) {
++ packet_len += 9 + attrs[i].name_len + attrs[i].value_len;
++ /* name_len(4) + value_len(4) + mandatory(1) */
++ }
++ }
++
++ pkey->add_packet = LIBSSH2_ALLOC(session, packet_len);
++ if (!pkey->add_packet) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for publickey \"add\" packet",
++ 0);
++ return -1;
++ }
++
++ pkey->add_s = pkey->add_packet;
++ libssh2_htonu32(pkey->add_s, packet_len - 4);
++ pkey->add_s += 4;
++ libssh2_htonu32(pkey->add_s, sizeof("add") - 1);
++ pkey->add_s += 4;
++ memcpy(pkey->add_s, "add", sizeof("add") - 1);
++ pkey->add_s += sizeof("add") - 1;
++ if (pkey->version == 1) {
++ libssh2_htonu32(pkey->add_s, comment_len);
++ pkey->add_s += 4;
++ if (comment) {
++ memcpy(pkey->add_s, comment, comment_len);
++ pkey->add_s += comment_len;
++ }
++
++ libssh2_htonu32(pkey->add_s, name_len);
++ pkey->add_s += 4;
++ memcpy(pkey->add_s, name, name_len);
++ pkey->add_s += name_len;
++ libssh2_htonu32(pkey->add_s, blob_len);
++ pkey->add_s += 4;
++ memcpy(pkey->add_s, blob, blob_len);
++ pkey->add_s += blob_len;
++ } else {
++ /* Version == 2 */
++
++ libssh2_htonu32(pkey->add_s, name_len);
++ pkey->add_s += 4;
++ memcpy(pkey->add_s, name, name_len);
++ pkey->add_s += name_len;
++ libssh2_htonu32(pkey->add_s, blob_len);
++ pkey->add_s += 4;
++ memcpy(pkey->add_s, blob, blob_len);
++ pkey->add_s += blob_len;
++ *(pkey->add_s++) = overwrite ? 0x01 : 0;
++ libssh2_htonu32(pkey->add_s, num_attrs);
++ pkey->add_s += 4;
++ for(i = 0; i < num_attrs; i++) {
++ libssh2_htonu32(pkey->add_s, attrs[i].name_len);
++ pkey->add_s += 4;
++ memcpy(pkey->add_s, attrs[i].name, attrs[i].name_len);
++ pkey->add_s += attrs[i].name_len;
++ libssh2_htonu32(pkey->add_s, attrs[i].value_len);
++ pkey->add_s += 4;
++ memcpy(pkey->add_s, attrs[i].value, attrs[i].value_len);
++ pkey->add_s += attrs[i].value_len;
++ *(pkey->add_s++) = attrs[i].mandatory ? 0x01 : 0;
++ }
++ }
++
++ _libssh2_debug(session, LIBSSH2_DBG_PUBLICKEY,
++ "Sending publickey \"add\" packet: type=%s blob_len=%ld num_attrs=%ld",
++ name, blob_len, num_attrs);
++
++ pkey->add_state = libssh2_NB_state_created;
++ }
++
++ if (pkey->add_state == libssh2_NB_state_created) {
++ rc = libssh2_channel_write_ex(channel, 0, (char *) pkey->add_packet,
++ (pkey->add_s - pkey->add_packet));
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if ((pkey->add_s - pkey->add_packet) != rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send publickey add packet", 0);
++ LIBSSH2_FREE(session, pkey->add_packet);
++ pkey->add_packet = NULL;
++ return -1;
++ }
++ LIBSSH2_FREE(session, pkey->add_packet);
++ pkey->add_packet = NULL;
++
++ pkey->add_state = libssh2_NB_state_sent;
++ }
++
++ rc = libssh2_publickey_response_success(pkey);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ }
++
++ pkey->add_state = libssh2_NB_state_idle;
++
++ return rc;
++}
++
++/* }}} */
++
++/* {{{ libssh2_publickey_remove_ex
++ * Remove an existing publickey so that authentication can no longer be performed using it
++ */
++LIBSSH2_API int
++libssh2_publickey_remove_ex(LIBSSH2_PUBLICKEY * pkey,
++ const unsigned char *name, unsigned long name_len,
++ const unsigned char *blob, unsigned long blob_len)
++{
++ LIBSSH2_CHANNEL *channel = pkey->channel;
++ LIBSSH2_SESSION *session = channel->session;
++ /* 22 = packet_len(4) + remove_len(4) + "remove"(6) + name_len(4) + {name} + blob_len(4) + {blob} */
++ unsigned long packet_len = 22 + name_len + blob_len;
++ int rc;
++
++ if (pkey->remove_state == libssh2_NB_state_idle) {
++ pkey->remove_packet = NULL;
++
++ pkey->remove_packet = LIBSSH2_ALLOC(session, packet_len);
++ if (!pkey->remove_packet) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for publickey \"remove\" packet",
++ 0);
++ return -1;
++ }
++
++ pkey->remove_s = pkey->remove_packet;
++ libssh2_htonu32(pkey->remove_s, packet_len - 4);
++ pkey->remove_s += 4;
++ libssh2_htonu32(pkey->remove_s, sizeof("remove") - 1);
++ pkey->remove_s += 4;
++ memcpy(pkey->remove_s, "remove", sizeof("remove") - 1);
++ pkey->remove_s += sizeof("remove") - 1;
++ libssh2_htonu32(pkey->remove_s, name_len);
++ pkey->remove_s += 4;
++ memcpy(pkey->remove_s, name, name_len);
++ pkey->remove_s += name_len;
++ libssh2_htonu32(pkey->remove_s, blob_len);
++ pkey->remove_s += 4;
++ memcpy(pkey->remove_s, blob, blob_len);
++ pkey->remove_s += blob_len;
++
++ _libssh2_debug(session, LIBSSH2_DBG_PUBLICKEY,
++ "Sending publickey \"remove\" packet: type=%s blob_len=%ld",
++ name, blob_len);
++
++ pkey->remove_state = libssh2_NB_state_created;
++ }
++
++ if (pkey->remove_state == libssh2_NB_state_created) {
++ rc = libssh2_channel_write_ex(channel, 0, (char *) pkey->remove_packet,
++ (pkey->remove_s - pkey->remove_packet));
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if ((pkey->remove_s - pkey->remove_packet) != rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send publickey remove packet", 0);
++ LIBSSH2_FREE(session, pkey->remove_packet);
++ pkey->remove_packet = NULL;
++ pkey->remove_state = libssh2_NB_state_idle;
++ return -1;
++ }
++ LIBSSH2_FREE(session, pkey->remove_packet);
++ pkey->remove_packet = NULL;
++
++ pkey->remove_state = libssh2_NB_state_sent;
++ }
++
++ rc = libssh2_publickey_response_success(pkey);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ }
++
++ pkey->remove_state = libssh2_NB_state_idle;
++
++ return rc;
++}
++
++/* }}} */
++
++/* {{{ libssh2_publickey_list_fetch
++ * Fetch a list of supported public key from a server
++ */
++LIBSSH2_API int
++libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
++ libssh2_publickey_list ** pkey_list)
++{
++ LIBSSH2_CHANNEL *channel = pkey->channel;
++ LIBSSH2_SESSION *session = channel->session;
++ libssh2_publickey_list *list = NULL;
++ unsigned long buffer_len = 12, keys = 0, max_keys = 0, i;
++ /* 12 = packet_len(4) + list_len(4) + "list"(4) */
++ int response;
++ int rc;
++
++ if (pkey->listFetch_state == libssh2_NB_state_idle) {
++ pkey->listFetch_data = NULL;
++
++ pkey->listFetch_s = pkey->listFetch_buffer;
++ libssh2_htonu32(pkey->listFetch_s, buffer_len - 4);
++ pkey->listFetch_s += 4;
++ libssh2_htonu32(pkey->listFetch_s, sizeof("list") - 1);
++ pkey->listFetch_s += 4;
++ memcpy(pkey->listFetch_s, "list", sizeof("list") - 1);
++ pkey->listFetch_s += sizeof("list") - 1;
++
++ _libssh2_debug(session, LIBSSH2_DBG_PUBLICKEY,
++ "Sending publickey \"list\" packet");
++
++ pkey->listFetch_state = libssh2_NB_state_created;
++ }
++
++ if (pkey->listFetch_state == libssh2_NB_state_created) {
++ rc = libssh2_channel_write_ex(channel, 0,
++ (char *) pkey->listFetch_buffer,
++ (pkey->listFetch_s -
++ pkey->listFetch_buffer));
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if ((pkey->listFetch_s - pkey->listFetch_buffer) != rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send publickey list packet", 0);
++ pkey->listFetch_state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ pkey->listFetch_state = libssh2_NB_state_sent;
++ }
++
++ while (1) {
++ rc = libssh2_publickey_packet_receive(pkey, &pkey->listFetch_data,
++ &pkey->listFetch_data_len);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT,
++ "Timeout waiting for response from publickey subsystem",
++ 0);
++ goto err_exit;
++ }
++
++ pkey->listFetch_s = pkey->listFetch_data;
++ if ((response =
++ libssh2_publickey_response_id(&pkey->listFetch_s,
++ pkey->listFetch_data_len)) < 0) {
++ libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
++ "Invalid publickey subsystem response code", 0);
++ goto err_exit;
++ }
++
++ switch (response) {
++ case LIBSSH2_PUBLICKEY_RESPONSE_STATUS:
++ /* Error, or processing complete */
++ {
++ unsigned long status, descr_len, lang_len;
++ unsigned char *descr, *lang;
++
++ status = libssh2_ntohu32(pkey->listFetch_s);
++ pkey->listFetch_s += 4;
++ descr_len = libssh2_ntohu32(pkey->listFetch_s);
++ pkey->listFetch_s += 4;
++ descr = pkey->listFetch_s;
++ pkey->listFetch_s += descr_len;
++ lang_len = libssh2_ntohu32(pkey->listFetch_s);
++ pkey->listFetch_s += 4;
++ lang = pkey->listFetch_s;
++ pkey->listFetch_s += lang_len;
++
++ if (pkey->listFetch_s >
++ pkey->listFetch_data + pkey->listFetch_data_len) {
++ libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
++ "Malformed publickey subsystem packet", 0);
++ goto err_exit;
++ }
++
++ if (status == LIBSSH2_PUBLICKEY_SUCCESS) {
++ LIBSSH2_FREE(session, pkey->listFetch_data);
++ pkey->listFetch_data = NULL;
++ *pkey_list = list;
++ *num_keys = keys;
++ pkey->listFetch_state = libssh2_NB_state_idle;
++ return 0;
++ }
++
++ libssh2_publickey_status_error(pkey, session, status, descr,
++ descr_len);
++ goto err_exit;
++ }
++ case LIBSSH2_PUBLICKEY_RESPONSE_PUBLICKEY:
++ /* What we want */
++ if (keys >= max_keys) {
++ libssh2_publickey_list *newlist;
++ /* Grow the key list if necessary */
++ max_keys += 8;
++ newlist =
++ LIBSSH2_REALLOC(session, list,
++ (max_keys +
++ 1) * sizeof(libssh2_publickey_list));
++ if (!newlist) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for publickey list",
++ 0);
++ goto err_exit;
++ }
++ list = newlist;
++ }
++ if (pkey->version == 1) {
++ unsigned long comment_len;
++
++ comment_len = libssh2_ntohu32(pkey->listFetch_s);
++ pkey->listFetch_s += 4;
++ if (comment_len) {
++ list[keys].num_attrs = 1;
++ list[keys].attrs =
++ LIBSSH2_ALLOC(session,
++ sizeof(libssh2_publickey_attribute));
++ if (!list[keys].attrs) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for publickey attributes",
++ 0);
++ goto err_exit;
++ }
++ list[keys].attrs[0].name = "comment";
++ list[keys].attrs[0].name_len = sizeof("comment") - 1;
++ list[keys].attrs[0].value = (char *) pkey->listFetch_s;
++ list[keys].attrs[0].value_len = comment_len;
++ list[keys].attrs[0].mandatory = 0;
++
++ pkey->listFetch_s += comment_len;
++ } else {
++ list[keys].num_attrs = 0;
++ list[keys].attrs = NULL;
++ }
++ list[keys].name_len = libssh2_ntohu32(pkey->listFetch_s);
++ pkey->listFetch_s += 4;
++ list[keys].name = pkey->listFetch_s;
++ pkey->listFetch_s += list[keys].name_len;
++ list[keys].blob_len = libssh2_ntohu32(pkey->listFetch_s);
++ pkey->listFetch_s += 4;
++ list[keys].blob = pkey->listFetch_s;
++ pkey->listFetch_s += list[keys].blob_len;
++ } else {
++ /* Version == 2 */
++ list[keys].name_len = libssh2_ntohu32(pkey->listFetch_s);
++ pkey->listFetch_s += 4;
++ list[keys].name = pkey->listFetch_s;
++ pkey->listFetch_s += list[keys].name_len;
++ list[keys].blob_len = libssh2_ntohu32(pkey->listFetch_s);
++ pkey->listFetch_s += 4;
++ list[keys].blob = pkey->listFetch_s;
++ pkey->listFetch_s += list[keys].blob_len;
++ list[keys].num_attrs = libssh2_ntohu32(pkey->listFetch_s);
++ pkey->listFetch_s += 4;
++ if (list[keys].num_attrs) {
++ list[keys].attrs =
++ LIBSSH2_ALLOC(session,
++ list[keys].num_attrs *
++ sizeof(libssh2_publickey_attribute));
++ if (!list[keys].attrs) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for publickey attributes",
++ 0);
++ goto err_exit;
++ }
++ for(i = 0; i < list[keys].num_attrs; i++) {
++ list[keys].attrs[i].name_len =
++ libssh2_ntohu32(pkey->listFetch_s);
++ pkey->listFetch_s += 4;
++ list[keys].attrs[i].name = (char *) pkey->listFetch_s;
++ pkey->listFetch_s += list[keys].attrs[i].name_len;
++ list[keys].attrs[i].value_len =
++ libssh2_ntohu32(pkey->listFetch_s);
++ pkey->listFetch_s += 4;
++ list[keys].attrs[i].value = (char *) pkey->listFetch_s;
++ pkey->listFetch_s += list[keys].attrs[i].value_len;
++ list[keys].attrs[i].mandatory = 0; /* actually an ignored value */
++ }
++ } else {
++ list[keys].attrs = NULL;
++ }
++ }
++ list[keys].packet = pkey->listFetch_data; /* To be FREEd in libssh2_publickey_list_free() */
++ keys++;
++
++ list[keys].packet = NULL; /* Terminate the list */
++ pkey->listFetch_data = NULL;
++ break;
++ default:
++ /* Unknown/Unexpected */
++ libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
++ "Unexpected publickey subsystem response, ignoring",
++ 0);
++ LIBSSH2_FREE(session, pkey->listFetch_data);
++ pkey->listFetch_data = NULL;
++ }
++ }
++
++ /* Only reached via explicit goto */
++ err_exit:
++ if (pkey->listFetch_data) {
++ LIBSSH2_FREE(session, pkey->listFetch_data);
++ pkey->listFetch_data = NULL;
++ }
++ if (list) {
++ libssh2_publickey_list_free(pkey, list);
++ }
++ pkey->listFetch_state = libssh2_NB_state_idle;
++ return -1;
++}
++
++/* }}} */
++
++/* {{{ libssh2_publickey_list_free
++ * Free a previously fetched list of public keys
++ */
++LIBSSH2_API void
++libssh2_publickey_list_free(LIBSSH2_PUBLICKEY * pkey,
++ libssh2_publickey_list * pkey_list)
++{
++ LIBSSH2_SESSION *session = pkey->channel->session;
++ libssh2_publickey_list *p = pkey_list;
++
++ while (p->packet) {
++ if (p->attrs) {
++ LIBSSH2_FREE(session, p->attrs);
++ }
++ LIBSSH2_FREE(session, p->packet);
++ p++;
++ }
++
++ LIBSSH2_FREE(session, pkey_list);
++}
++
++/* }}} */
++
++/* {{{ libssh2_publickey_shutdown
++ * Shutdown the publickey subsystem
++ */
++LIBSSH2_API int
++libssh2_publickey_shutdown(LIBSSH2_PUBLICKEY * pkey)
++{
++ LIBSSH2_SESSION *session = pkey->channel->session;
++
++ /*
++ * Make sure all memory used in the state variables are free
++ */
++ if (pkey->receive_packet) {
++ LIBSSH2_FREE(session, pkey->receive_packet);
++ pkey->receive_packet = NULL;
++ }
++ if (pkey->add_packet) {
++ LIBSSH2_FREE(session, pkey->add_packet);
++ pkey->add_packet = NULL;
++ }
++ if (pkey->remove_packet) {
++ LIBSSH2_FREE(session, pkey->remove_packet);
++ pkey->remove_packet = NULL;
++ }
++ if (pkey->listFetch_data) {
++ LIBSSH2_FREE(session, pkey->listFetch_data);
++ pkey->listFetch_data = NULL;
++ }
++
++ if (libssh2_channel_free(pkey->channel) == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ }
++
++ LIBSSH2_FREE(session, pkey);
++ return 0;
++}
++
++/* }}} */
+
+Property changes on: libssh2/src/publickey.c
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.4
+Added: svn:eol-style
+ + native
+
+Index: libssh2/src/kex.c
+===================================================================
+--- libssh2/src/kex.c (.../tags/RELEASE_0_11_0)
++++ libssh2/src/kex.c (.../trunk)
+@@ -0,0 +1,1916 @@
++/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
++ * 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"
++
++/* TODO: Switch this to an inline and handle alloc() failures */
++/* Helper macro called from libssh2_kex_method_diffie_hellman_group1_sha1_key_exchange */
++#define LIBSSH2_KEX_METHOD_DIFFIE_HELLMAN_SHA1_HASH(value, reqlen, version) \
++{ \
++ libssh2_sha1_ctx hash; \
++ unsigned long len = 0; \
++ if (!(value)) { \
++ value = LIBSSH2_ALLOC(session, reqlen + SHA_DIGEST_LENGTH); \
++ } \
++ if (value) \
++ while (len < (unsigned long)reqlen) { \
++ libssh2_sha1_init(&hash); \
++ libssh2_sha1_update(hash, exchange_state->k_value, \
++ exchange_state->k_value_len); \
++ libssh2_sha1_update(hash, exchange_state->h_sig_comp, \
++ SHA_DIGEST_LENGTH); \
++ if (len > 0) { \
++ libssh2_sha1_update(hash, value, len); \
++ } else { \
++ libssh2_sha1_update(hash, (version), 1); \
++ libssh2_sha1_update(hash, session->session_id, \
++ session->session_id_len); \
++ } \
++ libssh2_sha1_final(hash, (value) + len); \
++ len += SHA_DIGEST_LENGTH; \
++ } \
++}
++
++/* {{{ libssh2_kex_method_diffie_hellman_groupGP_sha1_key_exchange
++ * Diffie Hellman Key Exchange, Group Agnostic
++ */
++static int
++libssh2_kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_SESSION *
++ session,
++ _libssh2_bn * g,
++ _libssh2_bn * p,
++ int group_order,
++ unsigned char
++ packet_type_init,
++ unsigned char
++ packet_type_reply,
++ unsigned char
++ *midhash,
++ unsigned long
++ midhash_len,
++ kmdhgGPsha1kex_state_t
++ * exchange_state)
++{
++ int ret = 0;
++ int rc;
++
++ if (exchange_state->state == libssh2_NB_state_idle) {
++ /* Setup initial values */
++ exchange_state->e_packet = NULL;
++ exchange_state->s_packet = NULL;
++ exchange_state->k_value = NULL;
++ exchange_state->ctx = _libssh2_bn_ctx_new();
++ exchange_state->x = _libssh2_bn_init(); /* Random from client */
++ exchange_state->e = _libssh2_bn_init(); /* g^x mod p */
++ exchange_state->f = _libssh2_bn_init(); /* g^(Random from server) mod p */
++ exchange_state->k = _libssh2_bn_init(); /* The shared secret: f^x mod p */
++
++ /* Zero the whole thing out */
++ memset(&exchange_state->req_state, 0, sizeof(packet_require_state_t));
++
++ /* Generate x and e */
++ _libssh2_bn_rand(exchange_state->x, group_order, 0, -1);
++ _libssh2_bn_mod_exp(exchange_state->e, g, exchange_state->x, p,
++ exchange_state->ctx);
++
++ /* Send KEX init */
++ /* packet_type(1) + String Length(4) + leading 0(1) */
++ exchange_state->e_packet_len =
++ _libssh2_bn_bytes(exchange_state->e) + 6;
++ if (_libssh2_bn_bits(exchange_state->e) % 8) {
++ /* Leading 00 not needed */
++ exchange_state->e_packet_len--;
++ }
++
++ exchange_state->e_packet =
++ LIBSSH2_ALLOC(session, exchange_state->e_packet_len);
++ if (!exchange_state->e_packet) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Out of memory error",
++ 0);
++ ret = -1;
++ goto clean_exit;
++ }
++ exchange_state->e_packet[0] = packet_type_init;
++ libssh2_htonu32(exchange_state->e_packet + 1,
++ exchange_state->e_packet_len - 5);
++ if (_libssh2_bn_bits(exchange_state->e) % 8) {
++ _libssh2_bn_to_bin(exchange_state->e,
++ exchange_state->e_packet + 5);
++ } else {
++ exchange_state->e_packet[5] = 0;
++ _libssh2_bn_to_bin(exchange_state->e,
++ exchange_state->e_packet + 6);
++ }
++
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Sending KEX packet %d",
++ (int) packet_type_init);
++ exchange_state->state = libssh2_NB_state_created;
++ }
++
++ if (exchange_state->state == libssh2_NB_state_created) {
++ rc = libssh2_packet_write(session, exchange_state->e_packet,
++ exchange_state->e_packet_len);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send KEX init message", 0);
++ ret = -1;
++ goto clean_exit;
++ }
++ exchange_state->state = libssh2_NB_state_sent;
++ }
++
++ if (exchange_state->state == libssh2_NB_state_sent) {
++ if (session->burn_optimistic_kexinit) {
++ /* The first KEX packet to come along will be the guess initially
++ * sent by the server. That guess turned out to be wrong so we
++ * need to silently ignore it */
++ int burn_type;
++
++ _libssh2_debug(session, LIBSSH2_DBG_KEX,
++ "Waiting for badly guessed KEX packet (to be ignored)");
++ burn_type =
++ libssh2_packet_burn(session, &exchange_state->burn_state);
++ if (burn_type == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (burn_type <= 0) {
++ /* Failed to receive a packet */
++ ret = -1;
++ goto clean_exit;
++ }
++ session->burn_optimistic_kexinit = 0;
++
++ _libssh2_debug(session, LIBSSH2_DBG_KEX,
++ "Burnt packet of type: %02x",
++ (unsigned int) burn_type);
++ }
++
++ exchange_state->state = libssh2_NB_state_sent1;
++ }
++
++ if (exchange_state->state == libssh2_NB_state_sent1) {
++ /* Wait for KEX reply */
++ rc = libssh2_packet_require_ex(session, packet_type_reply,
++ &exchange_state->s_packet,
++ &exchange_state->s_packet_len, 0, NULL,
++ 0, &exchange_state->req_state);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ }
++ if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_TIMEOUT,
++ "Timed out waiting for KEX reply", 0);
++ ret = -1;
++ goto clean_exit;
++ }
++
++ /* Parse KEXDH_REPLY */
++ exchange_state->s = exchange_state->s_packet + 1;
++
++ session->server_hostkey_len = libssh2_ntohu32(exchange_state->s);
++ exchange_state->s += 4;
++ session->server_hostkey =
++ LIBSSH2_ALLOC(session, session->server_hostkey_len);
++ if (!session->server_hostkey) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory for a copy of the host key",
++ 0);
++ ret = -1;
++ goto clean_exit;
++ }
++ memcpy(session->server_hostkey, exchange_state->s,
++ session->server_hostkey_len);
++ exchange_state->s += session->server_hostkey_len;
++
++#if LIBSSH2_MD5
++ {
++ libssh2_md5_ctx fingerprint_ctx;
++
++ libssh2_md5_init(&fingerprint_ctx);
++ libssh2_md5_update(fingerprint_ctx, session->server_hostkey,
++ session->server_hostkey_len);
++ libssh2_md5_final(fingerprint_ctx, session->server_hostkey_md5);
++ }
++#ifdef LIBSSH2DEBUG
++ {
++ char fingerprint[50], *fprint = fingerprint;
++ int i;
++ for(i = 0; i < 16; i++, fprint += 3) {
++ snprintf(fprint, 4, "%02x:", session->server_hostkey_md5[i]);
++ }
++ *(--fprint) = '\0';
++ _libssh2_debug(session, LIBSSH2_DBG_KEX,
++ "Server's MD5 Fingerprint: %s", fingerprint);
++ }
++#endif /* LIBSSH2DEBUG */
++#endif /* ! LIBSSH2_MD5 */
++
++ {
++ libssh2_sha1_ctx fingerprint_ctx;
++
++ libssh2_sha1_init(&fingerprint_ctx);
++ libssh2_sha1_update(fingerprint_ctx, session->server_hostkey,
++ session->server_hostkey_len);
++ libssh2_sha1_final(fingerprint_ctx, session->server_hostkey_sha1);
++ }
++#ifdef LIBSSH2DEBUG
++ {
++ char fingerprint[64], *fprint = fingerprint;
++ int i;
++
++ for(i = 0; i < 20; i++, fprint += 3) {
++ snprintf(fprint, 4, "%02x:", session->server_hostkey_sha1[i]);
++ }
++ *(--fprint) = '\0';
++ _libssh2_debug(session, LIBSSH2_DBG_KEX,
++ "Server's SHA1 Fingerprint: %s", fingerprint);
++ }
++#endif /* LIBSSH2DEBUG */
++
++ if (session->hostkey->
++ init(session, session->server_hostkey, session->server_hostkey_len,
++ &session->server_hostkey_abstract)) {
++ libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_INIT,
++ "Unable to initialize hostkey importer", 0);
++ ret = -1;
++ goto clean_exit;
++ }
++
++ exchange_state->f_value_len = libssh2_ntohu32(exchange_state->s);
++ exchange_state->s += 4;
++ exchange_state->f_value = exchange_state->s;
++ exchange_state->s += exchange_state->f_value_len;
++ _libssh2_bn_from_bin(exchange_state->f, exchange_state->f_value_len,
++ exchange_state->f_value);
++
++ exchange_state->h_sig_len = libssh2_ntohu32(exchange_state->s);
++ exchange_state->s += 4;
++ exchange_state->h_sig = exchange_state->s;
++
++ /* Compute the shared secret */
++ _libssh2_bn_mod_exp(exchange_state->k, exchange_state->f,
++ exchange_state->x, p, exchange_state->ctx);
++ exchange_state->k_value_len = _libssh2_bn_bytes(exchange_state->k) + 5;
++ if (_libssh2_bn_bits(exchange_state->k) % 8) {
++ /* don't need leading 00 */
++ exchange_state->k_value_len--;
++ }
++ exchange_state->k_value =
++ LIBSSH2_ALLOC(session, exchange_state->k_value_len);
++ if (!exchange_state->k_value) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate buffer for K", 0);
++ ret = -1;
++ goto clean_exit;
++ }
++ libssh2_htonu32(exchange_state->k_value,
++ exchange_state->k_value_len - 4);
++ if (_libssh2_bn_bits(exchange_state->k) % 8) {
++ _libssh2_bn_to_bin(exchange_state->k, exchange_state->k_value + 4);
++ } else {
++ exchange_state->k_value[4] = 0;
++ _libssh2_bn_to_bin(exchange_state->k, exchange_state->k_value + 5);
++ }
++
++ libssh2_sha1_init(&exchange_state->exchange_hash);
++ if (session->local.banner) {
++ libssh2_htonu32(exchange_state->h_sig_comp,
++ strlen((char *) session->local.banner) - 2);
++ libssh2_sha1_update(exchange_state->exchange_hash,
++ exchange_state->h_sig_comp, 4);
++ libssh2_sha1_update(exchange_state->exchange_hash,
++ (char *) session->local.banner,
++ strlen((char *) session->local.banner) - 2);
++ } else {
++ libssh2_htonu32(exchange_state->h_sig_comp,
++ sizeof(LIBSSH2_SSH_DEFAULT_BANNER) - 1);
++ libssh2_sha1_update(exchange_state->exchange_hash,
++ exchange_state->h_sig_comp, 4);
++ libssh2_sha1_update(exchange_state->exchange_hash,
++ LIBSSH2_SSH_DEFAULT_BANNER,
++ sizeof(LIBSSH2_SSH_DEFAULT_BANNER) - 1);
++ }
++
++ libssh2_htonu32(exchange_state->h_sig_comp,
++ strlen((char *) session->remote.banner));
++ libssh2_sha1_update(exchange_state->exchange_hash,
++ exchange_state->h_sig_comp, 4);
++ libssh2_sha1_update(exchange_state->exchange_hash,
++ session->remote.banner,
++ strlen((char *) session->remote.banner));
++
++ libssh2_htonu32(exchange_state->h_sig_comp,
++ session->local.kexinit_len);
++ libssh2_sha1_update(exchange_state->exchange_hash,
++ exchange_state->h_sig_comp, 4);
++ libssh2_sha1_update(exchange_state->exchange_hash,
++ session->local.kexinit,
++ session->local.kexinit_len);
++
++ libssh2_htonu32(exchange_state->h_sig_comp,
++ session->remote.kexinit_len);
++ libssh2_sha1_update(exchange_state->exchange_hash,
++ exchange_state->h_sig_comp, 4);
++ libssh2_sha1_update(exchange_state->exchange_hash,
++ session->remote.kexinit,
++ session->remote.kexinit_len);
++
++ libssh2_htonu32(exchange_state->h_sig_comp,
++ session->server_hostkey_len);
++ libssh2_sha1_update(exchange_state->exchange_hash,
++ exchange_state->h_sig_comp, 4);
++ libssh2_sha1_update(exchange_state->exchange_hash,
++ session->server_hostkey,
++ session->server_hostkey_len);
++
++ if (packet_type_init == SSH_MSG_KEX_DH_GEX_INIT) {
++ /* diffie-hellman-group-exchange hashes additional fields */
++#ifdef LIBSSH2_DH_GEX_NEW
++ libssh2_htonu32(exchange_state->h_sig_comp,
++ LIBSSH2_DH_GEX_MINGROUP);
++ libssh2_htonu32(exchange_state->h_sig_comp + 4,
++ LIBSSH2_DH_GEX_OPTGROUP);
++ libssh2_htonu32(exchange_state->h_sig_comp + 8,
++ LIBSSH2_DH_GEX_MAXGROUP);
++ libssh2_sha1_update(exchange_state->exchange_hash,
++ exchange_state->h_sig_comp, 12);
++#else
++ libssh2_htonu32(exchange_state->h_sig_comp,
++ LIBSSH2_DH_GEX_OPTGROUP);
++ libssh2_sha1_update(exchange_state->exchange_hash,
++ exchange_state->h_sig_comp, 4);
++#endif
++ }
++
++ if (midhash) {
++ libssh2_sha1_update(exchange_state->exchange_hash, midhash,
++ midhash_len);
++ }
++
++ libssh2_sha1_update(exchange_state->exchange_hash,
++ exchange_state->e_packet + 1,
++ exchange_state->e_packet_len - 1);
++
++ libssh2_htonu32(exchange_state->h_sig_comp,
++ exchange_state->f_value_len);
++ libssh2_sha1_update(exchange_state->exchange_hash,
++ exchange_state->h_sig_comp, 4);
++ libssh2_sha1_update(exchange_state->exchange_hash,
++ exchange_state->f_value,
++ exchange_state->f_value_len);
++
++ libssh2_sha1_update(exchange_state->exchange_hash,
++ exchange_state->k_value,
++ exchange_state->k_value_len);
++
++ libssh2_sha1_final(exchange_state->exchange_hash,
++ exchange_state->h_sig_comp);
++
++ if (session->hostkey->
++ sig_verify(session, exchange_state->h_sig,
++ exchange_state->h_sig_len, exchange_state->h_sig_comp,
++ 20, &session->server_hostkey_abstract)) {
++ libssh2_error(session, LIBSSH2_ERROR_HOSTKEY_SIGN,
++ "Unable to verify hostkey signature", 0);
++ ret = -1;
++ goto clean_exit;
++ }
++
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Sending NEWKEYS message");
++ exchange_state->c = SSH_MSG_NEWKEYS;
++
++ exchange_state->state = libssh2_NB_state_sent2;
++ }
++
++ if (exchange_state->state == libssh2_NB_state_sent2) {
++ rc = libssh2_packet_write(session, &exchange_state->c, 1);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send NEWKEYS message", 0);
++ ret = -1;
++ goto clean_exit;
++ }
++
++ exchange_state->state = libssh2_NB_state_sent3;
++ }
++
++ if (exchange_state->state == libssh2_NB_state_sent3) {
++ rc = libssh2_packet_require_ex(session, SSH_MSG_NEWKEYS,
++ &exchange_state->tmp,
++ &exchange_state->tmp_len, 0, NULL, 0,
++ &exchange_state->req_state);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_TIMEOUT,
++ "Timed out waiting for NEWKEYS", 0);
++ ret = -1;
++ goto clean_exit;
++ }
++ /* The first key exchange has been performed,
++ switch to active crypt/comp/mac mode */
++ session->state |= LIBSSH2_STATE_NEWKEYS;
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Received NEWKEYS message");
++
++ /* This will actually end up being just packet_type(1)
++ for this packet type anyway */
++ LIBSSH2_FREE(session, exchange_state->tmp);
++
++ if (!session->session_id) {
++ session->session_id = LIBSSH2_ALLOC(session, SHA_DIGEST_LENGTH);
++ if (!session->session_id) {
++ ret = -1;
++ goto clean_exit;
++ }
++ memcpy(session->session_id, exchange_state->h_sig_comp,
++ SHA_DIGEST_LENGTH);
++ session->session_id_len = SHA_DIGEST_LENGTH;
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "session_id calculated");
++ }
++
++ /* Cleanup any existing cipher */
++ if (session->local.crypt->dtor) {
++ session->local.crypt->dtor(session,
++ &session->local.crypt_abstract);
++ }
++
++ /* Calculate IV/Secret/Key for each direction */
++ if (session->local.crypt->init) {
++ unsigned char *iv = NULL, *secret = NULL;
++ int free_iv = 0, free_secret = 0;
++
++ LIBSSH2_KEX_METHOD_DIFFIE_HELLMAN_SHA1_HASH(iv,
++ session->local.crypt->
++ iv_len, "A");
++ if (!iv) {
++ ret = -1;
++ goto clean_exit;
++ }
++ LIBSSH2_KEX_METHOD_DIFFIE_HELLMAN_SHA1_HASH(secret,
++ session->local.crypt->
++ secret_len, "C");
++ if (!secret) {
++ LIBSSH2_FREE(session, iv);
++ ret = -1;
++ goto clean_exit;
++ }
++ if (session->local.crypt->
++ init(session, session->local.crypt, iv, &free_iv, secret,
++ &free_secret, 1, &session->local.crypt_abstract)) {
++ LIBSSH2_FREE(session, iv);
++ LIBSSH2_FREE(session, secret);
++ ret = -1;
++ goto clean_exit;
++ }
++
++ if (free_iv) {
++ memset(iv, 0, session->local.crypt->iv_len);
++ LIBSSH2_FREE(session, iv);
++ }
++
++ if (free_secret) {
++ memset(secret, 0, session->local.crypt->secret_len);
++ LIBSSH2_FREE(session, secret);
++ }
++ }
++ _libssh2_debug(session, LIBSSH2_DBG_KEX,
++ "Client to Server IV and Key calculated");
++
++ if (session->remote.crypt->dtor) {
++ /* Cleanup any existing cipher */
++ session->remote.crypt->dtor(session,
++ &session->remote.crypt_abstract);
++ }
++
++ if (session->remote.crypt->init) {
++ unsigned char *iv = NULL, *secret = NULL;
++ int free_iv = 0, free_secret = 0;
++
++ LIBSSH2_KEX_METHOD_DIFFIE_HELLMAN_SHA1_HASH(iv,
++ session->remote.crypt->
++ iv_len, "B");
++ if (!iv) {
++ ret = -1;
++ goto clean_exit;
++ }
++ LIBSSH2_KEX_METHOD_DIFFIE_HELLMAN_SHA1_HASH(secret,
++ session->remote.crypt->
++ secret_len, "D");
++ if (!secret) {
++ LIBSSH2_FREE(session, iv);
++ ret = -1;
++ goto clean_exit;
++ }
++ if (session->remote.crypt->
++ init(session, session->remote.crypt, iv, &free_iv, secret,
++ &free_secret, 0, &session->remote.crypt_abstract)) {
++ LIBSSH2_FREE(session, iv);
++ LIBSSH2_FREE(session, secret);
++ ret = -1;
++ goto clean_exit;
++ }
++
++ if (free_iv) {
++ memset(iv, 0, session->remote.crypt->iv_len);
++ LIBSSH2_FREE(session, iv);
++ }
++
++ if (free_secret) {
++ memset(secret, 0, session->remote.crypt->secret_len);
++ LIBSSH2_FREE(session, secret);
++ }
++ }
++ _libssh2_debug(session, LIBSSH2_DBG_KEX,
++ "Server to Client IV and Key calculated");
++
++ if (session->local.mac->dtor) {
++ session->local.mac->dtor(session, &session->local.mac_abstract);
++ }
++
++ if (session->local.mac->init) {
++ unsigned char *key = NULL;
++ int free_key = 0;
++
++ LIBSSH2_KEX_METHOD_DIFFIE_HELLMAN_SHA1_HASH(key,
++ session->local.mac->
++ key_len, "E");
++ if (!key) {
++ ret = -1;
++ goto clean_exit;
++ }
++ session->local.mac->init(session, key, &free_key,
++ &session->local.mac_abstract);
++
++ if (free_key) {
++ memset(key, 0, session->local.mac->key_len);
++ LIBSSH2_FREE(session, key);
++ }
++ }
++ _libssh2_debug(session, LIBSSH2_DBG_KEX,
++ "Client to Server HMAC Key calculated");
++
++ if (session->remote.mac->dtor) {
++ session->remote.mac->dtor(session, &session->remote.mac_abstract);
++ }
++
++ if (session->remote.mac->init) {
++ unsigned char *key = NULL;
++ int free_key = 0;
++
++ LIBSSH2_KEX_METHOD_DIFFIE_HELLMAN_SHA1_HASH(key,
++ session->remote.mac->
++ key_len, "F");
++ if (!key) {
++ ret = -1;
++ goto clean_exit;
++ }
++ session->remote.mac->init(session, key, &free_key,
++ &session->remote.mac_abstract);
++
++ if (free_key) {
++ memset(key, 0, session->remote.mac->key_len);
++ LIBSSH2_FREE(session, key);
++ }
++ }
++ _libssh2_debug(session, LIBSSH2_DBG_KEX,
++ "Server to Client HMAC Key calculated");
++ }
++
++ clean_exit:
++ _libssh2_bn_free(exchange_state->x);
++ exchange_state->x = NULL;
++ _libssh2_bn_free(exchange_state->e);
++ exchange_state->e = NULL;
++ _libssh2_bn_free(exchange_state->f);
++ exchange_state->f = NULL;
++ _libssh2_bn_free(exchange_state->k);
++ exchange_state->k = NULL;
++ _libssh2_bn_ctx_free(exchange_state->ctx);
++ exchange_state->ctx = NULL;
++
++ if (exchange_state->e_packet) {
++ LIBSSH2_FREE(session, exchange_state->e_packet);
++ exchange_state->e_packet = NULL;
++ }
++
++ if (exchange_state->s_packet) {
++ LIBSSH2_FREE(session, exchange_state->s_packet);
++ exchange_state->s_packet = NULL;
++ }
++
++ if (exchange_state->k_value) {
++ LIBSSH2_FREE(session, exchange_state->k_value);
++ exchange_state->k_value = NULL;
++ }
++
++ if (session->server_hostkey) {
++ LIBSSH2_FREE(session, session->server_hostkey);
++ session->server_hostkey = NULL;
++ }
++
++ exchange_state->state = libssh2_NB_state_idle;
++
++ return ret;
++}
++
++/* }}} */
++
++/* {{{ libssh2_kex_method_diffie_hellman_group1_sha1_key_exchange
++ * Diffie-Hellman Group1 (Actually Group2) Key Exchange using SHA1
++ */
++static int
++libssh2_kex_method_diffie_hellman_group1_sha1_key_exchange(LIBSSH2_SESSION *
++ session,
++ key_exchange_state_low_t
++ * key_state)
++{
++ static const unsigned char p_value[128] = {
++ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
++ 0xC9, 0x0F, 0xDA, 0xA2, 0x21, 0x68, 0xC2, 0x34,
++ 0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1,
++ 0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74,
++ 0x02, 0x0B, 0xBE, 0xA6, 0x3B, 0x13, 0x9B, 0x22,
++ 0x51, 0x4A, 0x08, 0x79, 0x8E, 0x34, 0x04, 0xDD,
++ 0xEF, 0x95, 0x19, 0xB3, 0xCD, 0x3A, 0x43, 0x1B,
++ 0x30, 0x2B, 0x0A, 0x6D, 0xF2, 0x5F, 0x14, 0x37,
++ 0x4F, 0xE1, 0x35, 0x6D, 0x6D, 0x51, 0xC2, 0x45,
++ 0xE4, 0x85, 0xB5, 0x76, 0x62, 0x5E, 0x7E, 0xC6,
++ 0xF4, 0x4C, 0x42, 0xE9, 0xA6, 0x37, 0xED, 0x6B,
++ 0x0B, 0xFF, 0x5C, 0xB6, 0xF4, 0x06, 0xB7, 0xED,
++ 0xEE, 0x38, 0x6B, 0xFB, 0x5A, 0x89, 0x9F, 0xA5,
++ 0xAE, 0x9F, 0x24, 0x11, 0x7C, 0x4B, 0x1F, 0xE6,
++ 0x49, 0x28, 0x66, 0x51, 0xEC, 0xE6, 0x53, 0x81,
++ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
++ };
++
++ int ret;
++
++ if (key_state->state == libssh2_NB_state_idle) {
++ /* g == 2 */
++ key_state->p = _libssh2_bn_init(); /* SSH2 defined value (p_value) */
++ key_state->g = _libssh2_bn_init(); /* SSH2 defined value (2) */
++
++ /* Initialize P and G */
++ _libssh2_bn_set_word(key_state->g, 2);
++ _libssh2_bn_from_bin(key_state->p, 128, p_value);
++
++ _libssh2_debug(session, LIBSSH2_DBG_KEX,
++ "Initiating Diffie-Hellman Group1 Key Exchange");
++
++ key_state->state = libssh2_NB_state_created;
++ }
++
++ ret =
++ libssh2_kex_method_diffie_hellman_groupGP_sha1_key_exchange(session,
++ key_state->
++ g,
++ key_state->
++ p, 128,
++ SSH_MSG_KEXDH_INIT,
++ SSH_MSG_KEXDH_REPLY,
++ NULL, 0,
++ &key_state->
++ exchange_state);
++ if (ret == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ }
++
++ _libssh2_bn_free(key_state->p);
++ key_state->p = NULL;
++ _libssh2_bn_free(key_state->g);
++ key_state->g = NULL;
++ key_state->state = libssh2_NB_state_idle;
++
++ return ret;
++}
++
++/* }}} */
++
++/* {{{ libssh2_kex_method_diffie_hellman_group14_sha1_key_exchange
++ * Diffie-Hellman Group14 Key Exchange using SHA1
++ */
++static int
++libssh2_kex_method_diffie_hellman_group14_sha1_key_exchange(LIBSSH2_SESSION *
++ session,
++ key_exchange_state_low_t
++ * key_state)
++{
++ static const unsigned char p_value[256] = {
++ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
++ 0xC9, 0x0F, 0xDA, 0xA2, 0x21, 0x68, 0xC2, 0x34,
++ 0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1,
++ 0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74,
++ 0x02, 0x0B, 0xBE, 0xA6, 0x3B, 0x13, 0x9B, 0x22,
++ 0x51, 0x4A, 0x08, 0x79, 0x8E, 0x34, 0x04, 0xDD,
++ 0xEF, 0x95, 0x19, 0xB3, 0xCD, 0x3A, 0x43, 0x1B,
++ 0x30, 0x2B, 0x0A, 0x6D, 0xF2, 0x5F, 0x14, 0x37,
++ 0x4F, 0xE1, 0x35, 0x6D, 0x6D, 0x51, 0xC2, 0x45,
++ 0xE4, 0x85, 0xB5, 0x76, 0x62, 0x5E, 0x7E, 0xC6,
++ 0xF4, 0x4C, 0x42, 0xE9, 0xA6, 0x37, 0xED, 0x6B,
++ 0x0B, 0xFF, 0x5C, 0xB6, 0xF4, 0x06, 0xB7, 0xED,
++ 0xEE, 0x38, 0x6B, 0xFB, 0x5A, 0x89, 0x9F, 0xA5,
++ 0xAE, 0x9F, 0x24, 0x11, 0x7C, 0x4B, 0x1F, 0xE6,
++ 0x49, 0x28, 0x66, 0x51, 0xEC, 0xE4, 0x5B, 0x3D,
++ 0xC2, 0x00, 0x7C, 0xB8, 0xA1, 0x63, 0xBF, 0x05,
++ 0x98, 0xDA, 0x48, 0x36, 0x1C, 0x55, 0xD3, 0x9A,
++ 0x69, 0x16, 0x3F, 0xA8, 0xFD, 0x24, 0xCF, 0x5F,
++ 0x83, 0x65, 0x5D, 0x23, 0xDC, 0xA3, 0xAD, 0x96,
++ 0x1C, 0x62, 0xF3, 0x56, 0x20, 0x85, 0x52, 0xBB,
++ 0x9E, 0xD5, 0x29, 0x07, 0x70, 0x96, 0x96, 0x6D,
++ 0x67, 0x0C, 0x35, 0x4E, 0x4A, 0xBC, 0x98, 0x04,
++ 0xF1, 0x74, 0x6C, 0x08, 0xCA, 0x18, 0x21, 0x7C,
++ 0x32, 0x90, 0x5E, 0x46, 0x2E, 0x36, 0xCE, 0x3B,
++ 0xE3, 0x9E, 0x77, 0x2C, 0x18, 0x0E, 0x86, 0x03,
++ 0x9B, 0x27, 0x83, 0xA2, 0xEC, 0x07, 0xA2, 0x8F,
++ 0xB5, 0xC5, 0x5D, 0xF0, 0x6F, 0x4C, 0x52, 0xC9,
++ 0xDE, 0x2B, 0xCB, 0xF6, 0x95, 0x58, 0x17, 0x18,
++ 0x39, 0x95, 0x49, 0x7C, 0xEA, 0x95, 0x6A, 0xE5,
++ 0x15, 0xD2, 0x26, 0x18, 0x98, 0xFA, 0x05, 0x10,
++ 0x15, 0x72, 0x8E, 0x5A, 0x8A, 0xAC, 0xAA, 0x68,
++ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
++ };
++ int ret;
++
++ if (key_state->state == libssh2_NB_state_idle) {
++ key_state->p = _libssh2_bn_init(); /* SSH2 defined value (p_value) */
++ key_state->g = _libssh2_bn_init(); /* SSH2 defined value (2) */
++
++ /* g == 2 */
++ /* Initialize P and G */
++ _libssh2_bn_set_word(key_state->g, 2);
++ _libssh2_bn_from_bin(key_state->p, 256, p_value);
++
++ _libssh2_debug(session, LIBSSH2_DBG_KEX,
++ "Initiating Diffie-Hellman Group14 Key Exchange");
++
++ key_state->state = libssh2_NB_state_created;
++ }
++ ret =
++ libssh2_kex_method_diffie_hellman_groupGP_sha1_key_exchange(session,
++ key_state->
++ g,
++ key_state->
++ p, 256,
++ SSH_MSG_KEXDH_INIT,
++ SSH_MSG_KEXDH_REPLY,
++ NULL, 0,
++ &key_state->
++ exchange_state);
++ if (ret == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ }
++
++ key_state->state = libssh2_NB_state_idle;
++ _libssh2_bn_free(key_state->p);
++ key_state->p = NULL;
++ _libssh2_bn_free(key_state->g);
++ key_state->g = NULL;
++
++ return ret;
++}
++
++/* }}} */
++
++/* {{{ libssh2_kex_method_diffie_hellman_group_exchange_sha1_key_exchange
++ * Diffie-Hellman Group Exchange Key Exchange using SHA1
++ * Negotiates random(ish) group for secret derivation
++ */
++static int
++ libssh2_kex_method_diffie_hellman_group_exchange_sha1_key_exchange
++ (LIBSSH2_SESSION * session, key_exchange_state_low_t * key_state)
++{
++ unsigned char *s;
++ unsigned long p_len, g_len;
++ int ret = 0;
++ int rc;
++
++ if (key_state->state == libssh2_NB_state_idle) {
++ key_state->p = _libssh2_bn_init();
++ key_state->g = _libssh2_bn_init();
++ /* Ask for a P and G pair */
++#ifdef LIBSSH2_DH_GEX_NEW
++ key_state->request[0] = SSH_MSG_KEX_DH_GEX_REQUEST;
++ libssh2_htonu32(key_state->request + 1, LIBSSH2_DH_GEX_MINGROUP);
++ libssh2_htonu32(key_state->request + 5, LIBSSH2_DH_GEX_OPTGROUP);
++ libssh2_htonu32(key_state->request + 9, LIBSSH2_DH_GEX_MAXGROUP);
++ key_state->request_len = 13;
++ _libssh2_debug(session, LIBSSH2_DBG_KEX,
++ "Initiating Diffie-Hellman Group-Exchange (New Method)");
++#else
++ key_state->request[0] = SSH_MSG_KEX_DH_GEX_REQUEST_OLD;
++ libssh2_htonu32(key_state->request + 1, LIBSSH2_DH_GEX_OPTGROUP);
++ key_state->request_len = 5;
++ _libssh2_debug(session, LIBSSH2_DBG_KEX,
++ "Initiating Diffie-Hellman Group-Exchange (Old Method)");
++#endif
++
++ key_state->state = libssh2_NB_state_created;
++ }
++
++ if (key_state->state == libssh2_NB_state_created) {
++ rc = libssh2_packet_write(session, key_state->request,
++ key_state->request_len);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send Group Exchange Request", 0);
++ ret = -1;
++ goto dh_gex_clean_exit;
++ }
++
++ key_state->state = libssh2_NB_state_sent;
++ }
++
++ if (key_state->state == libssh2_NB_state_sent) {
++ rc = libssh2_packet_require_ex(session, SSH_MSG_KEX_DH_GEX_GROUP,
++ &key_state->data, &key_state->data_len,
++ 0, NULL, 0, &key_state->req_state);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ libssh2_error(session, LIBSSH2_ERROR_TIMEOUT,
++ "Timeout waiting for GEX_GROUP reply", 0);
++ ret = -1;
++ goto dh_gex_clean_exit;
++ }
++
++ key_state->state = libssh2_NB_state_sent1;
++ }
++
++ if (key_state->state == libssh2_NB_state_sent1) {
++ s = key_state->data + 1;
++ p_len = libssh2_ntohu32(s);
++ s += 4;
++ _libssh2_bn_from_bin(key_state->p, p_len, s);
++ s += p_len;
++
++ g_len = libssh2_ntohu32(s);
++ s += 4;
++ _libssh2_bn_from_bin(key_state->g, g_len, s);
++ s += g_len;
++
++ ret =
++ libssh2_kex_method_diffie_hellman_groupGP_sha1_key_exchange
++ (session, key_state->g, key_state->p, p_len,
++ SSH_MSG_KEX_DH_GEX_INIT, SSH_MSG_KEX_DH_GEX_REPLY,
++ key_state->data + 1, key_state->data_len - 1,
++ &key_state->exchange_state);
++ if (ret == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ }
++
++ LIBSSH2_FREE(session, key_state->data);
++ }
++
++ dh_gex_clean_exit:
++ key_state->state = libssh2_NB_state_idle;
++ _libssh2_bn_free(key_state->g);
++ key_state->g = NULL;
++ _libssh2_bn_free(key_state->p);
++ key_state->p = NULL;
++
++ return ret;
++}
++
++/* }}} */
++
++#define LIBSSH2_KEX_METHOD_FLAG_REQ_ENC_HOSTKEY 0x0001
++#define LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY 0x0002
++
++static const LIBSSH2_KEX_METHOD libssh2_kex_method_diffie_helman_group1_sha1 = {
++ "diffie-hellman-group1-sha1",
++ libssh2_kex_method_diffie_hellman_group1_sha1_key_exchange,
++ LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
++};
++
++static const LIBSSH2_KEX_METHOD libssh2_kex_method_diffie_helman_group14_sha1 = {
++ "diffie-hellman-group14-sha1",
++ libssh2_kex_method_diffie_hellman_group14_sha1_key_exchange,
++ LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
++};
++
++static const LIBSSH2_KEX_METHOD
++ libssh2_kex_method_diffie_helman_group_exchange_sha1 = {
++ "diffie-hellman-group-exchange-sha1",
++ libssh2_kex_method_diffie_hellman_group_exchange_sha1_key_exchange,
++ LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY,
++};
++
++static const LIBSSH2_KEX_METHOD *libssh2_kex_methods[] = {
++ &libssh2_kex_method_diffie_helman_group14_sha1,
++ &libssh2_kex_method_diffie_helman_group_exchange_sha1,
++ &libssh2_kex_method_diffie_helman_group1_sha1,
++ NULL
++};
++
++typedef struct _LIBSSH2_COMMON_METHOD
++{
++ const char *name;
++} LIBSSH2_COMMON_METHOD;
++
++/* {{{ libssh2_kex_method_strlen
++ * Calculate the length of a particular method list's resulting string
++ * Includes SUM(strlen() of each individual method plus 1 (for coma)) - 1 (because the last coma isn't used)
++ * Another sign of bad coding practices gone mad. Pretend you don't see this.
++ */
++static size_t
++libssh2_kex_method_strlen(LIBSSH2_COMMON_METHOD ** method)
++{
++ size_t len = 0;
++
++ if (!method || !*method) {
++ return 0;
++ }
++
++ while (*method && (*method)->name) {
++ len += strlen((*method)->name) + 1;
++ method++;
++ }
++
++ return len - 1;
++}
++
++/* }}} */
++
++/* {{{ libssh2_kex_method_list
++ * Generate formatted preference list in buf
++ */
++static size_t
++libssh2_kex_method_list(unsigned char *buf, size_t list_strlen,
++ LIBSSH2_COMMON_METHOD ** method)
++{
++ libssh2_htonu32(buf, list_strlen);
++ buf += 4;
++
++ if (!method || !*method) {
++ return 4;
++ }
++
++ while (*method && (*method)->name) {
++ int mlen = strlen((*method)->name);
++ memcpy(buf, (*method)->name, mlen);
++ buf += mlen;
++ *(buf++) = ',';
++ method++;
++ }
++
++ return list_strlen + 4;
++}
++
++/* }}} */
++
++#define LIBSSH2_METHOD_PREFS_LEN(prefvar, defaultvar) ((prefvar) ? strlen(prefvar) : libssh2_kex_method_strlen((LIBSSH2_COMMON_METHOD**)(defaultvar)))
++#define LIBSSH2_METHOD_PREFS_STR(buf, prefvarlen, prefvar, defaultvar) \
++ if (prefvar) { \
++ libssh2_htonu32((buf), (prefvarlen)); \
++ buf += 4; \
++ memcpy((buf), (prefvar), (prefvarlen)); \
++ buf += (prefvarlen); \
++ } else { \
++ buf += libssh2_kex_method_list((buf), (prefvarlen), (LIBSSH2_COMMON_METHOD**)(defaultvar)); \
++ }
++
++/* {{{ libssh2_kexinit
++ * Send SSH_MSG_KEXINIT packet
++ */
++static int
++libssh2_kexinit(LIBSSH2_SESSION * session)
++{
++ /* 62 = packet_type(1) + cookie(16) + first_packet_follows(1) +
++ reserved(4) + length longs(40) */
++ size_t data_len = 62;
++ size_t kex_len, hostkey_len = 0;
++ size_t crypt_cs_len, crypt_sc_len;
++ size_t comp_cs_len, comp_sc_len;
++ size_t mac_cs_len, mac_sc_len;
++ size_t lang_cs_len, lang_sc_len;
++ unsigned char *data, *s;
++ int rc;
++
++ if (session->kexinit_state == libssh2_NB_state_idle) {
++ kex_len =
++ LIBSSH2_METHOD_PREFS_LEN(session->kex_prefs, libssh2_kex_methods);
++ hostkey_len =
++ LIBSSH2_METHOD_PREFS_LEN(session->hostkey_prefs,
++ libssh2_hostkey_methods());
++ crypt_cs_len =
++ LIBSSH2_METHOD_PREFS_LEN(session->local.crypt_prefs,
++ libssh2_crypt_methods());
++ crypt_sc_len =
++ LIBSSH2_METHOD_PREFS_LEN(session->remote.crypt_prefs,
++ libssh2_crypt_methods());
++ mac_cs_len =
++ LIBSSH2_METHOD_PREFS_LEN(session->local.mac_prefs,
++ libssh2_mac_methods());
++ mac_sc_len =
++ LIBSSH2_METHOD_PREFS_LEN(session->remote.mac_prefs,
++ libssh2_mac_methods());
++ comp_cs_len =
++ LIBSSH2_METHOD_PREFS_LEN(session->local.comp_prefs,
++ libssh2_comp_methods());
++ comp_sc_len =
++ LIBSSH2_METHOD_PREFS_LEN(session->remote.comp_prefs,
++ libssh2_comp_methods());
++ lang_cs_len =
++ LIBSSH2_METHOD_PREFS_LEN(session->local.lang_prefs, NULL);
++ lang_sc_len =
++ LIBSSH2_METHOD_PREFS_LEN(session->remote.lang_prefs, NULL);
++
++ data_len += kex_len + hostkey_len + crypt_cs_len + crypt_sc_len +
++ comp_cs_len + comp_sc_len + mac_cs_len + mac_sc_len +
++ lang_cs_len + lang_sc_len;
++
++ s = data = LIBSSH2_ALLOC(session, data_len);
++ if (!data) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Unable to allocate memory", 0);
++ return -1;
++ }
++
++ *(s++) = SSH_MSG_KEXINIT;
++
++ libssh2_random(s, 16);
++ s += 16;
++
++ /* Ennumerating through these lists twice is probably (certainly?)
++ inefficient from a CPU standpoint, but it saves multiple
++ malloc/realloc calls */
++ LIBSSH2_METHOD_PREFS_STR(s, kex_len, session->kex_prefs,
++ libssh2_kex_methods);
++ LIBSSH2_METHOD_PREFS_STR(s, hostkey_len, session->hostkey_prefs,
++ libssh2_hostkey_methods());
++ LIBSSH2_METHOD_PREFS_STR(s, crypt_cs_len, session->local.crypt_prefs,
++ libssh2_crypt_methods());
++ LIBSSH2_METHOD_PREFS_STR(s, crypt_sc_len, session->remote.crypt_prefs,
++ libssh2_crypt_methods());
++ LIBSSH2_METHOD_PREFS_STR(s, mac_cs_len, session->local.mac_prefs,
++ libssh2_mac_methods());
++ LIBSSH2_METHOD_PREFS_STR(s, mac_sc_len, session->remote.mac_prefs,
++ libssh2_mac_methods());
++ LIBSSH2_METHOD_PREFS_STR(s, comp_cs_len, session->local.comp_prefs,
++ libssh2_comp_methods());
++ LIBSSH2_METHOD_PREFS_STR(s, comp_sc_len, session->remote.comp_prefs,
++ libssh2_comp_methods());
++ LIBSSH2_METHOD_PREFS_STR(s, lang_cs_len, session->local.lang_prefs,
++ NULL);
++ LIBSSH2_METHOD_PREFS_STR(s, lang_sc_len, session->remote.lang_prefs,
++ NULL);
++
++ /* No optimistic KEX packet follows */
++ /* Deal with optimistic packets
++ * session->flags |= KEXINIT_OPTIMISTIC
++ * session->flags |= KEXINIT_METHODSMATCH
++ */
++ *(s++) = 0;
++
++ /* Reserved == 0 */
++ *(s++) = 0;
++ *(s++) = 0;
++ *(s++) = 0;
++ *(s++) = 0;
++
++#ifdef LIBSSH2DEBUG
++ {
++ /* Funnily enough, they'll all "appear" to be '\0' terminated */
++ unsigned char *p = data + 21; /* type(1) + cookie(16) + len(4) */
++
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent KEX: %s", p);
++ p += kex_len + 4;
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent HOSTKEY: %s", p);
++ p += hostkey_len + 4;
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent CRYPT_CS: %s", p);
++ p += crypt_cs_len + 4;
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent CRYPT_SC: %s", p);
++ p += crypt_sc_len + 4;
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent MAC_CS: %s", p);
++ p += mac_cs_len + 4;
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent MAC_SC: %s", p);
++ p += mac_sc_len + 4;
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent COMP_CS: %s", p);
++ p += comp_cs_len + 4;
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent COMP_SC: %s", p);
++ p += comp_sc_len + 4;
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent LANG_CS: %s", p);
++ p += lang_cs_len + 4;
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Sent LANG_SC: %s", p);
++ p += lang_sc_len + 4;
++ }
++#endif /* LIBSSH2DEBUG */
++
++ session->kexinit_state = libssh2_NB_state_created;
++ } else {
++ data = session->kexinit_data;
++ data_len = session->kexinit_data_len;
++ }
++
++ if ((rc = libssh2_packet_write(session, data, data_len)) == PACKET_EAGAIN) {
++ session->kexinit_data = data;
++ session->kexinit_data_len = data_len;
++ return PACKET_EAGAIN;
++ } else if (rc) {
++ LIBSSH2_FREE(session, data);
++ libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND,
++ "Unable to send KEXINIT packet to remote host", 0);
++ session->kexinit_state = libssh2_NB_state_idle;
++ return -1;
++ }
++
++ if (session->local.kexinit) {
++ LIBSSH2_FREE(session, session->local.kexinit);
++ }
++
++ session->local.kexinit = data;
++ session->local.kexinit_len = data_len;
++
++ session->kexinit_state = libssh2_NB_state_idle;
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_kex_agree_instr
++ * Kex specific variant of strstr()
++ * Needle must be preceed by BOL or ',', and followed by ',' or EOL
++ */
++static unsigned char *
++libssh2_kex_agree_instr(unsigned char *haystack, unsigned long haystack_len,
++ const unsigned char *needle, unsigned long needle_len)
++{
++ unsigned char *s;
++
++ /* Haystack too short to bother trying */
++ if (haystack_len < needle_len) {
++ return NULL;
++ }
++
++ /* Needle at start of haystack */
++ if ((strncmp((char *) haystack, (char *) needle, needle_len) == 0) &&
++ (needle_len == haystack_len || haystack[needle_len] == ',')) {
++ return haystack;
++ }
++
++ s = haystack;
++ /* Search until we run out of comas or we run out of haystack,
++ whichever comes first */
++ while ((s = (unsigned char *) strchr((char *) s, ','))
++ && ((haystack_len - (s - haystack)) > needle_len)) {
++ s++;
++ /* Needle at X position */
++ if ((strncmp((char *) s, (char *) needle, needle_len) == 0) &&
++ (((s - haystack) + needle_len) == haystack_len
++ || s[needle_len] == ',')) {
++ return s;
++ }
++ }
++
++ return NULL;
++}
++
++/* }}} */
++
++/* {{{ libssh2_get_method_by_name
++ */
++static const LIBSSH2_COMMON_METHOD *
++libssh2_get_method_by_name(const char *name, int name_len,
++ const LIBSSH2_COMMON_METHOD ** methodlist)
++{
++ while (*methodlist) {
++ if ((strlen((*methodlist)->name) == name_len) &&
++ (strncmp((*methodlist)->name, name, name_len) == 0)) {
++ return *methodlist;
++ }
++ methodlist++;
++ }
++ return NULL;
++}
++
++/* }}} */
++
++/* {{{ libssh2_kex_agree_hostkey
++ * Agree on a Hostkey which works with this kex
++ */
++static int
++libssh2_kex_agree_hostkey(LIBSSH2_SESSION * session, unsigned long kex_flags,
++ unsigned char *hostkey, unsigned long hostkey_len)
++{
++ const LIBSSH2_HOSTKEY_METHOD **hostkeyp = libssh2_hostkey_methods();
++ unsigned char *s;
++
++ if (session->hostkey_prefs) {
++ s = (unsigned char *) session->hostkey_prefs;
++
++ while (s && *s) {
++ unsigned char *p = (unsigned char *) strchr((char *) s, ',');
++ int method_len = (p ? (p - s) : strlen((char *) s));
++ if (libssh2_kex_agree_instr(hostkey, hostkey_len, s, method_len)) {
++ const LIBSSH2_HOSTKEY_METHOD *method =
++ (const LIBSSH2_HOSTKEY_METHOD *)
++ libssh2_get_method_by_name((char *) s, method_len,
++ (const LIBSSH2_COMMON_METHOD **)
++ hostkeyp);
++
++ if (!method) {
++ /* Invalid method -- Should never be reached */
++ return -1;
++ }
++
++ /* So far so good, but does it suit our purposes? (Encrypting vs Signing) */
++ if (((kex_flags & LIBSSH2_KEX_METHOD_FLAG_REQ_ENC_HOSTKEY) ==
++ 0) || (method->encrypt)) {
++ /* Either this hostkey can do encryption or this kex just doesn't require it */
++ if (((kex_flags & LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY)
++ == 0) || (method->sig_verify)) {
++ /* Either this hostkey can do signing or this kex just doesn't require it */
++ session->hostkey = method;
++ return 0;
++ }
++ }
++ }
++
++ s = p ? p + 1 : NULL;
++ }
++ return -1;
++ }
++
++ while (hostkeyp && (*hostkeyp)->name) {
++ s = libssh2_kex_agree_instr(hostkey, hostkey_len,
++ (unsigned char *) (*hostkeyp)->name,
++ strlen((*hostkeyp)->name));
++ if (s) {
++ /* So far so good, but does it suit our purposes? (Encrypting vs Signing) */
++ if (((kex_flags & LIBSSH2_KEX_METHOD_FLAG_REQ_ENC_HOSTKEY) == 0) ||
++ ((*hostkeyp)->encrypt)) {
++ /* Either this hostkey can do encryption or this kex just doesn't require it */
++ if (((kex_flags & LIBSSH2_KEX_METHOD_FLAG_REQ_SIGN_HOSTKEY) ==
++ 0) || ((*hostkeyp)->sig_verify)) {
++ /* Either this hostkey can do signing or this kex just doesn't require it */
++ session->hostkey = *hostkeyp;
++ return 0;
++ }
++ }
++ }
++ hostkeyp++;
++ }
++
++ return -1;
++}
++
++/* }}} */
++
++/* {{{ libssh2_kex_agree_kex_hostkey
++ * Agree on a Key Exchange method and a hostkey encoding type
++ */
++static int
++libssh2_kex_agree_kex_hostkey(LIBSSH2_SESSION * session, unsigned char *kex,
++ unsigned long kex_len, unsigned char *hostkey,
++ unsigned long hostkey_len)
++{
++ const LIBSSH2_KEX_METHOD **kexp = libssh2_kex_methods;
++ unsigned char *s;
++
++ if (session->kex_prefs) {
++ s = (unsigned char *) session->kex_prefs;
++
++ while (s && *s) {
++ unsigned char *q, *p = (unsigned char *) strchr((char *) s, ',');
++ int method_len = (p ? (p - s) : strlen((char *) s));
++ if ((q = libssh2_kex_agree_instr(kex, kex_len, s, method_len))) {
++ const LIBSSH2_KEX_METHOD *method = (const LIBSSH2_KEX_METHOD *)
++ libssh2_get_method_by_name((char *) s, method_len,
++ (const LIBSSH2_COMMON_METHOD **)
++ kexp);
++
++ if (!method) {
++ /* Invalid method -- Should never be reached */
++ return -1;
++ }
++
++ /* We've agreed on a key exchange method,
++ * Can we agree on a hostkey that works with this kex?
++ */
++ if (libssh2_kex_agree_hostkey
++ (session, method->flags, hostkey, hostkey_len) == 0) {
++ session->kex = method;
++ if (session->burn_optimistic_kexinit && (kex == q)) {
++ /* Server sent an optimistic packet,
++ * and client agrees with preference
++ * cancel burning the first KEX_INIT packet that comes in */
++ session->burn_optimistic_kexinit = 0;
++ }
++ return 0;
++ }
++ }
++
++ s = p ? p + 1 : NULL;
++ }
++ return -1;
++ }
++
++ while (*kexp && (*kexp)->name) {
++ s = libssh2_kex_agree_instr(kex, kex_len,
++ (unsigned char *) (*kexp)->name,
++ strlen((*kexp)->name));
++ if (s) {
++ /* We've agreed on a key exchange method,
++ * Can we agree on a hostkey that works with this kex?
++ */
++ if (libssh2_kex_agree_hostkey
++ (session, (*kexp)->flags, hostkey, hostkey_len) == 0) {
++ session->kex = *kexp;
++ if (session->burn_optimistic_kexinit && (kex == s)) {
++ /* Server sent an optimistic packet,
++ * and client agrees with preference
++ * cancel burning the first KEX_INIT packet that comes in */
++ session->burn_optimistic_kexinit = 0;
++ }
++ return 0;
++ }
++ }
++ kexp++;
++ }
++ return -1;
++}
++
++/* }}} */
++
++/* {{{ libssh2_kex_agree_crypt
++ * Agree on a cipher algo
++ */
++static int
++libssh2_kex_agree_crypt(LIBSSH2_SESSION * session,
++ libssh2_endpoint_data * endpoint, unsigned char *crypt,
++ unsigned long crypt_len)
++{
++ const LIBSSH2_CRYPT_METHOD **cryptp = libssh2_crypt_methods();
++ unsigned char *s;
++
++ (void) session;
++
++ if (endpoint->crypt_prefs) {
++ s = (unsigned char *) endpoint->crypt_prefs;
++
++ while (s && *s) {
++ unsigned char *p = (unsigned char *) strchr((char *) s, ',');
++ int method_len = (p ? (p - s) : strlen((char *) s));
++
++ if (libssh2_kex_agree_instr(crypt, crypt_len, s, method_len)) {
++ const LIBSSH2_CRYPT_METHOD *method =
++ (const LIBSSH2_CRYPT_METHOD *)
++ libssh2_get_method_by_name((char *) s, method_len,
++ (const LIBSSH2_COMMON_METHOD **)
++ cryptp);
++
++ if (!method) {
++ /* Invalid method -- Should never be reached */
++ return -1;
++ }
++
++ endpoint->crypt = method;
++ return 0;
++ }
++
++ s = p ? p + 1 : NULL;
++ }
++ return -1;
++ }
++
++ while (*cryptp && (*cryptp)->name) {
++ s = libssh2_kex_agree_instr(crypt, crypt_len,
++ (unsigned char *) (*cryptp)->name,
++ strlen((*cryptp)->name));
++ if (s) {
++ endpoint->crypt = *cryptp;
++ return 0;
++ }
++ cryptp++;
++ }
++
++ return -1;
++}
++
++/* }}} */
++
++/* {{{ libssh2_kex_agree_mac
++ * Agree on a message authentication hash
++ */
++static int
++libssh2_kex_agree_mac(LIBSSH2_SESSION * session,
++ libssh2_endpoint_data * endpoint, unsigned char *mac,
++ unsigned long mac_len)
++{
++ const LIBSSH2_MAC_METHOD **macp = libssh2_mac_methods();
++ unsigned char *s;
++ (void) session;
++
++ if (endpoint->mac_prefs) {
++ s = (unsigned char *) endpoint->mac_prefs;
++
++ while (s && *s) {
++ unsigned char *p = (unsigned char *) strchr((char *) s, ',');
++ int method_len = (p ? (p - s) : strlen((char *) s));
++
++ if (libssh2_kex_agree_instr(mac, mac_len, s, method_len)) {
++ const LIBSSH2_MAC_METHOD *method = (const LIBSSH2_MAC_METHOD *)
++ libssh2_get_method_by_name((char *) s, method_len,
++ (const LIBSSH2_COMMON_METHOD **)
++ macp);
++
++ if (!method) {
++ /* Invalid method -- Should never be reached */
++ return -1;
++ }
++
++ endpoint->mac = method;
++ return 0;
++ }
++
++ s = p ? p + 1 : NULL;
++ }
++ return -1;
++ }
++
++ while (*macp && (*macp)->name) {
++ s = libssh2_kex_agree_instr(mac, mac_len,
++ (unsigned char *) (*macp)->name,
++ strlen((*macp)->name));
++ if (s) {
++ endpoint->mac = *macp;
++ return 0;
++ }
++ macp++;
++ }
++
++ return -1;
++}
++
++/* }}} */
++
++/* {{{ libssh2_kex_agree_comp
++ * Agree on a compression scheme
++ */
++static int
++libssh2_kex_agree_comp(LIBSSH2_SESSION * session,
++ libssh2_endpoint_data * endpoint, unsigned char *comp,
++ unsigned long comp_len)
++{
++ const LIBSSH2_COMP_METHOD **compp = libssh2_comp_methods();
++ unsigned char *s;
++ (void) session;
++
++ if (endpoint->comp_prefs) {
++ s = (unsigned char *) endpoint->comp_prefs;
++
++ while (s && *s) {
++ unsigned char *p = (unsigned char *) strchr((char *) s, ',');
++ int method_len = (p ? (p - s) : strlen((char *) s));
++
++ if (libssh2_kex_agree_instr(comp, comp_len, s, method_len)) {
++ const LIBSSH2_COMP_METHOD *method =
++ (const LIBSSH2_COMP_METHOD *)
++ libssh2_get_method_by_name((char *) s, method_len,
++ (const LIBSSH2_COMMON_METHOD **)
++ compp);
++
++ if (!method) {
++ /* Invalid method -- Should never be reached */
++ return -1;
++ }
++
++ endpoint->comp = method;
++ return 0;
++ }
++
++ s = p ? p + 1 : NULL;
++ }
++ return -1;
++ }
++
++ while (*compp && (*compp)->name) {
++ s = libssh2_kex_agree_instr(comp, comp_len,
++ (unsigned char *) (*compp)->name,
++ strlen((*compp)->name));
++ if (s) {
++ endpoint->comp = *compp;
++ return 0;
++ }
++ compp++;
++ }
++
++ return -1;
++}
++
++/* }}} */
++
++/* TODO: When in server mode we need to turn this logic on its head
++ * The Client gets to make the final call on "agreed methods"
++ */
++
++/* {{{ libssh2_kex_agree_methods
++ * Decide which specific method to use of the methods offered by each party
++ */
++static int
++libssh2_kex_agree_methods(LIBSSH2_SESSION * session, unsigned char *data,
++ unsigned data_len)
++{
++ unsigned char *kex, *hostkey, *crypt_cs, *crypt_sc, *comp_cs, *comp_sc,
++ *mac_cs, *mac_sc, *lang_cs, *lang_sc;
++ size_t kex_len, hostkey_len, crypt_cs_len, crypt_sc_len, comp_cs_len;
++ size_t comp_sc_len, mac_cs_len, mac_sc_len, lang_cs_len, lang_sc_len;
++ unsigned char *s = data;
++
++ /* Skip packet_type, we know it already */
++ s++;
++
++ /* Skip cookie, don't worry, it's preserved in the kexinit field */
++ s += 16;
++
++ /* Locate each string */
++ kex_len = libssh2_ntohu32(s);
++ kex = s + 4;
++ s += 4 + kex_len;
++ hostkey_len = libssh2_ntohu32(s);
++ hostkey = s + 4;
++ s += 4 + hostkey_len;
++ crypt_cs_len = libssh2_ntohu32(s);
++ crypt_cs = s + 4;
++ s += 4 + crypt_cs_len;
++ crypt_sc_len = libssh2_ntohu32(s);
++ crypt_sc = s + 4;
++ s += 4 + crypt_sc_len;
++ mac_cs_len = libssh2_ntohu32(s);
++ mac_cs = s + 4;
++ s += 4 + mac_cs_len;
++ mac_sc_len = libssh2_ntohu32(s);
++ mac_sc = s + 4;
++ s += 4 + mac_sc_len;
++ comp_cs_len = libssh2_ntohu32(s);
++ comp_cs = s + 4;
++ s += 4 + comp_cs_len;
++ comp_sc_len = libssh2_ntohu32(s);
++ comp_sc = s + 4;
++ s += 4 + comp_sc_len;
++ lang_cs_len = libssh2_ntohu32(s);
++ lang_cs = s + 4;
++ s += 4 + lang_cs_len;
++ lang_sc_len = libssh2_ntohu32(s);
++ lang_sc = s + 4;
++ s += 4 + lang_sc_len;
++
++ /* If the server sent an optimistic packet, assume that it guessed wrong.
++ * If the guess is determined to be right (by libssh2_kex_agree_kex_hostkey)
++ * This flag will be reset to zero so that it's not ignored */
++ session->burn_optimistic_kexinit = *(s++);
++ /* Next uint32 in packet is all zeros (reserved) */
++
++ if (data_len < (unsigned) (s - data))
++ return -1; /* short packet */
++
++ if (libssh2_kex_agree_kex_hostkey
++ (session, kex, kex_len, hostkey, hostkey_len)) {
++ return -1;
++ }
++
++ if (libssh2_kex_agree_crypt
++ (session, &session->local, crypt_cs, crypt_cs_len)
++ || libssh2_kex_agree_crypt(session, &session->remote, crypt_sc,
++ crypt_sc_len)) {
++ return -1;
++ }
++
++ if (libssh2_kex_agree_mac(session, &session->local, mac_cs, mac_cs_len) ||
++ libssh2_kex_agree_mac(session, &session->remote, mac_sc, mac_sc_len)) {
++ return -1;
++ }
++
++ if (libssh2_kex_agree_comp(session, &session->local, comp_cs, comp_cs_len)
++ || libssh2_kex_agree_comp(session, &session->remote, comp_sc,
++ comp_sc_len)) {
++ return -1;
++ }
++
++ if (libssh2_kex_agree_lang(session, &session->local, lang_cs, lang_cs_len)
++ || libssh2_kex_agree_lang(session, &session->remote, lang_sc,
++ lang_sc_len)) {
++ return -1;
++ }
++
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Agreed on KEX method: %s",
++ session->kex->name);
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Agreed on HOSTKEY method: %s",
++ session->hostkey->name);
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Agreed on CRYPT_CS method: %s",
++ session->local.crypt->name);
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Agreed on CRYPT_SC method: %s",
++ session->remote.crypt->name);
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Agreed on MAC_CS method: %s",
++ session->local.mac->name);
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Agreed on MAC_SC method: %s",
++ session->remote.mac->name);
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Agreed on COMP_CS method: %s",
++ session->local.comp->name);
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Agreed on COMP_SC method: %s",
++ session->remote.comp->name);
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Agreed on LANG_CS method:"); /* None yet */
++ _libssh2_debug(session, LIBSSH2_DBG_KEX, "Agreed on LANG_SC method:"); /* None yet */
++
++ /* Initialize compression layer */
++ if (session->local.comp && session->local.comp->init &&
++ session->local.comp->init(session, 1, &session->local.comp_abstract)) {
++ return -1;
++ }
++
++ if (session->remote.comp && session->remote.comp->init &&
++ session->remote.comp->init(session, 0,
++ &session->remote.comp_abstract)) {
++ return -1;
++ }
++
++ return 0;
++}
++
++/* }}} */
++
++/* {{{ libssh2_kex_exchange
++ * Exchange keys
++ * Returns 0 on success, non-zero on failure
++ */
++int
++libssh2_kex_exchange(LIBSSH2_SESSION * session, int reexchange,
++ key_exchange_state_t * key_state)
++{
++ int rc = 0;
++ int retcode;
++
++ session->state |= LIBSSH2_STATE_KEX_ACTIVE;
++
++ if (key_state->state == libssh2_NB_state_idle) {
++ /* Prevent loop in packet_add() */
++ session->state |= LIBSSH2_STATE_EXCHANGING_KEYS;
++
++ if (reexchange) {
++ session->kex = NULL;
++
++ if (session->hostkey && session->hostkey->dtor) {
++ session->hostkey->dtor(session,
++ &session->server_hostkey_abstract);
++ }
++ session->hostkey = NULL;
++ }
++
++ key_state->state = libssh2_NB_state_created;
++ }
++
++ if (!session->kex || !session->hostkey) {
++ if (key_state->state == libssh2_NB_state_created) {
++ /* Preserve in case of failure */
++ key_state->oldlocal = session->local.kexinit;
++ key_state->oldlocal_len = session->local.kexinit_len;
++
++ session->local.kexinit = NULL;
++
++ key_state->state = libssh2_NB_state_sent;
++ }
++
++ if (key_state->state == libssh2_NB_state_sent) {
++ retcode = libssh2_kexinit(session);
++ if (retcode == PACKET_EAGAIN) {
++ session->state &= ~LIBSSH2_STATE_KEX_ACTIVE;
++ return PACKET_EAGAIN;
++ } else if (retcode) {
++ session->local.kexinit = key_state->oldlocal;
++ session->local.kexinit_len = key_state->oldlocal_len;
++ key_state->state = libssh2_NB_state_idle;
++ session->state &= ~LIBSSH2_STATE_KEX_ACTIVE;
++ session->state &= ~LIBSSH2_STATE_EXCHANGING_KEYS;
++ return -1;
++ }
++
++ key_state->state = libssh2_NB_state_sent1;
++ }
++
++ if (key_state->state == libssh2_NB_state_sent1) {
++ retcode =
++ libssh2_packet_require_ex(session, SSH_MSG_KEXINIT,
++ &key_state->data,
++ &key_state->data_len, 0, NULL, 0,
++ &key_state->req_state);
++ if (retcode == PACKET_EAGAIN) {
++ session->state &= ~LIBSSH2_STATE_KEX_ACTIVE;
++ return PACKET_EAGAIN;
++ } else if (retcode) {
++ if (session->local.kexinit) {
++ LIBSSH2_FREE(session, session->local.kexinit);
++ }
++ session->local.kexinit = key_state->oldlocal;
++ session->local.kexinit_len = key_state->oldlocal_len;
++ key_state->state = libssh2_NB_state_idle;
++ session->state &= ~LIBSSH2_STATE_KEX_ACTIVE;
++ session->state &= ~LIBSSH2_STATE_EXCHANGING_KEYS;
++ return -1;
++ }
++
++ if (session->remote.kexinit) {
++ LIBSSH2_FREE(session, session->remote.kexinit);
++ }
++ session->remote.kexinit = key_state->data;
++ session->remote.kexinit_len = key_state->data_len;
++
++ if (libssh2_kex_agree_methods
++ (session, key_state->data, key_state->data_len)) {
++ rc = -1;
++ }
++
++ key_state->state = libssh2_NB_state_sent2;
++ }
++ } else {
++ key_state->state = libssh2_NB_state_sent2;
++ }
++
++ if (rc == 0) {
++ if (key_state->state == libssh2_NB_state_sent2) {
++ retcode =
++ session->kex->exchange_keys(session,
++ &key_state->key_state_low);
++ if (retcode == PACKET_EAGAIN) {
++ session->state &= ~LIBSSH2_STATE_KEX_ACTIVE;
++ return PACKET_EAGAIN;
++ } else if (retcode) {
++ libssh2_error(session, LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE,
++ "Unrecoverable error exchanging keys", 0);
++ rc = -1;
++ }
++ }
++ }
++
++ /* Done with kexinit buffers */
++ if (session->local.kexinit) {
++ LIBSSH2_FREE(session, session->local.kexinit);
++ session->local.kexinit = NULL;
++ }
++ if (session->remote.kexinit) {
++ LIBSSH2_FREE(session, session->remote.kexinit);
++ session->remote.kexinit = NULL;
++ }
++
++ session->state &= ~LIBSSH2_STATE_KEX_ACTIVE;
++ session->state &= ~LIBSSH2_STATE_EXCHANGING_KEYS;
++
++ key_state->state = libssh2_NB_state_idle;
++
++ return rc;
++}
++
++/* }}} */
++
++/* {{{ libssh2_session_method_pref
++ * Set preferred method
++ */
++LIBSSH2_API int
++libssh2_session_method_pref(LIBSSH2_SESSION * session, int method_type,
++ const char *prefs)
++{
++ char **prefvar, *s, *newprefs;
++ int prefs_len = strlen(prefs);
++ const LIBSSH2_COMMON_METHOD **mlist;
++
++ switch (method_type) {
++ case LIBSSH2_METHOD_KEX:
++ prefvar = &session->kex_prefs;
++ mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_kex_methods;
++ break;
++
++ case LIBSSH2_METHOD_HOSTKEY:
++ prefvar = &session->hostkey_prefs;
++ mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_hostkey_methods();
++ break;
++
++ case LIBSSH2_METHOD_CRYPT_CS:
++ prefvar = &session->local.crypt_prefs;
++ mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_crypt_methods();
++ break;
++
++ case LIBSSH2_METHOD_CRYPT_SC:
++ prefvar = &session->remote.crypt_prefs;
++ mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_crypt_methods();
++ break;
++
++ case LIBSSH2_METHOD_MAC_CS:
++ prefvar = &session->local.mac_prefs;
++ mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_mac_methods();
++ break;
++
++ case LIBSSH2_METHOD_MAC_SC:
++ prefvar = &session->remote.mac_prefs;
++ mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_mac_methods();
++ break;
++
++ case LIBSSH2_METHOD_COMP_CS:
++ prefvar = &session->local.comp_prefs;
++ mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_comp_methods();
++ break;
++
++ case LIBSSH2_METHOD_COMP_SC:
++ prefvar = &session->remote.comp_prefs;
++ mlist = (const LIBSSH2_COMMON_METHOD **) libssh2_comp_methods();
++ break;
++
++ case LIBSSH2_METHOD_LANG_CS:
++ prefvar = &session->local.lang_prefs;
++ mlist = NULL;
++ break;
++
++ case LIBSSH2_METHOD_LANG_SC:
++ prefvar = &session->remote.lang_prefs;
++ mlist = NULL;
++ break;
++
++ default:
++ libssh2_error(session, LIBSSH2_ERROR_INVAL,
++ "Invalid parameter specified for method_type", 0);
++ return -1;
++ }
++
++ s = newprefs = LIBSSH2_ALLOC(session, prefs_len + 1);
++ if (!newprefs) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC,
++ "Error allocated space for method preferences", 0);
++ return -1;
++ }
++ memcpy(s, prefs, prefs_len + 1);
++
++ while (s && *s) {
++ char *p = strchr(s, ',');
++ int method_len = p ? (p - s) : (int) strlen(s);
++
++ if (!libssh2_get_method_by_name(s, method_len, mlist)) {
++ /* Strip out unsupported method */
++ if (p) {
++ memcpy(s, p + 1, strlen(s) - method_len);
++ } else {
++ if (s > newprefs) {
++ *(--s) = '\0';
++ } else {
++ *s = '\0';
++ }
++ }
++ }
++
++ s = p ? (p + 1) : NULL;
++ }
++
++ if (strlen(newprefs) == 0) {
++ libssh2_error(session, LIBSSH2_ERROR_METHOD_NOT_SUPPORTED,
++ "The requested method(s) are not currently supported",
++ 0);
++ LIBSSH2_FREE(session, newprefs);
++ return -1;
++ }
++
++ if (*prefvar) {
++ LIBSSH2_FREE(session, *prefvar);
++ }
++ *prefvar = newprefs;
++
++ return 0;
++}
++
++/* }}} */
+
+Property changes on: libssh2/src/kex.c
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.3
+Added: svn:eol-style
+ + native
+
+Index: libssh2/src/openssl.h
+===================================================================
+--- libssh2/src/openssl.h (.../tags/RELEASE_0_11_0)
++++ libssh2/src/openssl.h (.../trunk)
+@@ -0,0 +1,224 @@
++/* Copyright (C) 2006, 2007 The Written Word, Inc. All rights reserved.
++ * Author: Simon Josefsson
++ *
++ * 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 <openssl/opensslconf.h>
++#include <openssl/sha.h>
++#ifndef OPENSSL_NO_MD5
++#include <openssl/md5.h>
++#endif
++#include <openssl/evp.h>
++#include <openssl/hmac.h>
++#include <openssl/bn.h>
++#include <openssl/pem.h>
++#include <openssl/rand.h>
++
++#ifdef OPENSSL_NO_RSA
++# define LIBSSH2_RSA 0
++#else
++# define LIBSSH2_RSA 1
++#endif
++
++#ifdef OPENSSL_NO_DSA
++# define LIBSSH2_DSA 0
++#else
++# define LIBSSH2_DSA 1
++#endif
++
++#ifdef OPENSSL_NO_MD5
++# define LIBSSH2_MD5 0
++#else
++# define LIBSSH2_MD5 1
++#endif
++
++#ifdef OPENSSL_NO_RIPEMD
++# define LIBSSH2_HMAC_RIPEMD 0
++#else
++# define LIBSSH2_HMAC_RIPEMD 1
++#endif
++
++#if OPENSSL_VERSION_NUMBER >= 0x00907000L && !defined(OPENSSL_NO_AES)
++# define LIBSSH2_AES 1
++#else
++# define LIBSSH2_AES 0
++#endif
++
++#ifdef OPENSSL_NO_BLOWFISH
++# define LIBSSH2_BLOWFISH 0
++#else
++# define LIBSSH2_BLOWFISH 1
++#endif
++
++#ifdef OPENSSL_NO_RC4
++# define LIBSSH2_RC4 0
++#else
++# define LIBSSH2_RC4 1
++#endif
++
++#ifdef OPENSSL_NO_CAST
++# define LIBSSH2_CAST 0
++#else
++# define LIBSSH2_CAST 1
++#endif
++
++#ifdef OPENSSL_NO_DES
++# define LIBSSH2_3DES 0
++#else
++# define LIBSSH2_3DES 1
++#endif
++
++#define libssh2_random(buf, len) \
++ RAND_bytes ((buf), (len))
++
++#define libssh2_sha1_ctx SHA_CTX
++#define libssh2_sha1_init(ctx) SHA1_Init(ctx)
++#define libssh2_sha1_update(ctx, data, len) SHA1_Update(&(ctx), data, len)
++#define libssh2_sha1_final(ctx, out) SHA1_Final(out, &(ctx))
++#define libssh2_sha1(message, len, out) SHA1(message, len, out)
++
++#define libssh2_md5_ctx MD5_CTX
++#define libssh2_md5_init(ctx) MD5_Init(ctx)
++#define libssh2_md5_update(ctx, data, len) MD5_Update(&(ctx), data, len)
++#define libssh2_md5_final(ctx, out) MD5_Final(out, &(ctx))
++#define libssh2_md5(message, len, out) MD5(message, len, out)
++
++#define libssh2_hmac_ctx HMAC_CTX
++#define libssh2_hmac_sha1_init(ctx, key, keylen) \
++ HMAC_Init(ctx, key, keylen, EVP_sha1())
++#define libssh2_hmac_md5_init(ctx, key, keylen) \
++ HMAC_Init(ctx, key, keylen, EVP_md5())
++#define libssh2_hmac_ripemd160_init(ctx, key, keylen) \
++ HMAC_Init(ctx, key, keylen, EVP_ripemd160())
++#define libssh2_hmac_update(ctx, data, datalen) \
++ HMAC_Update(&(ctx), data, datalen)
++#define libssh2_hmac_final(ctx, data) HMAC_Final(&(ctx), data, NULL)
++#define libssh2_hmac_cleanup(ctx) HMAC_cleanup(ctx)
++
++#define libssh2_crypto_init()
++
++#define libssh2_rsa_ctx RSA
++
++int _libssh2_rsa_new(libssh2_rsa_ctx ** rsa,
++ const unsigned char *edata,
++ unsigned long elen,
++ const unsigned char *ndata,
++ unsigned long nlen,
++ const unsigned char *ddata,
++ unsigned long dlen,
++ const unsigned char *pdata,
++ unsigned long plen,
++ const unsigned char *qdata,
++ unsigned long qlen,
++ const unsigned char *e1data,
++ unsigned long e1len,
++ const unsigned char *e2data,
++ unsigned long e2len,
++ const unsigned char *coeffdata, unsigned long coefflen);
++int _libssh2_rsa_new_private(libssh2_rsa_ctx ** rsa,
++ LIBSSH2_SESSION * session,
++ FILE * fp, unsigned const char *passphrase);
++int _libssh2_rsa_sha1_verify(libssh2_rsa_ctx * rsa,
++ const unsigned char *sig,
++ unsigned long sig_len,
++ const unsigned char *m, unsigned long m_len);
++int _libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
++ libssh2_rsa_ctx * rsactx,
++ const unsigned char *hash,
++ unsigned long hash_len,
++ unsigned char **signature,
++ unsigned long *signature_len);
++
++#define _libssh2_rsa_free(rsactx) RSA_free(rsactx)
++
++#define libssh2_dsa_ctx DSA
++
++int _libssh2_dsa_new(libssh2_dsa_ctx ** dsa,
++ const unsigned char *pdata,
++ unsigned long plen,
++ const unsigned char *qdata,
++ unsigned long qlen,
++ const unsigned char *gdata,
++ unsigned long glen,
++ const unsigned char *ydata,
++ unsigned long ylen,
++ const unsigned char *x, unsigned long x_len);
++int _libssh2_dsa_new_private(libssh2_dsa_ctx ** dsa,
++ LIBSSH2_SESSION * session,
++ FILE * fp, unsigned const char *passphrase);
++int _libssh2_dsa_sha1_verify(libssh2_dsa_ctx * dsactx,
++ const unsigned char *sig,
++ const unsigned char *m, unsigned long m_len);
++int _libssh2_dsa_sha1_sign(libssh2_dsa_ctx * dsactx,
++ const unsigned char *hash,
++ unsigned long hash_len, unsigned char *sig);
++
++#define _libssh2_dsa_free(dsactx) DSA_free(dsactx)
++
++#define _libssh2_cipher_type(name) const EVP_CIPHER *(*name)(void)
++#define _libssh2_cipher_ctx EVP_CIPHER_CTX
++
++#define _libssh2_cipher_aes256 EVP_aes_256_cbc
++#define _libssh2_cipher_aes192 EVP_aes_192_cbc
++#define _libssh2_cipher_aes128 EVP_aes_128_cbc
++#define _libssh2_cipher_blowfish EVP_bf_cbc
++#define _libssh2_cipher_arcfour EVP_rc4
++#define _libssh2_cipher_cast5 EVP_cast5_cbc
++#define _libssh2_cipher_3des EVP_des_ede3_cbc
++
++int _libssh2_cipher_init(_libssh2_cipher_ctx * h,
++ _libssh2_cipher_type(algo),
++ unsigned char *iv,
++ unsigned char *secret, int encrypt);
++
++int _libssh2_cipher_crypt(_libssh2_cipher_ctx * ctx,
++ _libssh2_cipher_type(algo),
++ int encrypt, unsigned char *block);
++
++#define _libssh2_cipher_dtor(ctx) EVP_CIPHER_CTX_cleanup(ctx)
++
++#define _libssh2_bn BIGNUM
++#define _libssh2_bn_ctx BN_CTX
++#define _libssh2_bn_ctx_new() BN_CTX_new()
++#define _libssh2_bn_ctx_free(bnctx) BN_CTX_free(bnctx)
++#define _libssh2_bn_init() BN_new()
++#define _libssh2_bn_rand(bn, bits, top, bottom) BN_rand(bn, bits, top, bottom)
++#define _libssh2_bn_mod_exp(r, a, p, m, ctx) BN_mod_exp(r, a, p, m, ctx)
++#define _libssh2_bn_set_word(bn, val) BN_set_word(bn, val)
++#define _libssh2_bn_from_bin(bn, len, val) BN_bin2bn(val, len, bn)
++#define _libssh2_bn_to_bin(bn, val) BN_bn2bin(bn, val)
++#define _libssh2_bn_bytes(bn) BN_num_bytes(bn)
++#define _libssh2_bn_bits(bn) BN_num_bits(bn)
++#define _libssh2_bn_free(bn) BN_clear_free(bn)
+
+Property changes on: libssh2/src/openssl.h
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.1
+Added: svn:eol-style
+ + native
+Added: svn:executable
+ + *
+
+Index: libssh2/src/misc.c
+===================================================================
+--- libssh2/src/misc.c (.../tags/RELEASE_0_11_0)
++++ libssh2/src/misc.c (.../trunk)
+@@ -0,0 +1,240 @@
++/* Copyright (c) 2004-2007, Sara Golemon <sarag@libssh2.org>
++ * 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"
++#ifdef HAVE_UNISTD_H
++#include <unistd.h>
++#endif
++
++/* {{{ libssh2_ntohu32
++ */
++unsigned long
++libssh2_ntohu32(const unsigned char *buf)
++{
++ return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
++}
++
++/* }}} */
++
++/* {{{ libssh2_ntohu64
++ *
++ */
++libssh2_uint64_t
++libssh2_ntohu64(const unsigned char *buf)
++{
++ unsigned long msl, lsl;
++
++ msl = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
++ lsl = (buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7];
++
++ return ((libssh2_uint64_t)msl <<32) | lsl;
++}
++
++/* }}} */
++
++/* {{{ libssh2_htonu32
++ */
++void
++libssh2_htonu32(unsigned char *buf, unsigned long value)
++{
++ buf[0] = (value >> 24) & 0xFF;
++ buf[1] = (value >> 16) & 0xFF;
++ buf[2] = (value >> 8) & 0xFF;
++ buf[3] = value & 0xFF;
++}
++
++/* }}} */
++
++/* {{{ libssh2_htonu64
++ */
++void
++libssh2_htonu64(unsigned char *buf, libssh2_uint64_t value)
++{
++ unsigned long msl = ((libssh2_uint64_t)value >> 32);
++
++ buf[0] = (msl >> 24) & 0xFF;
++ buf[1] = (msl >> 16) & 0xFF;
++ buf[2] = (msl >> 8) & 0xFF;
++ buf[3] = msl & 0xFF;
++
++ buf[4] = (value >> 24) & 0xFF;
++ buf[5] = (value >> 16) & 0xFF;
++ buf[6] = (value >> 8) & 0xFF;
++ buf[7] = value & 0xFF;
++}
++
++/* }}} */
++
++/* Base64 Conversion */
++
++/* {{{ */
++static const char libssh2_base64_table[] =
++ { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
++ 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
++ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
++ 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
++ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/', '\0'
++};
++
++static const char libssh2_base64_pad = '=';
++
++static const short libssh2_base64_reverse_table[256] = {
++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
++ 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
++ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
++ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
++ -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
++ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
++};
++
++/* }}} */
++
++
++/* {{{ libssh2_base64_decode
++ * Decode a base64 chunk and store it into a newly alloc'd buffer
++ */
++LIBSSH2_API int
++libssh2_base64_decode(LIBSSH2_SESSION * session, char **data,
++ unsigned int *datalen, const char *src,
++ unsigned int src_len)
++{
++ unsigned char *s, *d;
++ short v;
++ int i = 0, len = 0;
++
++ *data = LIBSSH2_ALLOC(session, (3 * src_len / 4) + 1);
++ d = (unsigned char *) *data;
++ if (!d) {
++ return -1;
++ }
++
++ for(s = (unsigned char *) src; ((char *) s) < (src + src_len); s++) {
++ if ((v = libssh2_base64_reverse_table[*s]) < 0)
++ continue;
++ switch (i % 4) {
++ case 0:
++ d[len] = v << 2;
++ break;
++ case 1:
++ d[len++] |= v >> 4;
++ d[len] = v << 4;
++ break;
++ case 2:
++ d[len++] |= v >> 2;
++ d[len] = v << 6;
++ break;
++ case 3:
++ d[len++] |= v;
++ break;
++ }
++ i++;
++ }
++ if ((i % 4) == 1) {
++ /* Invalid -- We have a byte which belongs exclusively to a partial octet */
++ LIBSSH2_FREE(session, *data);
++ return -1;
++ }
++
++ *datalen = len;
++ return 0;
++}
++
++/* }}} */
++
++#ifdef LIBSSH2DEBUG
++LIBSSH2_API int
++libssh2_trace(LIBSSH2_SESSION * session, int bitmask)
++{
++ session->showmask = bitmask;
++ return 0;
++}
++
++void
++_libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, ...)
++{
++ char buffer[1536];
++ int len;
++ va_list vargs;
++ static const char *const contexts[9] = {
++ "Unknown",
++ "Transport",
++ "Key Exchange",
++ "Userauth",
++ "Connection",
++ "scp",
++ "SFTP Subsystem",
++ "Failure Event",
++ "Publickey Subsystem",
++ };
++
++ if (context < 1 || context > 8) {
++ context = 0;
++ }
++ if (!(session->showmask & (1 << context))) {
++ /* no such output asked for */
++ return;
++ }
++
++ len = snprintf(buffer, 1535, "[libssh2] %s: ", contexts[context]);
++
++ va_start(vargs, format);
++ len += vsnprintf(buffer + len, 1535 - len, format, vargs);
++ buffer[len] = '\n';
++ va_end(vargs);
++ write(2, buffer, len + 1);
++
++}
++
++#else
++LIBSSH2_API int
++libssh2_trace(LIBSSH2_SESSION * session, int bitmask)
++{
++ (void) session;
++ (void) bitmask;
++ return 0;
++}
++#endif
+
+Property changes on: libssh2/src/misc.c
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.3
+Added: svn:eol-style
+ + native
+
+Index: libssh2/src/transport.c
+===================================================================
+--- libssh2/src/transport.c (.../tags/RELEASE_0_11_0)
++++ libssh2/src/transport.c (.../trunk)
+@@ -0,0 +1,815 @@
++/* Copyright (C) 2007 The Written Word, Inc. All rights reserved.
++ * Author: Daniel Stenberg <daniel@haxx.se>
++ *
++ * 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.
++ *
++ * This file handles reading and writing to the SECSH transport layer. RFC4253.
++ */
++
++#include "libssh2_priv.h"
++#include <errno.h>
++#include <fcntl.h>
++
++#include <assert.h>
++
++#define MAX_BLOCKSIZE 32 /* MUST fit biggest crypto block size we use/get */
++#define MAX_MACSIZE 20 /* MUST fit biggest MAC length we support */
++
++#ifdef LIBSSH2DEBUG
++#define UNPRINTABLE_CHAR '.'
++static void
++debugdump(LIBSSH2_SESSION * session,
++ const char *desc, unsigned char *ptr, unsigned long size)
++{
++ size_t i;
++ size_t c;
++ FILE *stream = stdout;
++ unsigned int width = 0x10;
++
++ if (!(session->showmask & (1 << LIBSSH2_DBG_TRANS))) {
++ /* not asked for, bail out */
++ return;
++ }
++
++ fprintf(stream, "=> %s (%d bytes)\n", desc, (int) size);
++
++ for(i = 0; i < size; i += width) {
++
++ fprintf(stream, "%04lx: ", (long)i);
++
++ /* hex not disabled, show it */
++ for(c = 0; c < width; c++) {
++ if (i + c < size)
++ fprintf(stream, "%02x ", ptr[i + c]);
++ else
++ fputs(" ", stream);
++ }
++
++ for(c = 0; (c < width) && (i + c < size); c++) {
++ fprintf(stream, "%c",
++ (ptr[i + c] >= 0x20) &&
++ (ptr[i + c] < 0x80) ? ptr[i + c] : UNPRINTABLE_CHAR);
++ }
++ fputc('\n', stream); /* newline */
++ }
++ fflush(stream);
++}
++#else
++#define debugdump(a,x,y,z)
++#endif
++
++
++/* decrypt() decrypts 'len' bytes from 'source' to 'dest'.
++ *
++ * returns PACKET_NONE on success and PACKET_FAIL on failure
++ */
++
++static libssh2pack_t
++decrypt(LIBSSH2_SESSION * session, unsigned char *source,
++ unsigned char *dest, int len)
++{
++ struct transportpacket *p = &session->packet;
++ int blocksize = session->remote.crypt->blocksize;
++
++ /* if we get called with a len that isn't an even number of blocksizes
++ we risk losing those extra bytes */
++ assert((len % blocksize) == 0);
++
++ while (len >= blocksize) {
++ if (session->remote.crypt->crypt(session, source,
++ &session->remote.crypt_abstract)) {
++ libssh2_error(session, LIBSSH2_ERROR_DECRYPT,
++ (char *) "Error decrypting packet", 0);
++ LIBSSH2_FREE(session, p->payload);
++ return PACKET_FAIL;
++ }
++
++ /* if the crypt() function would write to a given address it
++ wouldn't have to memcpy() and we could avoid this memcpy()
++ too */
++ memcpy(dest, source, blocksize);
++
++ len -= blocksize; /* less bytes left */
++ dest += blocksize; /* advance write pointer */
++ source += blocksize; /* advance read pointer */
++ }
++ return PACKET_NONE; /* all is fine */
++}
++
++/*
++ * fullpacket() gets called when a full packet has been received and properly
++ * collected.
++ */
++static libssh2pack_t
++fullpacket(LIBSSH2_SESSION * session, int encrypted /* 1 or 0 */ )
++{
++ unsigned char macbuf[MAX_MACSIZE];
++ struct transportpacket *p = &session->packet;
++ int rc;
++
++ if (session->fullpacket_state == libssh2_NB_state_idle) {
++ session->fullpacket_macstate = LIBSSH2_MAC_CONFIRMED;
++ session->fullpacket_payload_len = p->packet_length - 1;
++
++ if (encrypted) {
++
++ /* Calculate MAC hash */
++ session->remote.mac->hash(session, macbuf, /* store hash here */
++ session->remote.seqno,
++ p->init, 5,
++ p->payload,
++ session->fullpacket_payload_len,
++ &session->remote.mac_abstract);
++
++ /* Compare the calculated hash with the MAC we just read from
++ * the network. The read one is at the very end of the payload
++ * buffer. Note that 'payload_len' here is the packet_length
++ * field which includes the padding but not the MAC.
++ */
++ if (memcmp(macbuf, p->payload + session->fullpacket_payload_len,
++ session->remote.mac->mac_len)) {
++ session->fullpacket_macstate = LIBSSH2_MAC_INVALID;
++ }
++ }
++
++ session->remote.seqno++;
++
++ /* ignore the padding */
++ session->fullpacket_payload_len -= p->padding_length;
++
++ /* Check for and deal with decompression */
++ if (session->remote.comp && strcmp(session->remote.comp->name, "none")) {
++ unsigned char *data;
++ unsigned long data_len;
++ int free_payload = 1;
++
++ if (session->remote.comp->comp(session, 0,
++ &data, &data_len,
++ LIBSSH2_PACKET_MAXDECOMP,
++ &free_payload,
++ p->payload,
++ session->fullpacket_payload_len,
++ &session->remote.comp_abstract)) {
++ LIBSSH2_FREE(session, p->payload);
++ return PACKET_FAIL;
++ }
++
++ if (free_payload) {
++ LIBSSH2_FREE(session, p->payload);
++ p->payload = data;
++ session->fullpacket_payload_len = data_len;
++ } else {
++ if (data == p->payload) {
++ /* It's not to be freed, because the
++ * compression layer reused payload, So let's
++ * do the same!
++ */
++ session->fullpacket_payload_len = data_len;
++ } else {
++ /* No comp_method actually lets this happen,
++ * but let's prepare for the future */
++
++ LIBSSH2_FREE(session, p->payload);
++
++ /* We need a freeable struct otherwise the
++ * brigade won't know what to do with it */
++ p->payload = LIBSSH2_ALLOC(session, data_len);
++ if (!p->payload) {
++ libssh2_error(session, LIBSSH2_ERROR_ALLOC, (char *)
++ "Unable to allocate memory for copy of uncompressed data",
++ 0);
++ return PACKET_ENOMEM;
++ }
++ memcpy(p->payload, data, data_len);
++ session->fullpacket_payload_len = data_len;
++ }
++ }
++ }
++
++ session->fullpacket_packet_type = p->payload[0];
++
++ debugdump(session, "libssh2_packet_read() plain",
++ p->payload, session->fullpacket_payload_len);
++
++ session->fullpacket_state = libssh2_NB_state_created;
++ }
++
++ if (session->fullpacket_state == libssh2_NB_state_created) {
++ rc = libssh2_packet_add(session, p->payload,
++ session->fullpacket_payload_len,
++ session->fullpacket_macstate);
++ if (rc == PACKET_EAGAIN) {
++ return PACKET_EAGAIN;
++ } else if (rc < 0) {
++ return PACKET_FAIL;
++ }
++ }
++
++ session->fullpacket_state = libssh2_NB_state_idle;
++
++ return session->fullpacket_packet_type;
++}
++
++
++/* {{{ libssh2_packet_read
++ * Collect a packet into the input brigade
++ * block only controls whether or not to wait for a packet to start,
++ * Once a packet starts, libssh2 will block until it is complete
++ *
++ * Returns packet type added to input brigade (PACKET_NONE if nothing added),
++ * or PACKET_FAIL on failure and PACKET_EAGAIN if it couldn't process a full
++ * packet.
++ */
++
++/*
++ * This function reads the binary stream as specified in chapter 6 of RFC4253
++ * "The Secure Shell (SSH) Transport Layer Protocol"
++ */
++libssh2pack_t
++libssh2_packet_read(LIBSSH2_SESSION * session)
++{
++ libssh2pack_t rc;
++ struct transportpacket *p = &session->packet;
++ int remainbuf;
++ int remainpack;
++ int numbytes;
++ int numdecrypt;
++ unsigned char block[MAX_BLOCKSIZE];
++ int blocksize;
++ int encrypted = 1;
++
++ int status;
++
++ /*
++ * All channels, systems, subsystems, etc eventually make it down here
++ * when looking for more incoming data. If a key exchange is going on
++ * (LIBSSH2_STATE_EXCHANGING_KEYS bit is set) then the remote end
++ * will ONLY send key exchange related traffic. In non-blocking mode,
++ * there is a chance to break out of the kex_exchange function with an
++ * EAGAIN status, and never come back to it. If LIBSSH2_STATE_EXCHANGING_KEYS
++ * is active, then we must redirect to the key exchange. However,
++ * if kex_exchange is active (as in it is the one that calls this execution
++ * of packet_read, then don't redirect, as that would be an infinite loop!
++ */
++
++ if (session->state & LIBSSH2_STATE_EXCHANGING_KEYS &&
++ !(session->state & LIBSSH2_STATE_KEX_ACTIVE)) {
++
++ /* Whoever wants a packet won't get anything until the key re-exchange
++ * is done!
++ */
++ _libssh2_debug(session, LIBSSH2_DBG_TRANS, "Redirecting into the"
++ " key re-exchange");
++ status = libssh2_kex_exchange(session, 1, &session->startup_key_state);
++ if (status == PACKET_EAGAIN) {
++ libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
++ "Would block exchanging encryption keys", 0);
++ return PACKET_EAGAIN;
++ } else if (status) {
++ libssh2_error(session, LIBSSH2_ERROR_KEX_FAILURE,
++ "Unable to exchange encryption keys",0);
++ return LIBSSH2_ERROR_KEX_FAILURE;
++ }
++ }
++
++ /*
++ * =============================== NOTE ===============================
++ * I know this is very ugly and not a really good use of "goto", but
++ * this case statement would be even uglier to do it any other way
++ */
++ if (session->readPack_state == libssh2_NB_state_jump1) {
++ session->readPack_state = libssh2_NB_state_idle;
++ encrypted = session->readPack_encrypted;
++ goto libssh2_packet_read_point1;
++ }
++
++ do {
++ if (session->socket_state == LIBSSH2_SOCKET_DISCONNECTED) {
++ return PACKET_NONE;
++ }
++
++ if (session->state & LIBSSH2_STATE_NEWKEYS) {
++ blocksize = session->remote.crypt->blocksize;
++ } else {
++ encrypted = 0; /* not encrypted */
++ blocksize = 5; /* not strictly true, but we can use 5 here to
++ make the checks below work fine still */
++ }
++
++ /* read/use a whole big chunk into a temporary area stored in
++ the LIBSSH2_SESSION struct. We will decrypt data from that
++ buffer into the packet buffer so this temp one doesn't have
++ to be able to keep a whole SSH packet, just be large enough
++ so that we can read big chunks from the network layer. */
++
++ /* how much data there is remaining in the buffer to deal with
++ before we should read more from the network */
++ remainbuf = p->writeidx - p->readidx;
++
++ /* if remainbuf turns negative we have a bad internal error */
++ assert(remainbuf >= 0);
++
++ if (remainbuf < blocksize) {
++ /* If we have less than a blocksize left, it is too
++ little data to deal with, read more */
++ ssize_t nread;
++
++ /* move any remainder to the start of the buffer so
++ that we can do a full refill */
++ if (remainbuf) {
++ memmove(p->buf, &p->buf[p->readidx], remainbuf);
++ p->readidx = 0;
++ p->writeidx = remainbuf;
++ } else {
++ /* nothing to move, just zero the indexes */
++ p->readidx = p->writeidx = 0;
++ }
++
++ /* now read a big chunk from the network into the temp buffer */
++ nread =
++ recv(session->socket_fd, &p->buf[remainbuf],
++ PACKETBUFSIZE - remainbuf,
++ LIBSSH2_SOCKET_RECV_FLAGS(session));
++ if (nread <= 0) {
++ /* check if this is due to EAGAIN and return the special
++ return code if so, error out normally otherwise */
++#ifdef WIN32
++ switch (WSAGetLastError()) {
++ case WSAEWOULDBLOCK:
++ errno = EAGAIN;
++ break;
++
++ case WSAENOTSOCK:
++ errno = EBADF;
++ break;
++
++ case WSAENOTCONN:
++ case WSAECONNABORTED:
++ errno = WSAENOTCONN;
++ break;
++
++ case WSAEINTR:
++ errno = EINTR;
++ break;
++ }
++#endif /* WIN32 */
++ if ((nread < 0) && (errno == EAGAIN)) {
++ session->socket_block_directions =
++ LIBSSH2_SESSION_BLOCK_INBOUND;
++ return PACKET_EAGAIN;
++ }
++ return PACKET_FAIL;
++ }
++ debugdump(session, "libssh2_packet_read() raw",
++ &p->buf[remainbuf], nread);
++ /* advance write pointer */
++ p->writeidx += nread;
++
++ /* update remainbuf counter */
++ remainbuf = p->writeidx - p->readidx;
++ }
++
++ /* how much data to deal with from the buffer */
++ numbytes = remainbuf;
++
++ if (!p->total_num) {
++ /* No payload package area allocated yet. To know the
++ size of this payload, we need to decrypt the first
++ blocksize data. */
++
++ if (numbytes < blocksize) {
++ /* we can't act on anything less than blocksize, but this
++ check is only done for the initial block since once we have
++ got the start of a block we can in fact deal with fractions
++ */
++ return PACKET_EAGAIN;
++ }
++
++ if (encrypted) {
++ rc = decrypt(session, &p->buf[p->readidx], block, blocksize);
++ if (rc != PACKET_NONE) {
++ return rc;
++ }
++ /* save the first 5 bytes of the decrypted package, to be
++ used in the hash calculation later down. */
++ memcpy(p->init, &p->buf[p->readidx], 5);
++ } else {
++ /* the data is plain, just copy it verbatim to
++ the working block buffer */
++ memcpy(block, &p->buf[p->readidx], blocksize);
++ }
++
++ /* advance the read pointer */
++ p->readidx += blocksize;
++
++ /* we now have the initial blocksize bytes decrypted,
++ * and we can extract packet and padding length from it
++ */
++ p->packet_length = libssh2_ntohu32(block);
++ p->padding_length = block[4];
++
++ /* total_num is the number of bytes following the initial
++ (5 bytes) packet length and padding length fields */
++ p->total_num =
++ p->packet_length - 1 +
++ (encrypted ? session->remote.mac->mac_len : 0);
++
++ /* RFC4253 section 6.1 Maximum Packet Length says:
++ *
++ * "All implementations MUST be able to process
++ * packets with uncompressed payload length of 32768
++ * bytes or less and total packet size of 35000 bytes
++ * or less (including length, padding length, payload,
++ * padding, and MAC.)."
++ */
++ if (p->total_num > LIBSSH2_PACKET_MAXPAYLOAD) {
++ return PACKET_TOOBIG;
++ }
++
++ /* Get a packet handle put data into. We get one to
++ hold all data, including padding and MAC. */
++ p->payload = LIBSSH2_ALLOC(session, p->total_num);
++ if (!p->payload) {
++ return PACKET_ENOMEM;
++ }
++ /* init write pointer to start of payload buffer */
++ p->wptr = p->payload;
++
++ if (blocksize > 5) {
++ /* copy the data from index 5 to the end of
++ the blocksize from the temporary buffer to
++ the start of the decrypted buffer */
++ memcpy(p->wptr, &block[5], blocksize - 5);
++ p->wptr += blocksize - 5; /* advance write pointer */
++ }
++
++ /* init the data_num field to the number of bytes of
++ the package read so far */
++ p->data_num = p->wptr - p->payload;
++
++ /* we already dealt with a blocksize worth of data */
++ numbytes -= blocksize;
++ }
++
++ /* how much there is left to add to the current payload
++ package */
++ remainpack = p->total_num - p->data_num;
++
++ if (numbytes > remainpack) {
++ /* if we have more data in the buffer than what is going into this
++ particular packet, we limit this round to this packet only */
++ numbytes = remainpack;
++ }
++
++ if (encrypted) {
++ /* At the end of the incoming stream, there is a MAC,
++ and we don't want to decrypt that since we need it
++ "raw". We MUST however decrypt the padding data
++ since it is used for the hash later on. */
++ int skip = session->remote.mac->mac_len;
++
++ /* if what we have plus numbytes is bigger than the
++ total minus the skip margin, we should lower the
++ amount to decrypt even more */
++ if ((p->data_num + numbytes) > (p->total_num - skip)) {
++ numdecrypt = (p->total_num - skip) - p->data_num;
++ } else {
++ int frac;
++ numdecrypt = numbytes;
++ frac = numdecrypt % blocksize;
++ if (frac) {
++ /* not an aligned amount of blocks,
++ align it */
++ numdecrypt -= frac;
++ /* and make it no unencrypted data
++ after it */
++ numbytes = 0;
++ }
++ }
++ } else {
++ /* unencrypted data should not be decrypted at all */
++ numdecrypt = 0;
++ }
++
++ /* if there are bytes to decrypt, do that */
++ if (numdecrypt > 0) {
++ /* now decrypt the lot */
++ rc = decrypt(session, &p->buf[p->readidx], p->wptr, numdecrypt);
++ if (rc != PACKET_NONE) {
++ return rc;
++ }
++
++ /* advance the read pointer */
++ p->readidx += numdecrypt;
++ /* advance write pointer */
++ p->wptr += numdecrypt;
++ /* increse data_num */
++ p->data_num += numdecrypt;
++
++ /* bytes left to take care of without decryption */
++ numbytes -= numdecrypt;
++ }
++
++ /* if there are bytes to copy that aren't decrypted, simply
++ copy them as-is to the target buffer */
++ if (numbytes > 0) {
++ memcpy(p->wptr, &p->buf[p->readidx], numbytes);
++
++ /* advance the read pointer */
++ p->readidx += numbytes;
++ /* advance write pointer */
++ p->wptr += numbytes;
++ /* increse data_num */
++ p->data_num += numbytes;
++ }
++
++ /* now check how much data there's left to read to finish the
++ current packet */
++ remainpack = p->total_num - p->data_num;
++
++ if (!remainpack) {
++ /* we have a full packet */
++ libssh2_packet_read_point1:
++ rc = fullpacket(session, encrypted);
++ if (rc == PACKET_EAGAIN) {
++
++ if (session->packAdd_state != libssh2_NB_state_idle)
++ {
++ /* fullpacket only returns PACKET_EAGAIN if
++ * libssh2_packet_add returns PACKET_EAGAIN. If that
++ * returns PACKET_EAGAIN but the packAdd_state is idle,
++ * then the packet has been added to the brigade, but some
++ * immediate action that was taken based on the packet
++ * type (such as key re-exchange) is not yet complete.
++ * Clear the way for a new packet to be read in.
++ */
++ session->readPack_encrypted = encrypted;
++ session->readPack_state = libssh2_NB_state_jump1;
++ }
++
++ return PACKET_EAGAIN;
++ }
++
++ p->total_num = 0; /* no packet buffer available */
++
++ return rc;
++ }
++ } while (1); /* loop */
++
++ return PACKET_FAIL; /* we never reach this point */
++}
++
++/* }}} */
++
++static libssh2pack_t
++send_existing(LIBSSH2_SESSION * session, unsigned char *data,
++ unsigned long data_len, ssize_t * ret)
++{
++ ssize_t rc;
++ ssize_t length;
++ struct transportpacket *p = &session->packet;
++
++ if (!p->outbuf) {
++ *ret = 0;
++ return PACKET_NONE;
++ }
++
++ /* send as much as possible of the existing packet */
++ if ((data != p->odata) || (data_len != p->olen)) {
++ /* When we are about to complete the sending of a packet, it is vital
++ that the caller doesn't try to send a new/different packet since
++ we don't add this one up until the previous one has been sent. To
++ make the caller really notice his/hers flaw, we return error for
++ this case */
++ return PACKET_BADUSE;
++ }
++
++ *ret = 1; /* set to make our parent return */
++
++ /* number of bytes left to send */
++ length = p->ototal_num - p->osent;
++
++ rc = send(session->socket_fd, &p->outbuf[p->osent], length,
++ LIBSSH2_SOCKET_SEND_FLAGS(session));
++
++ if (rc == length) {
++ /* the remainder of the package was sent */
++ LIBSSH2_FREE(session, p->outbuf);
++ p->outbuf = NULL;
++ p->ototal_num = 0;
++ } else if (rc < 0) {
++ /* nothing was sent */
++ if (errno != EAGAIN) {
++ /* send failure! */
++ return PACKET_FAIL;
++ }
++ session->socket_block_directions = LIBSSH2_SESSION_BLOCK_OUTBOUND;
++ return PACKET_EAGAIN;
++ }
++
++ debugdump(session, "libssh2_packet_write send()", &p->outbuf[p->osent],
++ length);
++ p->osent += length; /* we sent away this much data */
++
++ return PACKET_NONE;
++}
++
++/* {{{ libssh2_packet_write
++ * Send a packet, encrypting it and adding a MAC code if necessary
++ * Returns 0 on success, non-zero on failure.
++ *
++ * Returns PACKET_EAGAIN if it would block - and if it does so, you should
++ * call this function again as soon as it is likely that more data can be
++ * sent, and this function should then be called with the same argument set
++ * (same data pointer and same data_len) until zero or failure is returned.
++ *
++ * NOTE: this function does not verify that 'data_len' is less than ~35000
++ * which is what all implementations should support at least as packet size.
++ * (RFC4253 section 6.1)
++ */
++int
++libssh2_packet_write(LIBSSH2_SESSION * session, unsigned char *data,
++ unsigned long data_len)
++{
++ int blocksize =
++ (session->state & LIBSSH2_STATE_NEWKEYS) ? session->local.crypt->
++ blocksize : 8;
++ int padding_length;
++ int packet_length;
++ int total_length;
++ int free_data = 0;
++#ifdef RANDOM_PADDING
++ int rand_max;
++ int seed = data[0]; /* FIXME: make this random */
++#endif
++ struct transportpacket *p = &session->packet;
++ int encrypted;
++ int i;
++ ssize_t ret;
++ libssh2pack_t rc;
++ unsigned char *orgdata = data;
++ unsigned long orgdata_len = data_len;
++
++ debugdump(session, "libssh2_packet_write plain", data, data_len);
++
++ /* FIRST, check if we have a pending write to complete */
++ rc = send_existing(session, data, data_len, &ret);
++ if (rc || ret) {
++ return rc;
++ }
++
++ encrypted = (session->state & LIBSSH2_STATE_NEWKEYS) ? 1 : 0;
++
++ /* check if we should compress */
++ if (encrypted && strcmp(session->local.comp->name, "none")) {
++ if (session->local.comp->comp(session, 1, &data, &data_len,
++ LIBSSH2_PACKET_MAXCOMP,
++ &free_data, data, data_len,
++ &session->local.comp_abstract)) {
++ return PACKET_COMPRESS; /* compression failure */
++ }
++ }
++
++ /* RFC4253 says: Note that the length of the concatenation of
++ 'packet_length', 'padding_length', 'payload', and 'random padding'
++ MUST be a multiple of the cipher block size or 8, whichever is
++ larger. */
++
++ /* Plain math: (4 + 1 + packet_length + padding_length) % blocksize == 0 */
++
++ packet_length = data_len + 1 + 4; /* 1 is for padding_length field
++ 4 for the packet_length field */
++
++ /* at this point we have it all except the padding */
++
++ /* first figure out our minimum padding amount to make it an even
++ block size */
++ padding_length = blocksize - (packet_length % blocksize);
++
++ /* if the padding becomes too small we add another blocksize worth
++ of it (taken from the original libssh2 where it didn't have any
++ real explanation) */
++ if (padding_length < 4) {
++ padding_length += blocksize;
++ }
++#ifdef RANDOM_PADDING
++ /* FIXME: we can add padding here, but that also makes the packets
++ bigger etc */
++
++ /* now we can add 'blocksize' to the padding_length N number of times
++ (to "help thwart traffic analysis") but it must be less than 255 in
++ total */
++ rand_max = (255 - padding_length) / blocksize + 1;
++ padding_length += blocksize * (seed % rand_max);
++#endif
++
++ packet_length += padding_length;
++
++ /* append the MAC length to the total_length size */
++ total_length =
++ packet_length + (encrypted ? session->local.mac->mac_len : 0);
++
++ /* allocate memory to store the outgoing packet in, in case we can't
++ send the whole one and thus need to keep it after this function
++ returns. */
++ p->outbuf = LIBSSH2_ALLOC(session, total_length);
++ if (!p->outbuf) {
++ return PACKET_ENOMEM;
++ }
++
++ /* store packet_length, which is the size of the whole packet except
++ the MAC and the packet_length field itself */
++ libssh2_htonu32(p->outbuf, packet_length - 4);
++ /* store padding_length */
++ p->outbuf[4] = padding_length;
++ /* copy the payload data */
++ memcpy(p->outbuf + 5, data, data_len);
++ /* fill the padding area with random junk */
++ libssh2_random(p->outbuf + 5 + data_len, padding_length);
++ if (free_data) {
++ LIBSSH2_FREE(session, data);
++ }
++
++ if (encrypted) {
++ /* Calculate MAC hash. Put the output at index packet_length,
++ since that size includes the whole packet. The MAC is
++ calculated on the entire unencrypted packet, including all
++ fields except the MAC field itself. */
++ session->local.mac->hash(session, p->outbuf + packet_length,
++ session->local.seqno, p->outbuf,
++ packet_length, NULL, 0,
++ &session->local.mac_abstract);
++
++ /* Encrypt the whole packet data, one block size at a time.
++ The MAC field is not encrypted. */
++ for(i = 0; i < packet_length; i += session->local.crypt->blocksize) {
++ unsigned char *ptr = &p->outbuf[i];
++ if (session->local.crypt->crypt(session, ptr,
++ &session->local.crypt_abstract))
++ return PACKET_FAIL; /* encryption failure */
++ }
++ }
++
++ session->local.seqno++;
++
++ ret = send(session->socket_fd, p->outbuf, total_length,
++ LIBSSH2_SOCKET_SEND_FLAGS(session));
++
++ if (ret != -1) {
++ debugdump(session, "libssh2_packet_write send()", p->outbuf, ret);
++ }
++ if (ret != total_length) {
++ if ((ret > 0) || ((ret == -1) && (errno == EAGAIN))) {
++ /* the whole packet could not be sent, save the rest */
++ session->socket_block_directions = LIBSSH2_SESSION_BLOCK_OUTBOUND;
++ p->odata = orgdata;
++ p->olen = orgdata_len;
++ p->osent = (ret == -1) ? 0 : ret;
++ p->ototal_num = total_length;
++ return PACKET_EAGAIN;
++ }
++ return PACKET_FAIL;
++ }
++
++ /* the whole thing got sent away */
++ p->odata = NULL;
++ p->olen = 0;
++ LIBSSH2_FREE(session, p->outbuf);
++ p->outbuf = NULL;
++
++ return PACKET_NONE; /* all is good */
++}
++
++/* }}} */
++
+
+Property changes on: libssh2/src/transport.c
+___________________________________________________________________
+Added: svn:mime-type
+ + text/x-c
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.1
+Added: svn:eol-style
+ + native
+Added: svn:executable
+ + *
+
+
+Property changes on: libssh2/src
+___________________________________________________________________
+Added: svn:ignore
+ + libssh2_config.h
+
+
+Index: package.xml
+===================================================================
+Cannot display: file marked as a binary type.
+svn:mime-type = application/xml
+
+Property changes on: package.xml
+___________________________________________________________________
+Deleted: svn:mime-type
+ - application/xml
+
+Index: ssh2_fopen_wrappers.c
+===================================================================
+--- ssh2_fopen_wrappers.c (.../tags/RELEASE_0_11_0)
++++ ssh2_fopen_wrappers.c (.../trunk)
+@@ -46,7 +46,7 @@
+ libssh2_channel_set_blocking(abstract->channel, abstract->is_blocking);
+
+ readstate = libssh2_channel_read_ex(abstract->channel, abstract->streamid, buf, count);
+- return (readstate == LIBSSH2_ERROR_EAGAIN ? 0 : readstate);
++ return (readstate < 0 ? 0 : readstate);
+ }
+
+ static int php_ssh2_channel_stream_close(php_stream *stream, int close_handle TSRMLS_DC)
+
+Property changes on: ssh2_fopen_wrappers.c
+___________________________________________________________________
+Modified: cvs2svn:cvs-rev
+ - 1.15
+ + 1.16
+
+Index: php_ssh2.h
+===================================================================
+--- php_ssh2.h (.../tags/RELEASE_0_11_0)
++++ php_ssh2.h (.../trunk)
+@@ -101,6 +101,10 @@
+ } php_ssh2_pkey_subsys_data;
+ #endif
+
++#ifndef PHP_WIN32
++#define closesocket(s) close(s)
++#endif
++
+ #ifdef ZTS
+ #define SSH2_TSRMLS_SET(datap) ((php_ssh2_session_data*)(datap))->tsrm_ls = TSRMLS_C
+ #define SSH2_TSRMLS_FETCH(datap) TSRMLS_D = ((php_ssh2_session_data*)(datap))->tsrm_ls
+@@ -109,6 +113,12 @@
+ #define SSH2_TSRMLS_FETCH(datap)
+ #endif
+
++#if (PHP_MAJOR_VERSION == 5) && (PHP_MINOR_VERSION >= 3)
++#define ZEND_IS_CALLABLE_TSRMLS_CC TSRMLS_CC
++#else
++#define ZEND_IS_CALLABLE_TSRMLS_CC
++#endif
++
+ /* < 5.3 compatibility */
+ #ifndef Z_REFCOUNT_P
+ #define Z_REFCOUNT_P(pz) (pz)->refcount
+
+Property changes on: php_ssh2.h
+___________________________________________________________________
+Modified: cvs2svn:cvs-rev
+ - 1.12
+ + 1.14
+
+Index: EXPERIMENTAL
+===================================================================
+
+Property changes on: EXPERIMENTAL
+___________________________________________________________________
+Added: svn:eol-style
+ + native
+Added: svn:keywords
+ + Id Rev Revision Date LastChangedDate LastChangedRevision Author LastChangedBy HeadURL URL
+Added: cvs2svn:cvs-rev
+ + 1.1
+
+
+Property changes on: .
+___________________________________________________________________
+Added: svn:ignore
+ + #*#
+*.dsw
+*.la
+*.lo
+*.ncb
+*.opt
+*.plg
+*.tgz
+*~
+.#*
+.deps
+.libs
+Debug
+Debug_TS
+Makefile
+Makefile.fragments
+Makefile.global
+Makefile.objects
+Release
+Release_TS
+Release_TSDbg
+Release_TS_inline
+Release_inline
+acinclude.m4
+aclocal.m4
+autom4te.cache
+build
+config.cache
+config.guess
+config.h
+config.h.in
+config.log
+config.nice
+config.status
+config.sub
+configure
+configure.in
+conftest
+conftest.c
+include
+install-sh
+libs.mk
+libtool
+ltmain.sh
+missing
+mkinstalldirs
+modules
+scan_makefile_in.awk
+*.gcda
+*.gcno
+run-tests.php
+
+
projects / packages / php-pecl-ssh2.git / commitdiff