Late commit -- This is for release 0.10

Drop these old references to initial window size, they were a mistake
BFN
2005-05-24 14:01:38 +00:00 · 2005-05-18 17:12:40 +00:00 · 2005-05-18 17:10:27 +00:00 · 2005-05-18 17:08:29 +00:00 · 2005-05-17 19:30:59 +00:00 · 2005-05-17 17:18:48 +00:00
27 changed files with 2243 additions and 550 deletions
--- a/2
+++ b/2
@@ -1,4 +1,4 @@
-/* Copyright (c) 2004, Sara Golemon <sarag@libssh2.org>
+/* Copyright (c) 2004-2005, Sara Golemon <sarag@libssh2.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms,
--- a/Makefile.in
+++ b/Makefile.in
@@ -42,11 +42,13 @@ dist:
 	ln -s . $(DISTLIB)
 	tar -zcf $(DISTLIB).tar.gz \
 		$(DISTLIB)/configure $(DISTLIB)/Makefile.in $(DISTLIB)/ssh2_sample.c \
-		$(DISTLIB)/LICENSE $(DISTLIB)/README $(DISTLIB)/TODO $(DISTLIB)/INSTALL \
+		$(DISTLIB)/LICENSE $(DISTLIB)/README $(DISTLIB)/INSTALL \
 		$(DISTLIB)/mkinstalldirs $(DISTLIB)/install-sh $(DISTLIB)/config.sub $(DISTLIB)/config.guess \
 		$(DISTLIB)/src/*.c $(DISTLIB)/src/Makefile.in \
 		$(DISTLIB)/include/libssh2.h $(DISTLIB)/include/libssh2_priv.h $(DISTLIB)/include/libssh2_sftp.h \
-		$(DISTLIB)/include/libssh2_config.h.in
+		$(DISTLIB)/include/libssh2_config.h.in \
+		$(DISTLIB)/win32/config.mk $(DISTLIB)/win32/libssh2_config.h $(DISTLIB)/win32/rules.mk \
+		$(DISTLIB)/win32/libssh2.dsp $(DISTLIB)/win32/libssh2.dsw $(DISTLIB)/win32/ssh2_sample.dsp
 	rm -f $(DISTLIB)
 dist_nmake:
 	autoheader
--- a/88
+++ b/88
@@ -1,6 +1,94 @@
 libssh2 - SSH2 library
 ======================

+Version 0.11
+------------
+
+  Added libssh2_channel_receive_window_adjust() to be able to increase the size of the receive window.
+
+  Added queueing for small window_adjust packets to avoid unnecessary packet conversation.
+
+Version 0.10
+------------
+
+  Added developer debugging hooks.  See --enable-debug-* options to ./configure
+
+  Ignore extended data in the SFTP layer.  With no other mechanism to deal with that data it'd just fill up and get stuck.
+
+  (Re)Fixed channel_write() to provide an opportunity for window space to become available again.
+
+  (Re)Fixed SFTP INIT to send the correct SFTP packet length.
+
+  Fixed segfault when client and host can't agree on a hostkey/crypt/mac/comp method. (Thanks puudeli)
+
+  Fixed major issue with sftp packet buffering mechanism.  Using wrong blocking semantics. (No puudeli, YOU the man)
+
+  Reduced busy-looping of libssh2_sftp_packet_requirev.
+
+Version 0.9
+-----------
+
+  Changed blocking_read to only block as much as necessary and not an arbitrary length of time. (Thanks Felix)
+
+  Fixed SFTP INIT/VERSION to exclude request_id and send correct maximum version number.
+
+  Fixed SFTP to be properly BC with version 1 and 2 servers.
+
+  Fixed libssh2_poll() to recognized closed sessions/channels.
+
+  Fixed libssh2_channel_write_ex() to fully block when set to blocking mode.  Return actual bytes written as well.  (Thanks deadem)
+
+  Added tests for -lm and -lsocket and add them when necessary.
+
+  Added libssh2_channel_window_read_ex() and libssh2_channel_window_write_ex()
+  for examining the ssh transport windowing states.
+
+Version 0.8
+-----------
+
+  Fix potential segfault in compression/decompression.
+
+  Fix compatability with older versions of OpenSSL
+
+  Swapped order of none,zlib compression modes to prefer no compression by default.
+
+  Added sys/uio.h for platforms (FBSD) which need it in order to define struct iovec.
+
+  Added libssh2_poll() to check status of sockets/channels/listeners.
+
+  Removed unnecessary inclusion of stdio.h (holdover from debugging)
+
+Version 0.7
+-----------
+
+  Added libssh2_userauth_hostbased_fromfile_ex() for authenticating from hostkey.
+
+  Added configure recognition for MacOSX (Darwin) (Thanks Gabe)
+
+  Fixed extended data identification in libssh2_channel_read().
+
+  Fixed window adjust code.  Hadn't acknowledged adjustments correctly.
+
+  Removed initial_window_size requirement for sending window adjust packet.
+
+
+Version 0.6
+-----------
+
+  Added LIBSSH2_FLAG_SIGPIPE to enable/disable SIGPIPE generated by send()/recv() calls. Default off.
+
+  Added libssh2_session_flag() to set optional session flags.
+
+  Collapsed exchanging_keys/newkeys/authenticated flags into single state attribute.
+
+  Fix zlib compression issue when internal buffer state misses partial sync.
+
+  Fix segfault when libssh2_session_methods() is called prior to session_startup().
+
+  Fixed client to server channel windowing.  Pervent send queue overruns.
+
+  Swapped banner send/receive order (send first, then wait for response).
+
 Version 0.5
 -----------

--- a/3
+++ b/3
@@ -1,3 +0,0 @@
-* More Crypt Methods
-* hmac-md5, hmac-md5-96
-* Review callbacks
--- a/configure.in
+++ b/configure.in
@@ -1,5 +1,5 @@
 # AC_PREREQ(2.57)
-AC_INIT(libssh2,0.5,sarag@libssh2.org)
+AC_INIT(libssh2,0.10,sarag@libssh2.org)
 AC_CONFIG_SRCDIR([src])
 AC_CONFIG_HEADER([include/libssh2_config.h])

@@ -11,13 +11,27 @@ case "$host" in
 	SHLIB_LDFLAGS="-shared"
 	CFLAGS="$CFLAGS -DLIBSSH2_WIN32"
    ;;
+	*darwin*)
+	SHLIB_SUFFIX_NAME="dylib"
+	SHLIB_LDFLAGS="-dynamiclib -flat_namespace"
+	CFLAGS="$CFLAGS -DLIBSSH2_DARWIN"
+	;;
    *)
    SHLIB_SUFFIX_NAME="so"
    SHLIB_LDFLAGS="-shared"
    ;;
 esac
+
+AC_CHECK_LIB(socket, socket, [
+SHLIB_LDFLAGS="$SHLIB_LDFLAGS -lsocket"
+LIBS="$LIBS -lsocket"
+])
+AC_CHECK_LIB(m, ceil, [ SHLIB_LDFLAGS="$SHLIB_LDFLAGS -lm" ])
+
+
 AC_SUBST(SHLIB_SUFFIX_NAME)
 AC_SUBST(SHLIB_LDFLAGS)
+AC_SUBST(LIBS)

 AC_PROG_CC
 AC_PROG_INSTALL
@@ -155,9 +169,48 @@ if test "$GEX_NEW" != "no"; then
  AC_DEFINE(LIBSSH2_DH_GEX_NEW, 1, [Enable newer diffie-hellman-group-exchange-sha1 syntax])
 fi

+#
+# Optional debugging -- Meant for developer maintenance only
+# When enabled, the relevant debugging information will be written on stderr
+#
+AC_ARG_ENABLE(debug-transport,
+	AC_HELP_STRING([--enable-debug-transport],[Output transport layer debugging info to stderr]),
+	[AC_DEFINE(LIBSSH2_DEBUG_TRANSPORT, 1, [Output transport layer debugging info to stderr])])
+AC_ARG_ENABLE(debug-kex,
+	AC_HELP_STRING([--enable-debug-kex],[Output Key Exchange debugging info to stderr]),
+	[AC_DEFINE(LIBSSH2_DEBUG_KEX, 1, [Output Key Exchange debugging info to stderr])])
+AC_ARG_ENABLE(debug-userauth,
+	AC_HELP_STRING([--enable-debug-userauth],[Output userauth debugging info to stderr]),
+	[AC_DEFINE(LIBSSH2_DEBUG_USERAUTH, 1, [Output userauth layer debugging info to stderr])])
+AC_ARG_ENABLE(debug-channel,
+	AC_HELP_STRING([--enable-debug-connection],[Output connection layer debugging info to stderr]),
+	[AC_DEFINE(LIBSSH2_DEBUG_CONNECTION, 1, [Output connection layer debugging info to stderr])])
+AC_ARG_ENABLE(debug-scp,
+	AC_HELP_STRING([--enable-debug-scp],[Output scp subsystem debugging info to stderr]),
+	[AC_DEFINE(LIBSSH2_DEBUG_SCP, 1, [Output scp subsystem debugging info to stderr])])
+AC_ARG_ENABLE(debug-sftp,
+	AC_HELP_STRING([--enable-debug-sftp],[Output sftp subsystem debugging info to stderr]),
+	[AC_DEFINE(LIBSSH2_DEBUG_SFTP, 1, [Output sftp subsystem debugging info to stderr])])
+AC_ARG_ENABLE(debug-errors,
+	AC_HELP_STRING([--enable-debug-errors],[Output failure events to stderr]),
+	[AC_DEFINE(LIBSSH2_DEBUG_ERRORS, 1, [Output failure events to stderr])])
+AC_ARG_ENABLE(debug-all,
+	AC_HELP_STRING([--enable-debug-all],[Output debugging info for all layers to stderr]),
+	[
+		AC_DEFINE(LIBSSH2_DEBUG_TRANSPORT, 1, [Output transport layer debugging info to stderr])
+		AC_DEFINE(LIBSSH2_DEBUG_KEX, 1, [Output Key Exchange debugging info to stderr])
+		AC_DEFINE(LIBSSH2_DEBUG_USERAUTH, 1, [Output userauth layer debugging info to stderr])
+		AC_DEFINE(LIBSSH2_DEBUG_CONNECTION, 1, [Output connection layer debugging info to stderr])
+		AC_DEFINE(LIBSSH2_DEBUG_SCP, 1, [Output scp subsystem debugging info to stderr])
+		AC_DEFINE(LIBSSH2_DEBUG_SFTP, 1, [Output sftp subsystem debugging info to stderr])
+		AC_DEFINE(LIBSSH2_DEBUG_ERRORS, 1, [Output failure events to stderr])
+	])
+
+
 # Checks for header files.
 # AC_HEADER_STDC
-AC_CHECK_HEADERS([errno.h fcntl.h stdio.h stdlib.h unistd.h])
+AC_CHECK_HEADERS([errno.h fcntl.h stdio.h stdlib.h unistd.h sys/uio.h sys/select.h])
+AC_CHECK_FUNCS(poll gettimeofday select)

 # Checks for typedefs, structures, and compiler characteristics.
 AC_C_CONST
--- a/include/libssh2.h
+++ b/include/libssh2.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2004, Sara Golemon <sarag@libssh2.org>
+/* Copyright (c) 2004-2005, Sara Golemon <sarag@libssh2.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms,
@@ -44,21 +44,22 @@

 /* 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
-# ifndef _MSC_VER
-#  include <sys/uio.h>
-# endif
-#else
-# define LIBSSH2_API
-#endif
+# 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))
+# include <sys/uio.h>
 #endif

-#if _MSC_VER < 1300
+#if defined(LIBSSH2_WIN32) && _MSC_VER < 1300
 typedef unsigned __int64 libssh2_uint64_t;
 typedef __int64 libssh2_int64_t;
 #else
@@ -66,8 +67,8 @@ typedef unsigned long long libssh2_uint64_t;
 typedef long long libssh2_int64_t;
 #endif

-#define LIBSSH2_VERSION								"0.5"
-#define LIBSSH2_APINO								200412301450
+#define LIBSSH2_VERSION								"0.10"
+#define LIBSSH2_APINO								200503281457

 /* Part of every banner, user specified or not */
 #define LIBSSH2_SSH_BANNER							"SSH-2.0-libssh2_" LIBSSH2_VERSION
@@ -76,51 +77,6 @@ typedef long long libssh2_int64_t;
 #define LIBSSH2_SSH_DEFAULT_BANNER					LIBSSH2_SSH_BANNER
 #define LIBSSH2_SSH_DEFAULT_BANNER_WITH_CRLF		LIBSSH2_SSH_DEFAULT_BANNER "\r\n"

-/* Capabilities */
-#define LIBSSH2_KEX_DH_GROUP1
-#define LIBSSH2_KEX_DH_GROUP14
-#define LIBSSH2_KEX_DH_GROUP_EXCHANGE
-
-#ifndef OPENSSL_NO_RSA
-#define LIBSSH2_HOSTKEY_RSA
-#endif
-#ifndef OPENSSL_NO_DSA
-#define LIBSSH2_HOSTKEY_DSA
-#endif
-
-#ifndef OPENSSL_NO_AES
-#define LIBSSH2_CRYPT_AES256_CBC
-#define LIBSSH2_CRYPT_RIJNDAEL_CBC_LYSATOR_LIU_SE
-#define LIBSSH2_CRYPT_AES192_CBC
-#define LIBSSH2_CRYPT_AES128_CBC
-#endif
-#ifndef OPENSSL_NO_BLOWFISH
-#define LIBSSH2_CRYPT_BLOWFISH_CBC
-#endif
-#ifndef OPENSSL_NO_RC4
-#define LIBSSH2_CRYPT_ARCFOUR
-#endif
-#ifndef OPENSSL_NO_CAST
-#define LIBSSH2_CRYPT_CAST128_CBC
-#endif
-#ifndef OPENSSL_NO_DES
-#define LIBSSH2_CRYPT_3DES_CBC
-#endif
-/* LIBSSH2_CRYPT_NONE already defined (or not) by ./configure */
-
-#ifdef LIBSSH2_HAVE_ZLIB
-#define LIBSSH2_COMP_ZLIB
-#endif
-#define LIBSSH2_COMP_NONE
-
-#define LIBSSH2_MAC_SHA1
-#define LIBSSH2_MAC_SHA1_96
-#ifndef OPENSSL_NO_RIPEMD
-#define LIBSSH2_MAC_RIPEMD160
-#define LIBSSH2_MAC_RIPEMD160_OPENSSH_COM
-#endif
-/* LIBSSH2_MAC_NONE already defined (or not) by ./configure */
-
 /* Default generate and safe prime sizes for diffie-hellman-group-exchange-sha1 */
 #define LIBSSH2_DH_GEX_MINGROUP     1024
 #define LIBSSH2_DH_GEX_OPTGROUP     1536
@@ -180,10 +136,47 @@ typedef long long libssh2_int64_t;
 #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 */
+
+/* Hash Types */
 #define LIBSSH2_HOSTKEY_HASH_MD5							1
 #define LIBSSH2_HOSTKEY_HASH_SHA1							2

@@ -239,6 +232,7 @@ typedef struct _LIBSSH2_LISTENER					LIBSSH2_LISTENER;
 #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

 /* 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);
@@ -259,6 +253,8 @@ LIBSSH2_API int libssh2_session_method_pref(LIBSSH2_SESSION *session, int method
 LIBSSH2_API 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_flag(LIBSSH2_SESSION *session, int flag, int value);
+
 /* Userauth API */
 LIBSSH2_API char *libssh2_userauth_list(LIBSSH2_SESSION *session, char *username, int username_len);
 LIBSSH2_API int libssh2_userauth_authenticated(LIBSSH2_SESSION *session);
@@ -270,10 +266,20 @@ LIBSSH2_API int libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION *session,
 																				 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, char *username, int username_len,
+																				 char *publickey, char *privatekey,
+																				 char *passphrase,
+																				 char *hostname, int hostname_len,
+																				 char *local_username, 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))
+
+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
@@ -313,10 +319,18 @@ LIBSSH2_API int libssh2_channel_read_ex(LIBSSH2_CHANNEL *channel, int stream_id,
 #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 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 int 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_channel_set_blocking(LIBSSH2_CHANNEL *channel, int blocking);
 LIBSSH2_API void libssh2_channel_handle_extended_data(LIBSSH2_CHANNEL *channel, int ignore_mode);
 /* libssh2_channel_ignore_extended_data() is defined below for BC with version 0.1
--- a/include/libssh2_config.h.in
+++ b/include/libssh2_config.h.in
@@ -6,12 +6,21 @@
 /* Define to 1 if you have the <fcntl.h> header file. */
 #undef HAVE_FCNTL_H

+/* Define to 1 if you have the `gettimeofday' function. */
+#undef HAVE_GETTIMEOFDAY
+
 /* Define to 1 if you have the <inttypes.h> header file. */
 #undef HAVE_INTTYPES_H

 /* Define to 1 if you have the <memory.h> header file. */
 #undef HAVE_MEMORY_H

+/* Define to 1 if you have the `poll' function. */
+#undef HAVE_POLL
+
+/* Define to 1 if you have the `select' function. */
+#undef HAVE_SELECT
+
 /* Define to 1 if you have the <stdint.h> header file. */
 #undef HAVE_STDINT_H

@@ -27,18 +36,45 @@
 /* Define to 1 if you have the <string.h> header file. */
 #undef HAVE_STRING_H

+/* Define to 1 if you have the <sys/select.h> header file. */
+#undef HAVE_SYS_SELECT_H
+
 /* Define to 1 if you have the <sys/stat.h> header file. */
 #undef HAVE_SYS_STAT_H

 /* Define to 1 if you have the <sys/types.h> header file. */
 #undef HAVE_SYS_TYPES_H

+/* Define to 1 if you have the <sys/uio.h> header file. */
+#undef HAVE_SYS_UIO_H
+
 /* Define to 1 if you have the <unistd.h> header file. */
 #undef HAVE_UNISTD_H

 /* Enable "none" cipher -- NOT RECOMMENDED */
 #undef LIBSSH2_CRYPT_NONE

+/* Output connection layer debugging info to stderr */
+#undef LIBSSH2_DEBUG_CONNECTION
+
+/* Output failure events to stderr */
+#undef LIBSSH2_DEBUG_ERRORS
+
+/* Output Key Exchange debugging info to stderr */
+#undef LIBSSH2_DEBUG_KEX
+
+/* Output scp subsystem debugging info to stderr */
+#undef LIBSSH2_DEBUG_SCP
+
+/* Output sftp subsystem debugging info to stderr */
+#undef LIBSSH2_DEBUG_SFTP
+
+/* Output transport layer debugging info to stderr */
+#undef LIBSSH2_DEBUG_TRANSPORT
+
+/* Output userauth layer debugging info to stderr */
+#undef LIBSSH2_DEBUG_USERAUTH
+
 /* Enable newer diffie-hellman-group-exchange-sha1 syntax */
 #undef LIBSSH2_DH_GEX_NEW

--- a/include/libssh2_priv.h
+++ b/include/libssh2_priv.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2004, Sara Golemon <sarag@libssh2.org>
+/* Copyright (c) 2004-2005, Sara Golemon <sarag@libssh2.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms,
@@ -113,6 +113,7 @@ struct _LIBSSH2_CHANNEL {
 	int blocking;

 	libssh2_channel_data local, remote;
+	unsigned long adjust_queue; /* Amount of bytes to be refunded to receive window (but not yet sent) */

 	LIBSSH2_SESSION *session;

@@ -180,9 +181,8 @@ struct _LIBSSH2_SESSION {
 	char *kex_prefs;
 	char *hostkey_prefs;

-	int exchanging_keys;
-	int newkeys;
-	int authenticated;
+	int state;
+	int flags;

 	/* Agreed Key Exchange Method */
 	LIBSSH2_KEX_METHOD *kex;
@@ -233,6 +233,21 @@ struct _LIBSSH2_SESSION {
 	int err_code;
 };

+/* session.state bits */
+#define LIBSSH2_STATE_EXCHANGING_KEYS	0x00000001
+#define LIBSSH2_STATE_NEWKEYS			0x00000002
+#define LIBSSH2_STATE_AUTHENTICATED		0x00000004
+
+/* 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 {
@@ -303,6 +318,37 @@ struct _LIBSSH2_MAC_METHOD {
 	int (*dtor)(LIBSSH2_SESSION *session, void **abstract);
 };

+#if defined(LIBSSH2_DEBUG_TRANSPORT) || defined(LIBSSH2_DEBUG_KEX) || defined(LIBSSH2_DEBUG_USERAUTH) || defined(LIBSSH2_DEBUG_CONNECTION) || defined(LIBSSH2_DEBUG_SCP) || defined(LIBSSH2_DEBUG_SFTP) || defined(LIBSSH2_DEBUG_ERRORS)
+#define LIBSSH2_DEBUG_ENABLED
+
+/* Internal debugging contexts -- Used with --enable-debug-* */
+#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
+
+void _libssh2_debug(LIBSSH2_SESSION *session, int context, const char *format, ...);
+
+#endif /* LIBSSH2_DEBUG_ENABLED */
+
+#ifdef LIBSSH2_DEBUG_ERRORS
+#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 = 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 /* ! LIBSSH2_DEBUG_ERRORS */
+
 #define libssh2_error(session, errcode, errmsg, should_free)	\
 { \
 	if (session->err_msg && session->err_should_free) { \
@@ -314,6 +360,9 @@ struct _LIBSSH2_MAC_METHOD {
 	session->err_code = errcode; \
 }

+#endif /* LIBSSH2_DEBUG_ENABLED */
+
+
 #define LIBSSH2_SOCKET_UNKNOWN					 1
 #define LIBSSH2_SOCKET_CONNECTED				 0
 #define LIBSSH2_SOCKET_DISCONNECTED				-1
@@ -387,9 +436,15 @@ int libssh2_packet_read(LIBSSH2_SESSION *session, int block);
 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);
 #define libssh2_packet_ask(session, packet_type, data, data_len, poll_socket)	\
 		libssh2_packet_ask_ex((session), (packet_type), (data), (data_len), 0, NULL, 0, (poll_socket))
+int libssh2_packet_askv_ex(LIBSSH2_SESSION *session, 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);
+#define libssh2_packet_askv(session, packet_types, data, data_len, poll_socket)	\
+		libssh2_packet_askv_ex((session), (packet_types), (data), (data_len), 0, NULL, 0, (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);
 #define libssh2_packet_require(session, packet_type, data, data_len)			\
 		libssh2_packet_require_ex((session), (packet_type), (data), (data_len), 0, NULL, 0)
+int libssh2_packet_requirev_ex(LIBSSH2_SESSION *session, unsigned char *packet_types, unsigned char **data, unsigned long *data_len, unsigned long match_ofs, const unsigned char *match_buf, unsigned long match_len);
+#define libssh2_packet_requirev(session, packet_types, data, data_len)			\
+		libssh2_packet_requirev_ex((session), (packet_types), (data), (data_len), 0, NULL, 0)
 int libssh2_packet_write(LIBSSH2_SESSION *session, unsigned char *data, unsigned long data_len);
 int libssh2_kex_exchange(LIBSSH2_SESSION *session, int reexchange);
 unsigned long libssh2_channel_nextid(LIBSSH2_SESSION *session);
--- a/include/libssh2_sftp.h
+++ b/include/libssh2_sftp.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2004, Sara Golemon <sarag@libssh2.org>
+/* Copyright (c) 2004-2005, Sara Golemon <sarag@libssh2.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms,
--- a/src/channel.c
+++ b/src/channel.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2004, Sara Golemon <sarag@libssh2.org>
+/* Copyright (c) 2004-2005, Sara Golemon <sarag@libssh2.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms,
@@ -64,7 +64,9 @@ unsigned long libssh2_channel_nextid(LIBSSH2_SESSION *session)
 	 * Gets picked up by the new one.... Pretty unlikely all told...
 	 */
 	session->next_channel = id + 1;
-
+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "Allocated new channel ID#%lu", id);
+#endif
 	return id;
 }
 /* }}} */
@@ -106,6 +108,7 @@ LIBSSH2_CHANNEL *libssh2_channel_locate(LIBSSH2_SESSION *session, unsigned long
 LIBSSH2_API LIBSSH2_CHANNEL *libssh2_channel_open_ex(LIBSSH2_SESSION *session, char *channel_type, int channel_type_len, int window_size, int packet_size,
 																			   char *message, int message_len)
 {
+	unsigned char reply_codes[3] = { SSH_MSG_CHANNEL_OPEN_CONFIRMATION, SSH_MSG_CHANNEL_OPEN_FAILURE, 0 };
 	LIBSSH2_CHANNEL *channel = NULL;
 	unsigned long local_channel = libssh2_channel_nextid(session);
 	unsigned char *s, *packet = NULL;
@@ -113,8 +116,10 @@ LIBSSH2_API LIBSSH2_CHANNEL *libssh2_channel_open_ex(LIBSSH2_SESSION *session, c
 																	   window_size(4) + packet_size(4) */
 	unsigned char *data = NULL;
 	unsigned long data_len;
-	int polls = 0;

+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "Opening Channel - win %d pack %d", window_size, packet_size);
+#endif
 	channel = LIBSSH2_ALLOC(session, sizeof(LIBSSH2_CHANNEL));
 	if (!channel) {
 		libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate space for channel data", 0);
@@ -161,35 +166,30 @@ LIBSSH2_API LIBSSH2_CHANNEL *libssh2_channel_open_ex(LIBSSH2_SESSION *session, c
 		goto channel_error;
 	}

-	while (session->socket_state != LIBSSH2_SOCKET_DISCONNECTED) {
-		if (libssh2_packet_ask_ex(session, SSH_MSG_CHANNEL_OPEN_CONFIRMATION, &data, &data_len, 1, packet + 5 + channel_type_len, 4, 1) == 0) {
-			/* YAY! You like me! */
-			break;
-		}
-		if (libssh2_packet_ask_ex(session, SSH_MSG_CHANNEL_OPEN_FAILURE, &data, &data_len, 1, packet + 5 + channel_type_len, 4, 0) == 0) {
-			/* But! Dear! I thought we had something! */
-
-			/* TODO: provide reason code and description */
-			libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE, "Channel open failure", 0);
-			goto channel_error;
-		}
-		usleep(LIBSSH2_SOCKET_POLL_UDELAY);
-		if (polls++ > LIBSSH2_SOCKET_POLL_MAXLOOPS) {
-			/* Give up waiting */
-			libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, "Timed out waiting for response", 0);
-			goto channel_error;
-		}
+	if (libssh2_packet_requirev_ex(session, reply_codes, &data, &data_len, 1, packet + 5 + channel_type_len, 4)) {
+		goto channel_error;
 	}

-	channel->remote.id					= libssh2_ntohu32(data + 5);
-	channel->local.window_size			= libssh2_ntohu32(data + 9);
-	channel->local.window_size_initial	= libssh2_ntohu32(data + 9);
-	channel->local.packet_size			= libssh2_ntohu32(data + 13);
+	if (data[0] == SSH_MSG_CHANNEL_OPEN_CONFIRMATION) {
+		channel->remote.id					= libssh2_ntohu32(data + 5);
+		channel->local.window_size			= libssh2_ntohu32(data + 9);
+		channel->local.window_size_initial	= libssh2_ntohu32(data + 9);
+		channel->local.packet_size			= libssh2_ntohu32(data + 13);
+#ifdef LIBSSH2_DEBUG_CONNECTION
+		_libssh2_debug(session, LIBSSH2_DBG_CONN, "Connection Established - ID: %lu/%lu win: %lu/%lu pack: %lu/%lu",
+												channel->local.id, channel->remote.id,
+												channel->local.window_size, channel->remote.window_size,
+												channel->local.packet_size, channel->remote.packet_size);
+#endif
+		LIBSSH2_FREE(session, packet);
+		LIBSSH2_FREE(session, data);

-	LIBSSH2_FREE(session, packet);
-	LIBSSH2_FREE(session, data);
+		return channel;
+	}

-	return channel;
+	if (data[0] == SSH_MSG_CHANNEL_OPEN_FAILURE) {
+		libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE, "Channel open failure", 0);
+	}

 channel_error:

@@ -240,6 +240,10 @@ LIBSSH2_API LIBSSH2_CHANNEL *libssh2_channel_direct_tcpip_ex(LIBSSH2_SESSION *se
 	unsigned long host_len = strlen(host), shost_len = strlen(shost);
 	unsigned long message_len = host_len + shost_len + 16; /* host_len(4) + port(4) + shost_len(4) + sport(4) */

+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "Requesting direct-tcpip session to from %s:%d to %s:%d", shost, sport, host, port);
+#endif
+
 	s = message = LIBSSH2_ALLOC(session, message_len);
 	if (!message) {
 		libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for direct-tcpip connection", 0);
@@ -265,11 +269,16 @@ LIBSSH2_API LIBSSH2_CHANNEL *libssh2_channel_direct_tcpip_ex(LIBSSH2_SESSION *se
 */
 LIBSSH2_API LIBSSH2_LISTENER *libssh2_channel_forward_listen_ex(LIBSSH2_SESSION *session, char *host, int port, int *bound_port, int queue_maxsize)
 {
-	unsigned char *packet, *s;
+	unsigned char *packet, *s, *data, reply_codes[3] = { SSH_MSG_REQUEST_SUCCESS, SSH_MSG_REQUEST_FAILURE, 0 };
+	unsigned long data_len;
 	unsigned long host_len = (host ? strlen(host) : (sizeof("0.0.0.0") - 1));
 	unsigned long packet_len = host_len + (sizeof("tcpip-forward") - 1) + 14;
 					/* packet_type(1) + request_len(4) + want_replay(1) + host_len(4) + port(4) */

+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "Requesting tcpip-forward session for %s:%d", host, port);
+#endif
+
 	s = packet = LIBSSH2_ALLOC(session, packet_len);
 	if (!packet) {
 		libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memeory for setenv packet", 0);
@@ -292,59 +301,61 @@ LIBSSH2_API LIBSSH2_LISTENER *libssh2_channel_forward_listen_ex(LIBSSH2_SESSION
 	}
 	LIBSSH2_FREE(session, packet);

-	while (session->socket_state == LIBSSH2_SOCKET_CONNECTED) {
-		unsigned char *data;
-		unsigned long data_len;
+	if (libssh2_packet_requirev(session, reply_codes, &data, &data_len)) {
+		return NULL;
+	}

-		if (libssh2_packet_ask(session, SSH_MSG_REQUEST_SUCCESS, &data, &data_len, 1) == 0) {
-			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);
-				return NULL;
-			}
-			memset(listener, 0, sizeof(LIBSSH2_LISTENER));
-			listener->session = session;
-			listener->host = LIBSSH2_ALLOC(session, 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);
-				return NULL;
-			}
-			memcpy(listener->host, host ? host : "0.0.0.0", host_len);
-			listener->host[host_len] = 0;
-			if (data_len >= 5 && !port) {
-				listener->port = libssh2_ntohu32(data + 1);
-			} 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;
-			}
+	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);
-			return listener;
-		}
-
-		if (libssh2_packet_ask(session, SSH_MSG_REQUEST_FAILURE, &data, &data_len, 0) == 0) {
-			LIBSSH2_FREE(session, data);
-			libssh2_error(session, LIBSSH2_ERROR_REQUEST_DENIED, "Unable to complete request for forward-listen", 0);
 			return NULL;
 		}
+		memset(listener, 0, sizeof(LIBSSH2_LISTENER));
+		listener->session = session;
+		listener->host = LIBSSH2_ALLOC(session, 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);
+			return NULL;
+		}
+		memcpy(listener->host, host ? host : "0.0.0.0", host_len);
+		listener->host[host_len] = 0;
+		if (data_len >= 5 && !port) {
+			listener->port = libssh2_ntohu32(data + 1);
+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "Dynamic tcpip-forward port allocated: %d", listener->port);
+#endif
+		} 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);
+		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);
+		return NULL;
 	}

 	return NULL;
@@ -364,6 +375,10 @@ LIBSSH2_API int libssh2_channel_forward_cancel(LIBSSH2_LISTENER *listener)
 	unsigned long packet_len = host_len + 14 + sizeof("cancel-tcpip-forward") - 1;
 					/* packet_type(1) + request_len(4) + want_replay(1) + host_len(4) + port(4) */

+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "Cancelling tcpip-forward session for %s:%d", listener->host, listener->port);
+#endif
+
 	s = packet = LIBSSH2_ALLOC(session, packet_len);
 	if (!packet) {
 		libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memeory for setenv packet", 0);
@@ -451,10 +466,15 @@ LIBSSH2_API LIBSSH2_CHANNEL *libssh2_channel_forward_accept(LIBSSH2_LISTENER *li
 LIBSSH2_API int libssh2_channel_setenv_ex(LIBSSH2_CHANNEL *channel, char *varname, int varname_len, char *value, int value_len)
 {
 	LIBSSH2_SESSION *session = channel->session;
-	unsigned char *s, *packet;
+	unsigned char *s, *packet, *data, reply_codes[3] = { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 }, local_channel[4];
+	unsigned long data_len;
 	unsigned long packet_len = varname_len + value_len + 21; /* packet_type(1) + channel_id(4) + request_len(4) + request(3)"env" + 
 																want_reply(1) + varname_len(4) + value_len(4) */

+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "Setting remote environment variable: %s=%s on channel %lu/%lu", varname, value, channel->local.id, channel->remote.id);
+#endif
+
 	s = packet = LIBSSH2_ALLOC(session, packet_len);
 	if (!packet) {
 		libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memeory for setenv packet", 0);
@@ -481,26 +501,18 @@ LIBSSH2_API int libssh2_channel_setenv_ex(LIBSSH2_CHANNEL *channel, char *varnam
 	}
 	LIBSSH2_FREE(session, packet);

-	while (1) {
-		unsigned char *data;
-		unsigned long data_len;
-		unsigned char local_channel[4];
-
-		libssh2_htonu32(local_channel, channel->local.id);
-
-		if (libssh2_packet_ask_ex(session, SSH_MSG_CHANNEL_SUCCESS, &data, &data_len, 1, local_channel, 4, 1) == 0) {
-			LIBSSH2_FREE(session, data);
-			return 0;
-		}
-
-		if (libssh2_packet_ask_ex(session, SSH_MSG_CHANNEL_FAILURE, &data, &data_len, 1, local_channel, 4, 0) == 0) {
-			LIBSSH2_FREE(session, data);
-			libssh2_error(session, LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED, "Unable to complete request for channel-setenv", 0);
-			return -1;
-		}
+	libssh2_htonu32(local_channel, channel->local.id);
+	if (libssh2_packet_requirev_ex(session, reply_codes, &data, &data_len, 1, local_channel, 4)) {
+		return -1;
 	}

-	/* Never reached, just giving the compiler something to not complain about */
+	if (data[0] == SSH_MSG_CHANNEL_SUCCESS) {
+		LIBSSH2_FREE(session, data);
+		return 0;
+	}
+
+	LIBSSH2_FREE(session, data);
+	libssh2_error(session, LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED, "Unable to complete request for channel-setenv", 0);
 	return -1;
 }
 /* }}} */
@@ -514,10 +526,15 @@ LIBSSH2_API int libssh2_channel_request_pty_ex(LIBSSH2_CHANNEL *channel, char *t
 																		 int width_px, int height_px)
 {
 	LIBSSH2_SESSION *session = channel->session;
-	unsigned char *s, *packet;
+	unsigned char *s, *packet, *data, reply_codes[3] = { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 }, local_channel[4];
+	unsigned long data_len;
 	unsigned long packet_len = term_len + modes_len + 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) */

+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "Allocating tty on channel %lu/%lu", channel->local.id, channel->remote.id);
+#endif
+
 	s = packet = LIBSSH2_ALLOC(session, packet_len);
 	if (!packet) {
 		libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for pty-request", 0);
@@ -553,26 +570,18 @@ LIBSSH2_API int libssh2_channel_request_pty_ex(LIBSSH2_CHANNEL *channel, char *t
 	}
 	LIBSSH2_FREE(session, packet);

-	while (1) {
-		unsigned char *data;
-		unsigned long data_len;
-		unsigned char local_channel[4];
-
-		libssh2_htonu32(local_channel, channel->local.id);
-
-		if (libssh2_packet_ask_ex(session, SSH_MSG_CHANNEL_SUCCESS, &data, &data_len, 1, local_channel, 4, 1) == 0) {
-			LIBSSH2_FREE(session, data);
-			return 0;
-		}
-
-		if (libssh2_packet_ask_ex(session, SSH_MSG_CHANNEL_FAILURE, &data, &data_len, 1, local_channel, 4, 1) == 0) {
-			LIBSSH2_FREE(session, data);
-			libssh2_error(session, LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED, "Unable to complete request for channel request-pty", 0);
-			return -1;
-		}
+	libssh2_htonu32(local_channel, channel->local.id);
+	if (libssh2_packet_requirev_ex(session, reply_codes, &data, &data_len, 1, local_channel, 4)) {
+		return -1;
 	}

-	/* Never reached, just giving the compiler something to not complain about */
+	if (data[0] == SSH_MSG_CHANNEL_SUCCESS) {
+		LIBSSH2_FREE(session, data);
+		return 0;
+	}
+
+	LIBSSH2_FREE(session, data);
+	libssh2_error(session, LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED, "Unable to complete request for channel request-pty", 0);
 	return -1;
 }
 /* }}} */
@@ -585,12 +594,20 @@ LIBSSH2_API int libssh2_channel_request_pty_ex(LIBSSH2_CHANNEL *channel, char *t
 LIBSSH2_API int libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL *channel, int single_connection, char *auth_proto, char *auth_cookie, int screen_number)
 {
 	LIBSSH2_SESSION *session = channel->session;
-	unsigned char *s, *packet;
+	unsigned char *s, *packet, *data, reply_codes[3] = { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 }, local_channel[4];
+	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;
 	unsigned long packet_len = proto_len + cookie_len + 41; /*  packet_type(1) + channel(4) + x11_req_len(4) + "x11-req"(7) + want_reply(1) + 
 																single_cnx(4) + proto_len(4) + cookie_len(4) + screen_num(4) */

+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_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);
+#endif
+
 	s = packet = LIBSSH2_ALLOC(session, packet_len);
 	if (!packet) {
 		libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for pty-request", 0);
@@ -632,26 +649,14 @@ LIBSSH2_API int libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL *channel, int single_
 	}
 	LIBSSH2_FREE(session, packet);

-	while (1) {
-		unsigned char *data;
-		unsigned long data_len;
-		unsigned char local_channel[4];
-
-		libssh2_htonu32(local_channel, channel->local.id);
-
-		if (libssh2_packet_ask_ex(session, SSH_MSG_CHANNEL_SUCCESS, &data, &data_len, 1, local_channel, 4, 1) == 0) {
-			LIBSSH2_FREE(session, data);
-			return 0;
-		}
-
-		if (libssh2_packet_ask_ex(session, SSH_MSG_CHANNEL_FAILURE, &data, &data_len, 1, local_channel, 4, 1) == 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_htonu32(local_channel, channel->local.id);
+	if (libssh2_packet_requirev_ex(session, reply_codes, &data, &data_len, 1, local_channel, 4)) {
+		LIBSSH2_FREE(session, data);
+		return 0;
 	}

-	/* Never reached, just giving the compiler something to not complain about */
+	LIBSSH2_FREE(session, data);
+	libssh2_error(session, LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED, "Unable to complete request for channel x11-req", 0);
 	return -1;
 }
 /* }}} */
@@ -662,13 +667,18 @@ LIBSSH2_API int libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL *channel, int single_
 LIBSSH2_API int libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel, char *request, int request_len, char *message, int message_len)
 {
 	LIBSSH2_SESSION *session = channel->session;
-	unsigned char *s, *packet;
+	unsigned char *s, *packet, *data, reply_codes[3] = { SSH_MSG_CHANNEL_SUCCESS, SSH_MSG_CHANNEL_FAILURE, 0 }, local_channel[4];
+	unsigned long data_len;
 	unsigned long packet_len = request_len + 10; /* packet_type(1) + channel(4) + request_len(4) + want_reply(1) */

 	if (message) {
 		packet_len += message_len + 4;
 	}

+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "starting request(%s) on channel %lu/%lu, message=%s", request, channel->local.id, channel->remote.id, message);
+#endif
+
 	s = packet = LIBSSH2_ALLOC(session, packet_len);
 	if (!packet) {
 		libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for channel-process request", 0);
@@ -694,26 +704,18 @@ LIBSSH2_API int libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel, char *
 	}
 	LIBSSH2_FREE(session, packet);

-	while (1) {
-		unsigned char *data;
-		unsigned long data_len;
-		unsigned char local_channel[4];
-
-		libssh2_htonu32(local_channel, channel->local.id);
-
-		if (libssh2_packet_ask_ex(session, SSH_MSG_CHANNEL_SUCCESS, &data, &data_len, 1, local_channel, 4, 1) == 0) {
-			LIBSSH2_FREE(session, data);
-			return 0;
-		}
-
-		if (libssh2_packet_ask_ex(session, SSH_MSG_CHANNEL_FAILURE, &data, &data_len, 1, local_channel, 4, 0) == 0) {
-			LIBSSH2_FREE(session, data);
-			libssh2_error(session, LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED, "Unable to complete request for channel-process-startup", 0);
-			return -1;
-		}
+	libssh2_htonu32(local_channel, channel->local.id);
+	if (libssh2_packet_requirev_ex(session, reply_codes, &data, &data_len, 1, local_channel, 4)) {
+		return -1;
 	}

-	/* Never reached, just giving the compiler something to not complain about */
+	if (data[0] == SSH_MSG_CHANNEL_SUCCESS) {
+		LIBSSH2_FREE(session, data);
+		return 0;
+	}
+
+	LIBSSH2_FREE(session, data);
+	libssh2_error(session, LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED, "Unable to complete request for channel-process-startup", 0);
 	return -1;
 }
 /* }}} */
@@ -723,6 +725,9 @@ LIBSSH2_API int libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel, char *
 */
 LIBSSH2_API void libssh2_channel_set_blocking(LIBSSH2_CHANNEL *channel, int blocking)
 {
+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(channel->session, LIBSSH2_DBG_CONN, "Setting blocking mode on channel %lu/%lu to %d", channel->local.id, channel->remote.id, blocking);
+#endif
 	channel->blocking = blocking;
 }
 /* }}} */
@@ -743,13 +748,19 @@ LIBSSH2_API int libssh2_channel_flush_ex(LIBSSH2_CHANNEL *channel, int streamid)
 		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 */
+			unsigned 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 = libssh2_ntohu32(packet->data + 5)))) ||
+				((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;
+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_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);
+#endif

 				/* It's one of the streams we wanted to flush */
 				refund_bytes += packet->data_len - 13;
-				flush_bytes += packet->data_len - packet->data_head;
+				flush_bytes += bytes_to_flush;

 				LIBSSH2_FREE(channel->session, packet->data);
 				if (packet->prev) {
@@ -768,26 +779,60 @@ LIBSSH2_API int libssh2_channel_flush_ex(LIBSSH2_CHANNEL *channel, int streamid)
 		packet = next;
 	}

-	if (refund_bytes && channel->remote.window_size_initial) {
-		unsigned char adjust[9]; /* packet_type(1) + channel(4) + adjustment(4) */
-
-		/* Adjust the window based on the block we just freed */
-		adjust[0] = SSH_MSG_CHANNEL_WINDOW_ADJUST;
-		libssh2_htonu32(adjust + 1, channel->remote.id);
-		libssh2_htonu32(adjust + 5, refund_bytes);
-
-		if (libssh2_packet_write(channel->session, adjust, 9)) {
-			libssh2_error(channel->session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send transfer-window adjustment packet", 0);
-			return -1;
-		} else {
-			channel->remote.window_size += refund_bytes;
-		}
+	if (refund_bytes) {
+		libssh2_channel_receive_window_adjust(channel, refund_bytes, 0);
 	}

 	return flush_bytes;
 }
 /* }}} */

+/* {{{ 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)
+{
+	unsigned char adjust[9]; /* packet_type(1) + channel(4) + adjustment(4) */
+
+	if (!force && (adjustment + channel->adjust_queue < LIBSSH2_CHANNEL_MINADJUST)) {
+#ifdef LIBSSH2_DEBUG_CONNECTION
+		_libssh2_debug(channel->session, LIBSSH2_DBG_CONN, "Queing %lu bytes for receive window adjustment for channel %lu/%lu", adjustment, channel->local.id, channel->remote.id);
+#endif
+		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 */
+	adjust[0] = SSH_MSG_CHANNEL_WINDOW_ADJUST;
+	libssh2_htonu32(adjust + 1, channel->remote.id);
+	libssh2_htonu32(adjust + 5, adjustment);
+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_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);
+#endif
+
+	if (libssh2_packet_write(channel->session, adjust, 9)) {
+		libssh2_error(channel->session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send transfer-window adjustment packet, deferring", 0);
+		channel->adjust_queue = adjustment;
+	} else {
+		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)
@@ -796,6 +841,9 @@ LIBSSH2_API int libssh2_channel_flush_ex(LIBSSH2_CHANNEL *channel, int streamid)
 */
 LIBSSH2_API void libssh2_channel_handle_extended_data(LIBSSH2_CHANNEL *channel, int ignore_mode)
 {
+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_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);
+#endif
 	channel->remote.extended_data_ignore_mode = ignore_mode;

 	if (ignore_mode == LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE) {
@@ -812,6 +860,9 @@ LIBSSH2_API int libssh2_channel_read_ex(LIBSSH2_CHANNEL *channel, int stream_id,
 	LIBSSH2_SESSION *session = channel->session;
 	int bytes_read = 0, blocking_read = 0;

+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_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);
+#endif
 	do {
 		LIBSSH2_PACKET *packet;

@@ -827,7 +878,7 @@ LIBSSH2_API int libssh2_channel_read_ex(LIBSSH2_CHANNEL *channel, int stream_id,
 			 * or the standard stream (and data was available),
 			 * or the standard stream with extended_data_merge enabled and data was available
 			 */
-			if ((stream_id  && (packet->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA) && (channel->local.id == libssh2_ntohu32(packet->data + 1))) ||
+			if ((stream_id  && (packet->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA) && (channel->local.id == libssh2_ntohu32(packet->data + 1)) && (stream_id == libssh2_ntohu32(packet->data + 5))) ||
 				(!stream_id && (packet->data[0] == SSH_MSG_CHANNEL_DATA) && (channel->local.id == libssh2_ntohu32(packet->data + 1))) ||
 				(!stream_id && (packet->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA) && (channel->local.id == libssh2_ntohu32(packet->data + 1)) && (channel->remote.extended_data_ignore_mode == LIBSSH2_CHANNEL_EXTENDED_DATA_MERGE))) {
 				int want = buflen - bytes_read;
@@ -838,13 +889,14 @@ LIBSSH2_API int libssh2_channel_read_ex(LIBSSH2_CHANNEL *channel, int stream_id,
 					unlink_packet = 1;
 				}

+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "Reading %d of buffered data from %lu/%lu/%d", want, channel->local.id, channel->remote.id, stream_id);
+#endif
 				memcpy(buf + bytes_read, packet->data + packet->data_head, want);
 				packet->data_head += want;
 				bytes_read += want;

 				if (unlink_packet) {
-					unsigned char adjust[9]; /* packet_type(1) + channel(4) + adjustment(4) */
-
 					if (packet->prev) {
 						packet->prev->next = packet->next;
 					} else {
@@ -857,18 +909,11 @@ LIBSSH2_API int libssh2_channel_read_ex(LIBSSH2_CHANNEL *channel, int stream_id,
 					}
 					LIBSSH2_FREE(session, packet->data);

-					if (channel->remote.window_size_initial) {
-						/* Adjust the window based on the block we just freed */
-						adjust[0] = SSH_MSG_CHANNEL_WINDOW_ADJUST;
-						libssh2_htonu32(adjust + 1, channel->remote.id);
-						libssh2_htonu32(adjust + 5, packet->data_len - (stream_id ? 13 : 9));
-
-						if (libssh2_packet_write(session, adjust, 9)) {
-							libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send transfer-window adjustment packet", 0);
-						}
-
-						LIBSSH2_FREE(session, packet);
-					}
+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "Unlinking empty packet buffer from channel %lu/%lu", channel->local.id, channel->remote.id);
+#endif
+					libssh2_channel_receive_window_adjust(channel, packet->data_len - (stream_id ? 13 : 9), 0);
+					LIBSSH2_FREE(session, packet);
 				}
 			}
 			packet = next;
@@ -890,9 +935,12 @@ LIBSSH2_API int libssh2_channel_read_ex(LIBSSH2_CHANNEL *channel, int stream_id,
 LIBSSH2_API int libssh2_channel_write_ex(LIBSSH2_CHANNEL *channel, int stream_id, const char *buf, size_t buflen)
 {
 	LIBSSH2_SESSION *session = channel->session;
-	unsigned char *packet, *s;
-	unsigned long packet_len;
+	unsigned char *packet;
+	unsigned long packet_len, bufwrote = 0;

+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_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);
+#endif
 	if (channel->local.close) {
 		libssh2_error(session, LIBSSH2_ERROR_CHANNEL_CLOSED, "We've already closed this channel", 0);
 		return -1;
@@ -902,48 +950,78 @@ LIBSSH2_API int libssh2_channel_write_ex(LIBSSH2_CHANNEL *channel, int stream_id
 		libssh2_error(session, LIBSSH2_ERROR_CHANNEL_EOF_SENT, "EOF has already been sight, data might be ignored", 0);
 	}

-	if (channel->blocking && channel->local.window_size_initial && (channel->local.window_size <= 0)) {
-		/* twiddle our thumbs until there's window space available */
-		if (libssh2_packet_read(session, 1) < 0) {
-			/* Error occured, disconnect? */
-			return -1;
-		}
+	if (!channel->blocking && (channel->local.window_size <= 0)) {
+		/* Can't write anything */
+		return 0;
 	}

 	packet_len = buflen + (stream_id ? 13 : 9); /* packet_type(1) + channelno(4) [ + streamid(4) ] + buflen(4) */
-	s = packet = LIBSSH2_ALLOC(session, packet_len);
+	packet = LIBSSH2_ALLOC(session, packet_len);
 	if (!packet) {
 		libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocte space for data transmission packet", 0);
 		return -1;
 	}

-	*(s++) = stream_id ? SSH_MSG_CHANNEL_EXTENDED_DATA : SSH_MSG_CHANNEL_DATA;
-	libssh2_htonu32(s, channel->remote.id);					s += 4;
-	if (stream_id) {
-		libssh2_htonu32(s, stream_id);						s += 4;
-	}
+	while (buflen > 0) {
+		size_t bufwrite = buflen;
+		unsigned char *s = packet;

-	/* Don't exceed the remote end's limits */
-	/* REMEMBER local means local as the SOURCE of the data */
-	if (channel->local.window_size_initial && (buflen > channel->local.window_size)) {
-		buflen = channel->local.window_size;
-	}
-	if (buflen > channel->local.packet_size) {
-		buflen = channel->local.packet_size;
-	}
-	libssh2_htonu32(s, buflen);							s += 4;
-	memcpy(s, buf, buflen);								s += buflen;
+		*(s++) = stream_id ? SSH_MSG_CHANNEL_EXTENDED_DATA : SSH_MSG_CHANNEL_DATA;
+		libssh2_htonu32(s, channel->remote.id);					s += 4;
+		if (stream_id) {
+			libssh2_htonu32(s, stream_id);						s += 4;
+		}

-	if (libssh2_packet_write(session, packet, s - packet)) {
-		libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send channel data", 0);
-		return -1;
+		/* 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 */
+			if (libssh2_packet_read(session, 1) < 0) {
+				/* Error occured, disconnect? */
+				return -1;
+			}
+		}
+
+		/* Don't exceed the remote end's limits */
+		/* REMEMBER local means local as the SOURCE of the data */
+		if (bufwrite > channel->local.window_size) {
+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_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);
+#endif
+			bufwrite = channel->local.window_size;
+		}
+		if (bufwrite > channel->local.packet_size) {
+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_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);
+#endif
+			bufwrite = channel->local.packet_size;
+		}
+		libssh2_htonu32(s, bufwrite);							s += 4;
+		memcpy(s, buf, bufwrite);								s += bufwrite;
+
+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "Sending %d bytes on channel %lu/%lu, stream_id=%d", (int)bufwrite, channel->local.id, channel->remote.id, stream_id);
+#endif
+		if (libssh2_packet_write(session, packet, s - packet)) {
+			libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send channel data", 0);
+			LIBSSH2_FREE(session, packet);
+			return -1;
+		}
+		/* Shrink local window size */
+		channel->local.window_size -= bufwrite;
+
+		/* Adjust buf for next iteration */
+		buflen -= bufwrite;
+		buf += bufwrite;
+		bufwrote += bufwrite;
+
+		if (!channel->blocking) {
+			break;
+		}
 	}
-	/* Shrink local window size */
-	channel->local.window_size -= buflen;

 	LIBSSH2_FREE(session, packet);

-	return buflen;
+	return bufwrote;
 }
 /* }}} */

@@ -955,6 +1033,9 @@ LIBSSH2_API int libssh2_channel_send_eof(LIBSSH2_CHANNEL *channel)
 	LIBSSH2_SESSION *session = channel->session;
 	unsigned char packet[5]; /* packet_type(1) + channelno(4) */

+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "Sending EOF on channel %lu/%lu",channel->local.id, channel->remote.id);
+#endif
 	packet[0] = SSH_MSG_CHANNEL_EOF;
 	libssh2_htonu32(packet + 1, channel->remote.id);
 	if (libssh2_packet_write(session, packet, 5)) {
@@ -1001,6 +1082,10 @@ LIBSSH2_API int libssh2_channel_close(LIBSSH2_CHANNEL *channel)
 		return 0;
 	}

+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "Closing channel %lu/%lu", channel->local.id, channel->remote.id);
+#endif
+
 	if (channel->close_cb) {
 		LIBSSH2_CHANNEL_CLOSE(session, channel);
 	}
@@ -1028,6 +1113,9 @@ LIBSSH2_API int libssh2_channel_free(LIBSSH2_CHANNEL *channel)
 	unsigned char channel_id[4], *data;
 	unsigned long data_len;

+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "Freeing channel %lu/%lu resources", channel->local.id, channel->remote.id);
+#endif
 	/* Allow channel freeing even when the socket has lost its connection */
 	if (!channel->local.close && (session->socket_state == LIBSSH2_SOCKET_CONNECTED) &&
 		libssh2_channel_close(channel)) {
@@ -1068,3 +1156,53 @@ LIBSSH2_API int libssh2_channel_free(LIBSSH2_CHANNEL *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;
+}
+/* }}} */
--- a/src/comp.c
+++ b/src/comp.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2004, Sara Golemon <sarag@libssh2.org>
+/* Copyright (c) 2004-2005, Sara Golemon <sarag@libssh2.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms,
@@ -136,12 +136,12 @@ static int libssh2_comp_method_zlib_comp(LIBSSH2_SESSION *session, int compress,
 	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 : (2 * src_len);
+	int out_maxlen = compress ? (src_len + 4) : (2 * src_len);
 	int limiter = 0;

 	/* In practice they never come smaller than this */
-	if (out_maxlen < 21) {
-		out_maxlen = 21;
+	if (out_maxlen < 25) {
+		out_maxlen = 25;
 	}

 	if (out_maxlen > payload_limit) {
@@ -166,17 +166,17 @@ static int libssh2_comp_method_zlib_comp(LIBSSH2_SESSION *session, int compress,
 		}
 		if (status != Z_OK) {
 			libssh2_error(session, LIBSSH2_ERROR_ZLIB, "compress/decompression failure", 0);
-			LIBSSH2_FREE(session, strm->next_out);
+			LIBSSH2_FREE(session, out);
 			return -1;
 		}
 		if (strm->avail_in) {
 			unsigned long out_ofs = out_maxlen - strm->avail_out;

-			out_maxlen += compress ? strm->avail_in : (2 * strm->avail_in);
+			out_maxlen += compress ? (strm->avail_in + 4) : (2 * strm->avail_in);

 			if ((out_maxlen > payload_limit) && !compress && limiter++) {
 				libssh2_error(session, LIBSSH2_ERROR_ZLIB, "Excessive growth in decompression phase", 0);
-				LIBSSH2_FREE(session, strm->next_out);
+				LIBSSH2_FREE(session, out);
 				return -1;
 			}

@@ -186,7 +186,43 @@ static int libssh2_comp_method_zlib_comp(LIBSSH2_SESSION *session, int compress,
 				return -1;
 			}
 			strm->next_out = out + out_ofs;
-			strm->avail_out += compress ? strm->avail_in : (2 * strm->avail_in);
+			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;
+
+			if (out_maxlen >= payload_limit) {
+				libssh2_error(session, LIBSSH2_ERROR_ZLIB, "Excessive growth in decompression phase", 0);
+				LIBSSH2_FREE(session, out);
+				return -1;
+			}
+
+			if (grow_size > (payload_limit - out_maxlen)) {
+				grow_size = payload_limit - out_maxlen;
+			}
+
+			out_maxlen += grow_size;
+			strm->avail_out = grow_size;
+
+			out = LIBSSH2_REALLOC(session, out, out_maxlen);
+			if (!out) {
+				libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to expand final compress/decompress buffer", 0);
+				return -1;
+			}
+			strm->next_out = 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;
+			}
 		}
 	}

@@ -236,10 +272,10 @@ static LIBSSH2_COMP_METHOD libssh2_comp_method_zlib = {
   *********************** */

 static LIBSSH2_COMP_METHOD *_libssh2_comp_methods[] = {
+	&libssh2_comp_method_none,
 #ifdef LIBSSH2_HAVE_ZLIB
 	&libssh2_comp_method_zlib,
 #endif /* LIBSSH2_HAVE_ZLIB */
-	&libssh2_comp_method_none,
 	NULL
 };

--- a/src/crypt.c
+++ b/src/crypt.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2004, Sara Golemon <sarag@libssh2.org>
+/* Copyright (c) 2004-2005, Sara Golemon <sarag@libssh2.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms,
--- a/src/hostkey.c
+++ b/src/hostkey.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2004, Sara Golemon <sarag@libssh2.org>
+/* Copyright (c) 2004-2005, Sara Golemon <sarag@libssh2.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms,
@@ -40,6 +40,11 @@
 #include <openssl/pem.h>
 #include <openssl/evp.h>

+/* Needed for struct iovec on some platforms */
+#ifdef HAVE_SYS_UIO_H
+#include <sys/uio.h>
+#endif
+
 #ifndef OPENSSL_NO_RSA
 /* ***********
   * ssh-rsa *
@@ -124,7 +129,7 @@ static int libssh2_hostkey_method_ssh_rsa_initPEM(LIBSSH2_SESSION *session, unsi
 		 * 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_algorithms_noconf();
+		OpenSSL_add_all_ciphers();
 	}
 	rsactx = PEM_read_RSAPrivateKey(fp, NULL, (void*)libssh2_hostkey_method_ssh_rsadsa_passphrase_cb, passphrase);
 	if (!rsactx) {
@@ -338,7 +343,7 @@ static int libssh2_hostkey_method_ssh_dss_initPEM(LIBSSH2_SESSION *session, unsi
 		 * 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_algorithms_noconf();
+		OpenSSL_add_all_ciphers();
 	}
 	dsactx = PEM_read_DSAPrivateKey(fp, NULL, (void*)libssh2_hostkey_method_ssh_rsadsa_passphrase_cb, passphrase);
 	if (!dsactx) {
@@ -392,11 +397,9 @@ static int libssh2_hostkey_method_ssh_dss_sign(LIBSSH2_SESSION *session, unsigne
 	DSA_SIG *sig;
 	unsigned char hash[SHA_DIGEST_LENGTH];
 	SHA_CTX ctx;
-	int r_len, s_len, rs_pad;

 	*signature = LIBSSH2_ALLOC(session, 2 * SHA_DIGEST_LENGTH);
 	*signature_len = 2 * SHA_DIGEST_LENGTH;
-	memset(*signature, 0, 2 * SHA_DIGEST_LENGTH);

 	if (!(*signature)) {
 		return -1;
@@ -412,17 +415,8 @@ static int libssh2_hostkey_method_ssh_dss_sign(LIBSSH2_SESSION *session, unsigne
 		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);
-		LIBSSH2_FREE(session, *signature);
-		return -1;
-	}
-
-	BN_bn2bin(sig->r, *signature + rs_pad);
-	BN_bn2bin(sig->s, *signature + rs_pad + r_len);
+	BN_bn2bin(sig->r, *signature);
+	BN_bn2bin(sig->s, *signature + SHA_DIGEST_LENGTH);

 	DSA_SIG_free(sig);

--- a/src/kex.c
+++ b/src/kex.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2004, Sara Golemon <sarag@libssh2.org>
+/* Copyright (c) 2004-2005, Sara Golemon <sarag@libssh2.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms,
@@ -109,6 +109,9 @@ static int libssh2_kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_S
 		BN_bn2bin(e, e_packet + 6);
 	}

+#ifdef LIBSSH2_DEBUG_KEX
+	_libssh2_debug(session, LIBSSH2_DBG_KEX, "Sending KEX packet %d", (int)packet_type_init);
+#endif
 	if (libssh2_packet_write(session, e_packet, e_packet_len)) {
 		libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send KEX init message", 0);
 		ret = -11;
@@ -143,7 +146,18 @@ static int libssh2_kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_S
    MD5_Update(&fingerprint_ctx, session->server_hostkey, session->server_hostkey_len);
    MD5_Final(session->server_hostkey_md5, &fingerprint_ctx);
 }
-#endif
+#ifdef LIBSSH2_DEBUG_KEX
+{
+	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 /* LIBSSH2_DEBUG_KEX */
+#endif /* ! OPENSSL_NO_MD5 */

 #ifndef OPENSSL_NO_SHA
 {
@@ -153,7 +167,18 @@ static int libssh2_kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_S
    SHA1_Update(&fingerprint_ctx, session->server_hostkey, session->server_hostkey_len);
    SHA1_Final(session->server_hostkey_sha1, &fingerprint_ctx);
 }
-#endif
+#ifdef LIBSSH2_DEBUG_KEX
+{
+	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 /* LIBSSH2_DEBUG_KEX */
+#endif /* ! OPENSSL_NO_SHA */

 	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);
@@ -161,7 +186,6 @@ static int libssh2_kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_S
 		goto clean_exit;
 	}

-
 	f_value_len = libssh2_ntohu32(s);							s += 4;
 	f_value = s;												s += f_value_len;
 	BN_bin2bn(f_value, f_value_len, f);
@@ -250,6 +274,9 @@ static int libssh2_kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_S
 		goto clean_exit;
 	}

+#ifdef LIBSSH2_DEBUG_KEX
+	_libssh2_debug(session, LIBSSH2_DBG_KEX, "Sending NEWKEYS message");
+#endif
 	c = SSH_MSG_NEWKEYS;
 	if (libssh2_packet_write(session, &c, 1)) {
 		libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send NEWKEYS message", 0);
@@ -263,7 +290,10 @@ static int libssh2_kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_S
 		goto clean_exit;
 	}
 	/* The first key exchange has been performed, switch to active crypt/comp/mac mode */
-	session->newkeys = 1;
+	session->state |= LIBSSH2_STATE_NEWKEYS;
+#ifdef LIBSSH2_DEBUG_KEX
+	_libssh2_debug(session, LIBSSH2_DBG_KEX, "Received NEWKEYS message");
+#endif

 	/* This will actually end up being just packet_type(1) for this packet type anyway */
 	LIBSSH2_FREE(session, tmp);
@@ -276,6 +306,9 @@ static int libssh2_kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_S
 		}
 		memcpy(session->session_id, h_sig_comp, SHA_DIGEST_LENGTH);
 		session->session_id_len = SHA_DIGEST_LENGTH;
+#ifdef LIBSSH2_DEBUG_KEX
+	_libssh2_debug(session, LIBSSH2_DBG_KEX, "session_id calculated");
+#endif
 	}

 	/* Calculate IV/Secret/Key for each direction */
@@ -327,6 +360,9 @@ static int libssh2_kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_S
 			LIBSSH2_FREE(session, secret);
 		}
 	}
+#ifdef LIBSSH2_DEBUG_KEX
+	_libssh2_debug(session, LIBSSH2_DBG_KEX, "Client to Server IV and Key calculated");
+#endif

 	if (session->remote.crypt->flags & LIBSSH2_CRYPT_METHOD_FLAG_EVP) {
 		if (session->remote.crypt_abstract) {
@@ -376,6 +412,9 @@ static int libssh2_kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_S
 			LIBSSH2_FREE(session, secret);
 		}
 	}
+#ifdef LIBSSH2_DEBUG_KEX
+	_libssh2_debug(session, LIBSSH2_DBG_KEX, "Server to Client IV and Key calculated");
+#endif

 	if (session->local.mac->dtor) {
 		session->local.mac->dtor(session, &session->local.mac_abstract);
@@ -393,6 +432,9 @@ static int libssh2_kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_S
 			LIBSSH2_FREE(session, key);
 		}
 	}
+#ifdef LIBSSH2_DEBUG_KEX
+	_libssh2_debug(session, LIBSSH2_DBG_KEX, "Client to Server HMAC Key calculated");
+#endif

 	if (session->remote.mac->dtor) {
 		session->remote.mac->dtor(session, &session->remote.mac_abstract);
@@ -410,6 +452,9 @@ static int libssh2_kex_method_diffie_hellman_groupGP_sha1_key_exchange(LIBSSH2_S
 			LIBSSH2_FREE(session, key);
 		}
 	}
+#ifdef LIBSSH2_DEBUG_KEX
+	_libssh2_debug(session, LIBSSH2_DBG_KEX, "Server to Client HMAC Key calculated");
+#endif

 clean_exit:
 	BN_clear_free(x);
@@ -470,6 +515,9 @@ static int libssh2_kex_method_diffie_hellman_group1_sha1_key_exchange(LIBSSH2_SE
 	BN_set_word(g, 2);
 	BN_bin2bn(p_value, 128, p);

+#ifdef LIBSSH2_DEBUG_KEX
+	_libssh2_debug(session, LIBSSH2_DBG_KEX, "Initiating Diffie-Hellman Group1 Key Exchange");
+#endif
 	ret = libssh2_kex_method_diffie_hellman_groupGP_sha1_key_exchange(session, g, p, SSH_MSG_KEXDH_INIT, SSH_MSG_KEXDH_REPLY, NULL, 0);

 	BN_clear_free(p);
@@ -526,6 +574,9 @@ static int libssh2_kex_method_diffie_hellman_group14_sha1_key_exchange(LIBSSH2_S
 	BN_set_word(g, 2);
 	BN_bin2bn(p_value, 256, p);

+#ifdef LIBSSH2_DEBUG_KEX
+	_libssh2_debug(session, LIBSSH2_DBG_KEX, "Initiating Diffie-Hellman Group14 Key Exchange");
+#endif
 	ret = libssh2_kex_method_diffie_hellman_groupGP_sha1_key_exchange(session, g, p, SSH_MSG_KEXDH_INIT, SSH_MSG_KEXDH_REPLY, NULL, 0);

 	BN_clear_free(p);
@@ -554,10 +605,16 @@ static int libssh2_kex_method_diffie_hellman_group_exchange_sha1_key_exchange(LI
 	libssh2_htonu32(request + 5, LIBSSH2_DH_GEX_OPTGROUP);
 	libssh2_htonu32(request	+ 9, LIBSSH2_DH_GEX_MAXGROUP);
 	request_len = 13;
+#ifdef LIBSSH2_DEBUG_KEX
+	_libssh2_debug(session, LIBSSH2_DBG_KEX, "Initiating Diffie-Hellman Group-Exchange (New Method)");
+#endif
 #else
 	request[0] = SSH_MSG_KEX_DH_GEX_REQUEST_OLD;
 	libssh2_htonu32(request + 1, LIBSSH2_DH_GEX_OPTGROUP);
 	request_len = 5;
+#ifdef LIBSSH2_DEBUG_KEX
+	_libssh2_debug(session, LIBSSH2_DBG_KEX, "Initiating Diffie-Hellman Group-Exchange (Old Method)");
+#endif
 #endif

 	if (libssh2_packet_write(session, request, request_len)) {
@@ -746,6 +803,23 @@ static int libssh2_kexinit(LIBSSH2_SESSION *session)
 	*(s++) = 0;
 	*(s++) = 0;

+#ifdef LIBSSH2_DEBUG_KEX
+{
+	/* Funnily enough, they'll all "appear" to be '\0' terminated */
+	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 /* LIBSSH2_DEBUG_KEX */
 	if (libssh2_packet_write(session, data, data_len)) {
 		LIBSSH2_FREE(session, data);
 		libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send KEXINIT packet to remote host", 0);
@@ -854,7 +928,7 @@ static int libssh2_kex_agree_hostkey(LIBSSH2_SESSION *session, unsigned long kex
 		return -1;
 	}

-	while ((*hostkeyp)->name) {
+	while (hostkeyp && (*hostkeyp)->name) {
 		s = libssh2_kex_agree_instr(hostkey, hostkey_len, (*hostkeyp)->name, strlen((*hostkeyp)->name));
 		if (s) {
 			/* So far so good, but does it suit our purposes? (Encrypting vs Signing) */
@@ -962,7 +1036,7 @@ static int libssh2_kex_agree_crypt(LIBSSH2_SESSION *session, libssh2_endpoint_da
 		return -1;
 	}

-	while ((*cryptp)->name) {
+	while (*cryptp && (*cryptp)->name) {
 		s = libssh2_kex_agree_instr(crypt, crypt_len, (*cryptp)->name, strlen((*cryptp)->name));
 		if (s) {
 			endpoint->crypt = *cryptp;
@@ -1007,7 +1081,7 @@ static int libssh2_kex_agree_mac(LIBSSH2_SESSION *session, libssh2_endpoint_data
 		return -1;
 	}

-	while ((*macp)->name) {
+	while (*macp && (*macp)->name) {
 		s = libssh2_kex_agree_instr(mac, mac_len, (*macp)->name, strlen((*macp)->name));
 		if (s) {
 			endpoint->mac = *macp;
@@ -1052,7 +1126,7 @@ static int libssh2_kex_agree_comp(LIBSSH2_SESSION *session, libssh2_endpoint_dat
 		return -1;
 	}

-	while ((*compp)->name) {
+	while (*compp && (*compp)->name) {
 		s = libssh2_kex_agree_instr(comp, comp_len, (*compp)->name, strlen((*compp)->name));
 		if (s) {
 			endpoint->comp = *compp;
@@ -1120,6 +1194,19 @@ static int libssh2_kex_agree_methods(LIBSSH2_SESSION *session, unsigned char *da
 		return -1;
 	}

+#ifdef LIBSSH2_DEBUG_KEX
+	_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 */
+#endif
+
 	/* Initialize compression layer */
 	if (session->local.comp && session->local.comp->init &&
 		session->local.comp->init(session, 1, &session->local.comp_abstract)) {
@@ -1145,7 +1232,7 @@ int libssh2_kex_exchange(LIBSSH2_SESSION *session, int reexchange) /* session->f
 	unsigned long data_len;

 	/* Prevent loop in packet_add() */
-	session->exchanging_keys = 1;
+	session->state |= LIBSSH2_STATE_EXCHANGING_KEYS;

 	if (reexchange) {
 		session->kex = NULL;
@@ -1191,7 +1278,7 @@ int libssh2_kex_exchange(LIBSSH2_SESSION *session, int reexchange) /* session->f
 		session->remote.kexinit = NULL;
 	}

-	session->exchanging_keys = 0;
+	session->state &= ~LIBSSH2_STATE_EXCHANGING_KEYS;

 	return 0;
 }
--- a/src/mac.c
+++ b/src/mac.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2004, Sara Golemon <sarag@libssh2.org>
+/* Copyright (c) 2004-2005, Sara Golemon <sarag@libssh2.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms,
--- a/src/misc.c
+++ b/src/misc.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2004, Sara Golemon <sarag@libssh2.org>
+/* Copyright (c) 2004-2005, Sara Golemon <sarag@libssh2.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms,
@@ -49,7 +49,7 @@ unsigned long libssh2_ntohu32(const unsigned char *buf)
 * Note: Some 32-bit platforms have issues with bitops on long longs
 * Work around this by doing expensive (but safer) arithmetic ops with optimization defying parentheses
 */
-unsigned long long libssh2_ntohu64(const unsigned char *buf)
+libssh2_uint64_t libssh2_ntohu64(const unsigned char *buf)
 {
 	unsigned long msl, lsl;

@@ -73,7 +73,7 @@ void libssh2_htonu32(unsigned char *buf, unsigned long value)

 /* {{{ libssh2_htonu64
 */
-void libssh2_htonu64(unsigned char *buf, unsigned long long value)
+void libssh2_htonu64(unsigned char *buf, libssh2_uint64_t value)
 {
 	unsigned long msl = (value / 65536) / 65536;

@@ -169,3 +169,29 @@ LIBSSH2_API int libssh2_base64_decode(LIBSSH2_SESSION *session, char **data, int
 }
 /* }}} */

+#ifdef LIBSSH2_DEBUG_ENABLED
+/* {{{ _libssh2_debug
+ * Internal debug logging facility
+ * Just writes to stderr until a good reason comes up to support anything else
+ */
+void _libssh2_debug(LIBSSH2_SESSION *session, int context, const char *format, ...)
+{
+	char buffer[1536];
+	int len;
+	va_list vargs;
+	char *contexts[8] = { "Unknown", "Transport", "Key Exhange", "Userauth", "Connection", "scp", "SFTP", "Failure Event" };
+
+	if (context < 1 || context > 6) {
+		context = 0;
+	}
+
+	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);
+}
+/* }}} */
+#endif
--- a/src/packet.c
+++ b/src/packet.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2004, Sara Golemon <sarag@libssh2.org>
+/* Copyright (c) 2004-2005, Sara Golemon <sarag@libssh2.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms,
@@ -44,6 +44,23 @@
 #include <openssl/evp.h>
 #include <openssl/rand.h>

+/* Needed for struct iovec on some platforms */
+#ifdef HAVE_SYS_UIO_H
+#include <sys/uio.h>
+#endif
+
+#ifdef HAVE_POLL
+# include <sys/poll.h>
+#else
+# ifdef HAVE_SELECT
+#  ifdef HAVE_SYS_SELECT_H
+#   include <sys/select.h>
+#  else
+#   include <sys/time.h>
+#   include <sys/types.h>
+#  endif
+# endif
+#endif

 /* {{{ libssh2_packet_queue_listener
 * Queue a connection request for a listener
@@ -74,6 +91,9 @@ inline int libssh2_packet_queue_listener(LIBSSH2_SESSION *session, unsigned char
 	shost = s;									s += shost_len;
 	sport = libssh2_ntohu32(s);					s += 4;

+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "Remote received connection from %s:%ld to %s:%ld", shost, sport, host, port);
+#endif
 	while (l) {
 		if ((l->port == port) &&
 			(strlen(l->host) == host_len) &&
@@ -85,6 +105,9 @@ inline int libssh2_packet_queue_listener(LIBSSH2_SESSION *session, unsigned char
 				(l->queue_maxsize <= l->queue_size)) {
 				/* Queue is full */
 				failure_code = 4; /* SSH_OPEN_RESOURCE_SHORTAGE */
+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "Listener queue full, ignoring");
+#endif
 				break;
 			}

@@ -117,6 +140,13 @@ inline int libssh2_packet_queue_listener(LIBSSH2_SESSION *session, unsigned char
 			channel->local.window_size = initial_window_size;
 			channel->local.packet_size = packet_size;

+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_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);
+#endif
+
 			p = packet;
 			*(p++) = SSH_MSG_CHANNEL_OPEN_CONFIRMATION;
 			libssh2_htonu32(p, channel->remote.id);						p += 4;
@@ -191,6 +221,9 @@ inline int libssh2_packet_x11_open(LIBSSH2_SESSION *session, unsigned char *data
 	shost = s;										s += shost_len;
 	sport = libssh2_ntohu32(s);						s += 4;

+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "X11 Connection Received from %s:%ld on channel %lu", shost, sport, sender_channel);
+#endif
 	if (session->x11) {
 		channel = LIBSSH2_ALLOC(session, sizeof(LIBSSH2_CHANNEL));
 		if (!channel) {
@@ -221,6 +254,12 @@ inline int libssh2_packet_x11_open(LIBSSH2_SESSION *session, unsigned char *data
 		channel->local.window_size = initial_window_size;
 		channel->local.packet_size = packet_size;

+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_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);
+#endif
 		p = packet;
 		*(p++) = SSH_MSG_CHANNEL_OPEN_CONFIRMATION;
 		libssh2_htonu32(p, channel->remote.id);						p += 4;
@@ -277,6 +316,9 @@ static int libssh2_packet_add(LIBSSH2_SESSION *session, unsigned char *data, siz
 	LIBSSH2_PACKET *packet;
 	unsigned long data_head = 0;

+#ifdef LIBSSH2_DEBUG_TRANSPORT
+	_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Packet type %d received, length=%d", (int)data[0], (int)datalen);
+#endif
 	if (macstate == LIBSSH2_MAC_INVALID) {
 		if (session->macerror) {
 			if (LIBSSH2_MACERROR(session, data, datalen) == 0) {
@@ -325,6 +367,9 @@ static int libssh2_packet_add(LIBSSH2_SESSION *session, unsigned char *data, siz
 			if (session->ssh_msg_disconnect) {
 				LIBSSH2_DISCONNECT(session, reason, message, message_len, language, language_len);
 			}
+#ifdef LIBSSH2_DEBUG_TRANSPORT
+	_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Disconnect(%d): %s(%s)", reason, message, language);
+#endif
 			LIBSSH2_FREE(session, data);
 			session->socket_state = LIBSSH2_SOCKET_DISCONNECTED;
 			return -1;
@@ -365,6 +410,10 @@ static int libssh2_packet_add(LIBSSH2_SESSION *session, unsigned char *data, siz
 			if (session->ssh_msg_debug) {
 				LIBSSH2_DEBUG(session, always_display, message, message_len, language, language_len);
 			}
+#ifdef LIBSSH2_DEBUG_TRANSPORT
+	/* _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);
+#endif
 			LIBSSH2_FREE(session, data);
 			return 0;
 		}
@@ -381,22 +430,27 @@ static int libssh2_packet_add(LIBSSH2_SESSION *session, unsigned char *data, siz
 					LIBSSH2_FREE(session, data);
 					return 0;
 				}
+#ifdef LIBSSH2_DEBUG_CONNECTION
+{
+	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 - data_head), channel->local.id, channel->remote.id, stream_id);
+}
+#endif
 				if ((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);

-					if (channel->remote.window_size_initial) {
-						/* Adjust the window based on the block we just freed */
-						unsigned char adjust[9];
+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "Ignoring extended data and refunding %d bytes", (int)(datalen - 13));
+#endif
+					/* Adjust the window based on the block we just freed */
+					libssh2_channel_receive_window_adjust(channel, datalen - 13, 0);

-						adjust[0] = SSH_MSG_CHANNEL_WINDOW_ADJUST;
-						libssh2_htonu32(adjust + 1, channel->remote.id);
-						libssh2_htonu32(adjust + 5, datalen - 13);
-
-						if (libssh2_packet_write(channel->session, adjust, 9)) {
-							libssh2_error(channel->session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send transfer-window adjustment packet", 0);
-						}
-					}
 					return 0;
 				}

@@ -406,7 +460,7 @@ static int libssh2_packet_add(LIBSSH2_SESSION *session, unsigned char *data, siz
 					libssh2_error(session, LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED, "Packet contains more data than we offered to receive, truncating", 0);
 					datalen = channel->remote.packet_size + data_head;
 				}
-				if (channel->remote.window_size_initial && (channel->remote.window_size <= 0)) {
+				if (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);
@@ -415,7 +469,7 @@ static int libssh2_packet_add(LIBSSH2_SESSION *session, unsigned char *data, siz
 				/* Reset EOF status */
 				channel->remote.eof = 0;

-				if (channel->remote.window_size_initial && ((datalen - data_head) > channel->remote.window_size)) {
+				if ((datalen - data_head) > channel->remote.window_size) {
 					libssh2_error(session, LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED, "Remote sent more data than current window allows, truncating", 0);
 					datalen = channel->remote.window_size + data_head;
 				} else {
@@ -434,6 +488,9 @@ static int libssh2_packet_add(LIBSSH2_SESSION *session, unsigned char *data, siz
 					return 0;
 				}

+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "EOF received for channel %lu/%lu", channel->local.id, channel->remote.id);
+#endif
 				channel->remote.eof = 1;

 				LIBSSH2_FREE(session, data);
@@ -449,6 +506,9 @@ static int libssh2_packet_add(LIBSSH2_SESSION *session, unsigned char *data, siz
 					LIBSSH2_FREE(session, data);
 					return 0;
 				}
+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "Close received for channel %lu/%lu", channel->local.id, channel->remote.id);
+#endif

 				channel->remote.close = 1;
 				/* TODO: Add a callback for this */
@@ -475,6 +535,22 @@ static int libssh2_packet_add(LIBSSH2_SESSION *session, unsigned char *data, siz
 				return retval;
 			}
 			break;
+		case SSH_MSG_CHANNEL_WINDOW_ADJUST:
+			{
+				LIBSSH2_CHANNEL *channel = libssh2_channel_locate(session, libssh2_ntohu32(data + 1));
+				unsigned long bytestoadd = libssh2_ntohu32(data + 5);
+
+				if (channel && bytestoadd) {
+					channel->local.window_size += bytestoadd;
+				}
+#ifdef LIBSSH2_DEBUG_CONNECTION
+	_libssh2_debug(session, LIBSSH2_DBG_CONN, "Window adjust received for channel %lu/%lu, adding %lu bytes, new window_size=%lu", channel->local.id, channel->remote.id, bytestoadd, channel->local.window_size);
+#endif
+
+				LIBSSH2_FREE(session, data);
+				return 0;
+			}
+			break;
 	}

 	packet = LIBSSH2_ALLOC(session, sizeof(LIBSSH2_PACKET));
@@ -497,11 +573,14 @@ static int libssh2_packet_add(LIBSSH2_SESSION *session, unsigned char *data, siz
 		packet->prev = NULL;
 	}

-	if (data[0] == SSH_MSG_KEXINIT && !session->exchanging_keys) {
+	if (data[0] == SSH_MSG_KEXINIT && !(session->state & LIBSSH2_STATE_EXCHANGING_KEYS)) {
 		/* Remote wants new keys
 		 * Well, it's already in the brigade,
 		 * let's just call back into ourselves
 		 */
+#ifdef LIBSSH2_DEBUG_TRANSPORT
+	_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Renegotiating Keys");
+#endif
 		libssh2_kex_exchange(session, 1);
 		/* 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 */
 	}
@@ -516,27 +595,66 @@ static int libssh2_packet_add(LIBSSH2_SESSION *session, unsigned char *data, siz
 static int libssh2_blocking_read(LIBSSH2_SESSION *session, unsigned char *buf, size_t count)
 {
 	size_t bytes_read = 0;
+#if !defined(HAVE_POLL) && !defined(HAVE_SELECT)
 	int polls = 0;
+#endif
+
+#ifndef WIN32
+	fcntl(session->socket_fd, F_SETFL, 0);
+#else
+	{
+		u_long block = FALSE;
+		ioctlsocket(session->socket_fd, FIONBIO, &block);
+	}
+#endif
+
+#ifdef LIBSSH2_DEBUG_TRANSPORT
+	_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Blocking read: %d bytes", (int)count);
+#endif

 	while (bytes_read < count) {
 		int ret;

-		ret = recv(session->socket_fd, buf + bytes_read, count - bytes_read, 0);
+		ret = recv(session->socket_fd, buf + bytes_read, count - bytes_read, LIBSSH2_SOCKET_RECV_FLAGS(session));
 		if (ret < 0) {
 #ifdef WIN32
 			switch (WSAGetLastError()) {
-				case WSAEWOULDBLOCK:	errno = EAGAIN;
+				case WSAEWOULDBLOCK:	errno = EAGAIN;		break;
 				case WSAENOTCONN:
 				case WSAENOTSOCK:
-				case WSAECONNABORTED:	errno = EBADF;
-				case WSAEINTR:			errno = EINTR;
+				case WSAECONNABORTED:	errno = EBADF;		break;
+				case WSAEINTR:			errno = EINTR;		break;
 			}
 #endif
 			if (errno == EAGAIN) {
+#ifdef HAVE_POLL
+				struct pollfd read_socket;
+
+				read_socket.fd = session->socket_fd;
+				read_socket.events = POLLIN;
+
+				if (poll(&read_socket, 1, 30000) <= 0) {
+					return -1;
+				}
+#elif defined(HAVE_SELECT)
+				fd_set read_socket;
+				struct timeval timeout;
+
+				FD_ZERO(&read_socket);
+				FD_SET(session->socket_fd, &read_socket);
+
+				timeout.tv_sec = 30;
+				timeout.tv_usec = 0;
+
+				if (select(session->socket_fd + 1, &read_socket, NULL, NULL, &timeout) <= 0) {
+					return -1;
+				}
+#else
 				if (polls++ > LIBSSH2_SOCKET_POLL_MAXLOOPS) {
 					return -1;
 				}
 				usleep(LIBSSH2_SOCKET_POLL_UDELAY);
+#endif /* POLL/SELECT/SLEEP */
 				continue;
 			}
 			if (errno == EINTR) {
@@ -552,6 +670,10 @@ static int libssh2_blocking_read(LIBSSH2_SESSION *session, unsigned char *buf, s
 		bytes_read += ret;
 	}

+#ifdef LIBSSH2_DEBUG_TRANSPORT
+	_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Blocking read: %d bytes actually read", (int)bytes_read);
+#endif
+
 	return bytes_read;
 }
 /* }}} */
@@ -578,7 +700,11 @@ int libssh2_packet_read(LIBSSH2_SESSION *session, int should_block)
 		ioctlsocket(session->socket_fd, FIONBIO, &non_block);
 	}
 #endif
-	if (session->newkeys) {
+
+#ifdef LIBSSH2_DEBUG_TRANSPORT
+	_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Checking for packet: will%s block", should_block ? "" : " not");
+#endif
+	if (session->state & LIBSSH2_STATE_NEWKEYS) {
 		/* Temporary Buffer
 		 * The largest blocksize (currently) is 32, the largest MAC (currently) is 20
 		 */
@@ -598,7 +724,7 @@ int libssh2_packet_read(LIBSSH2_SESSION *session, int should_block)
 		if (should_block) {
 			read_len = libssh2_blocking_read(session, block, blocksize);
 		} else {
-			read_len = recv(session->socket_fd, block, 1, 0);
+			read_len = recv(session->socket_fd, block, 1, LIBSSH2_SOCKET_RECV_FLAGS(session));
 			if (read_len <= 0) {
 				return 0;
 			}
@@ -620,6 +746,9 @@ int libssh2_packet_read(LIBSSH2_SESSION *session, int should_block)

 		packet_len = libssh2_ntohu32(block);
 		padding_len = block[4];
+#ifdef LIBSSH2_DEBUG_TRANSPORT
+	_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Processing packet %lu bytes long (with %lu bytes padding)", packet_len, padding_len);
+#endif
 		memcpy(tmp, block, 5); /* Use this for MAC later */

 		payload_len = packet_len - 1; /* padding_len(1) */
@@ -683,6 +812,9 @@ int libssh2_packet_read(LIBSSH2_SESSION *session, int should_block)
 				LIBSSH2_FREE(session, payload);
 				return -1;
 			}
+#ifdef LIBSSH2_DEBUG_TRANSPORT
+	_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Payload decompressed: %lu bytes(compressed) to %lu bytes(uncompressed)", data_len, payload_len);
+#endif
 			if (free_payload) {
 				LIBSSH2_FREE(session, payload);
 				payload = data;
@@ -723,7 +855,7 @@ int libssh2_packet_read(LIBSSH2_SESSION *session, int should_block)
 		if (should_block) {
 			buf_len = libssh2_blocking_read(session, buf, 5);
 		} else {
-			buf_len = recv(session->socket_fd, buf, 1, 0);
+			buf_len = recv(session->socket_fd, buf, 1, LIBSSH2_SOCKET_RECV_FLAGS(session));
 			if (buf_len <= 0) {
 				return 0;
 			}
@@ -735,6 +867,9 @@ int libssh2_packet_read(LIBSSH2_SESSION *session, int should_block)
 		}
 		packet_length = libssh2_ntohu32(buf);
 		padding_length = buf[4];
+#ifdef LIBSSH2_DEBUG_TRANSPORT
+	_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Processing plaintext packet %lu bytes long (with %lu bytes padding)", packet_length, padding_length);
+#endif

 		payload_len = packet_length - padding_length - 1; /* padding_length(1) */
 		payload = LIBSSH2_ALLOC(session, payload_len);
@@ -775,6 +910,9 @@ int libssh2_packet_ask_ex(LIBSSH2_SESSION *session, unsigned char packet_type, u
 			return -1;
 		}
 	}
+#ifdef LIBSSH2_DEBUG_TRANSPORT
+	_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Looking for packet of type: %d", (int)packet_type);
+#endif
 	while (packet) {
 		if (packet->data[0] == packet_type &&
 			(packet->data_len >= (match_ofs + match_len)) &&
@@ -804,9 +942,27 @@ int libssh2_packet_ask_ex(LIBSSH2_SESSION *session, unsigned char packet_type, u
 }
 /* }}} */

+/* {{{ 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, 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(packet_types);
+
+	for(i = 0; i < packet_types_len; i++) {
+		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;
+}
+/* }}} */
+
 /* {{{ libssh2_packet_require
 * Loops libssh2_packet_read() until the packet requested is available
- * SSH_DISCONNECT will cause a bailout though
+ * SSH_DISCONNECT or a SOCKET_DISCONNECTED will cause a bailout
 */
 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)
@@ -816,6 +972,9 @@ int libssh2_packet_require_ex(LIBSSH2_SESSION *session, unsigned char packet_typ
 		return 0;
 	}

+#ifdef LIBSSH2_DEBUG_TRANSPORT
+	_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Blocking until packet of type %d becomes available", (int)packet_type);
+#endif
 	while (session->socket_state == LIBSSH2_SOCKET_CONNECTED) {
 		int ret = libssh2_packet_read(session, 1);
 		if (ret < 0) {
@@ -834,6 +993,39 @@ int libssh2_packet_require_ex(LIBSSH2_SESSION *session, unsigned char packet_typ
 }
 /* }}} */

+/* {{{ 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, unsigned char *packet_types, unsigned char **data, unsigned long *data_len,
+														 unsigned long match_ofs, const unsigned char *match_buf, unsigned long match_len)
+{
+	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 */
+		return 0;
+	}
+
+	while (session->socket_state != LIBSSH2_SOCKET_DISCONNECTED) {
+		int ret = libssh2_packet_read(session, 1);
+		if (ret < 0) {
+			return -1;
+		}
+		if (ret == 0) {
+			continue;
+		}
+
+		if (strchr(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 */
+	return -1;
+}
+/* }}} */
+
 /* {{{ libssh2_packet_write
 * Send a packet, encrypting it and adding a MAC code if necessary
 * Returns 0 on success, non-zero on failure
@@ -841,19 +1033,31 @@ int libssh2_packet_require_ex(LIBSSH2_SESSION *session, unsigned char packet_typ
 int libssh2_packet_write(LIBSSH2_SESSION *session, unsigned char *data, unsigned long data_len)
 {
 	unsigned long packet_length = data_len + 1;
-	unsigned long block_size = (session->newkeys) ? session->local.crypt->blocksize : 8;
+	unsigned long block_size = (session->state & LIBSSH2_STATE_NEWKEYS) ? session->local.crypt->blocksize : 8;
 	/* At this point packet_length doesn't include the packet_len field itself */
 	unsigned long padding_length;
 	int free_data = 0;
 	unsigned char buf[246]; /* 6 byte header plus max padding size(240) */
-	int i;

-	if (session->newkeys &&
+#ifdef LIBSSH2_DEBUG_TRANSPORT
+{
+	/* Show a hint of what's being sent */
+	char excerpt[32];
+	int ex_len = 0, db_ofs = 0;
+
+	for (; ex_len < 24 && db_ofs < data_len; ex_len += 3, db_ofs++) snprintf(excerpt + ex_len, 4, "%02X ", data[db_ofs]);
+	_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Sending packet type %d, length=%lu, %s", (int)data[0], data_len, excerpt);
+}
+#endif
+	if ((session->state & LIBSSH2_STATE_NEWKEYS) &&
 		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 -1;
 		}
+#ifdef LIBSSH2_DEBUG_TRANSPORT
+		_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Compressed payload to %lu bytes", data_len);
+#endif
 	}

 #ifndef WIN32
@@ -875,13 +1079,11 @@ int libssh2_packet_write(LIBSSH2_SESSION *session, unsigned char *data, unsigned
 	packet_length += padding_length;
 	libssh2_htonu32(buf, packet_length);
 	buf[4] = padding_length;
+#ifdef LIBSSH2_DEBUG_TRANSPORT
+	_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Sending packet with total length %lu (%lu bytes padding)", packet_length, padding_length);
+#endif

-	for (i = 0; i < padding_length; i++) {
-		/* Make random */
-		buf[5 + i] = '\0';
-	}
-
-	if (session->newkeys) {
+	if (session->state & LIBSSH2_STATE_NEWKEYS) {
 		/* Encryption is in effect */
 		unsigned char *encbuf, *s;
 		int ret;
@@ -923,7 +1125,7 @@ int libssh2_packet_write(LIBSSH2_SESSION *session, unsigned char *data, unsigned
 		session->local.seqno++;

 		/* Send It */
-		ret = ((4 + packet_length + session->local.mac->mac_len) == send(session->socket_fd, encbuf, 4 + packet_length + session->local.mac->mac_len, 0)) ? 0 : -1;
+		ret = ((4 + packet_length + session->local.mac->mac_len) == send(session->socket_fd, encbuf, 4 + packet_length + session->local.mac->mac_len, LIBSSH2_SOCKET_SEND_FLAGS(session))) ? 0 : -1;

 		/* Cleanup environment */
 		LIBSSH2_FREE(session, encbuf);
--- a/src/scp.c
+++ b/src/scp.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2004, Sara Golemon <sarag@libssh2.org>
+/* Copyright (c) 2004-2005, Sara Golemon <sarag@libssh2.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms,
@@ -37,7 +37,6 @@

 #include "libssh2_priv.h"
 #include <errno.h>
-#include <stdio.h>
 #include <stdlib.h>

 #define LIBSSH2_SCP_RESPONSE_BUFLEN		256
@@ -71,6 +70,9 @@ LIBSSH2_API LIBSSH2_CHANNEL *libssh2_scp_recv(LIBSSH2_SESSION *session, char *pa
 	}
 	command[command_len - 1] = '\0';

+#ifdef LIBSSH2_DEBUG_SCP
+	_libssh2_debug(session, LIBSSH2_DBG_SCP, "Opening channel for SCP receive");
+#endif
 	/* Allocate a channel */
 	if ((channel = libssh2_channel_open_session(session)) == NULL) {
 		LIBSSH2_FREE(session, command);
@@ -87,6 +89,9 @@ LIBSSH2_API LIBSSH2_CHANNEL *libssh2_scp_recv(LIBSSH2_SESSION *session, char *pa
 	}
 	LIBSSH2_FREE(session, command);

+#ifdef LIBSSH2_DEBUG_SCP
+	_libssh2_debug(session, LIBSSH2_DBG_SCP, "Sending initial wakeup");
+#endif
 	/* SCP ACK */
 	response[0] = '\0';
 	if (libssh2_channel_write(channel, response, 1) != 1) {
@@ -198,6 +203,9 @@ LIBSSH2_API LIBSSH2_CHANNEL *libssh2_scp_recv(LIBSSH2_SESSION *session, char *pa
 			libssh2_channel_free(channel);
 			return NULL;
 		}
+#ifdef LIBSSH2_DEBUG_SCP
+		_libssh2_debug(session, LIBSSH2_DBG_SCP, "mtime = %ld, atime = %ld", mtime, atime);
+#endif

 		/* We *should* check that atime.usec is valid, but why let that stop use? */
 		break;
@@ -296,6 +304,9 @@ LIBSSH2_API LIBSSH2_CHANNEL *libssh2_scp_recv(LIBSSH2_SESSION *session, char *pa
 			libssh2_channel_free(channel);
 			return NULL;
 		}
+#ifdef LIBSSH2_DEBUG_SCP
+	_libssh2_debug(session, LIBSSH2_DBG_SCP, "mod = 0%lo size = %ld", mode, size);
+#endif

 		/* We *should* check that basename is valid, but why let that stop us? */
 		break;
@@ -345,8 +356,12 @@ LIBSSH2_API LIBSSH2_CHANNEL *libssh2_scp_send_ex(LIBSSH2_SESSION *session, char
 	}
 	command[command_len - 1] = '\0';

+#ifdef LIBSSH2_DEBUG_SCP
+	_libssh2_debug(session, LIBSSH2_DBG_SCP, "Opening channel for SCP send");
+#endif
 	/* Allocate a channel */
 	if ((channel = libssh2_channel_open_session(session)) == NULL) {
+	        /* previous call set libssh2_session_last_error(), pass it through */
 		LIBSSH2_FREE(session, command);
 		return NULL;
 	}
@@ -355,6 +370,7 @@ LIBSSH2_API LIBSSH2_CHANNEL *libssh2_scp_send_ex(LIBSSH2_SESSION *session, char

 	/* Request SCP for the desired file */
 	if (libssh2_channel_process_startup(channel, "exec", sizeof("exec") - 1, command, command_len)) {
+	        /* previous call set libssh2_session_last_error(), pass it through */
 		LIBSSH2_FREE(session, command);
 		libssh2_channel_free(channel);
 		return NULL;
@@ -371,6 +387,9 @@ LIBSSH2_API LIBSSH2_CHANNEL *libssh2_scp_send_ex(LIBSSH2_SESSION *session, char
 	/* Send mtime and atime to be used for file */
 	if (mtime || atime) {
 		response_len = snprintf(response, LIBSSH2_SCP_RESPONSE_BUFLEN, "T%ld 0 %ld 0\n", mtime, atime);
+#ifdef LIBSSH2_DEBUG_SCP
+		_libssh2_debug(session, LIBSSH2_DBG_SCP, "Sent %s", response);
+#endif
 		if (libssh2_channel_write(channel, response, response_len) != response_len) {
 			libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send time data for SCP file", 0);
 			libssh2_channel_free(channel);
@@ -393,6 +412,9 @@ LIBSSH2_API LIBSSH2_CHANNEL *libssh2_scp_send_ex(LIBSSH2_SESSION *session, char
 	}

 	response_len = snprintf(response, LIBSSH2_SCP_RESPONSE_BUFLEN, "C0%o %lu %s\n", mode, (unsigned long)size, base);
+#ifdef LIBSSH2_DEBUG_SCP
+	_libssh2_debug(session, LIBSSH2_DBG_SCP, "Sent %s", response);
+#endif
 	if (libssh2_channel_write(channel, response, response_len) != response_len) {
 		libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send core file data for SCP file", 0);
 		libssh2_channel_free(channel);
--- a/src/session.c
+++ b/src/session.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2004, Sara Golemon <sarag@libssh2.org>
+/* Copyright (c) 2004-2005, Sara Golemon <sarag@libssh2.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms,
@@ -42,6 +42,26 @@
 #endif
 #include <stdlib.h>

+#ifdef HAVE_GETTIMEOFDAY
+#include <sys/time.h>
+#include <math.h>
+#endif
+
+#ifdef HAVE_POLL
+# include <sys/poll.h>
+#else
+# ifdef HAVE_SELECT
+#  ifdef HAVE_SYS_SELECT_H
+#   include <sys/select.h>
+#  else
+#   include <sys/time.h>
+#   include <sys/types.h>
+#  endif
+# endif
+#endif
+
+
+
 /* {{{ libssh2_default_alloc
 */
 static LIBSSH2_ALLOC_FUNC(libssh2_default_alloc)
@@ -81,7 +101,7 @@ static int libssh2_banner_receive(LIBSSH2_SESSION *session)
 		char c = '\0';
 		int ret;

-		ret = recv(session->socket_fd, &c, 1, 0);
+		ret = recv(session->socket_fd, &c, 1, LIBSSH2_SOCKET_RECV_FLAGS(session));

 		if ((ret < 0) && (ret != EAGAIN)) {
 			/* Some kinda error, but don't break for non-blocking issues */
@@ -108,6 +128,9 @@ static int libssh2_banner_receive(LIBSSH2_SESSION *session)
 	session->remote.banner = LIBSSH2_ALLOC(session, banner_len + 1);
 	memcpy(session->remote.banner, banner, banner_len);
 	session->remote.banner[banner_len] = '\0';
+#ifdef LIBSSH2_DEBUG_TRANSPORT
+	_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Received Banner: %s", session->remote.banner);
+#endif
 	return 0;
 }
 /* }}} */
@@ -125,8 +148,24 @@ static int libssh2_banner_send(LIBSSH2_SESSION *session)
 		banner_len = strlen(session->local.banner);
 		banner = session->local.banner;
 	}
+#ifdef LIBSSH2_DEBUG_TRANSPORT
+{
+	/* Hack and slash to avoid sending CRLF in debug output */
+	char banner_dup[256];

-	return (send(session->socket_fd, banner, banner_len, 0) == banner_len) ? 0 : 1;
+	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
+
+	return (send(session->socket_fd, banner, banner_len, LIBSSH2_SOCKET_SEND_FLAGS(session)) == banner_len) ? 0 : 1;
 }
 /* }}} */

@@ -153,6 +192,10 @@ LIBSSH2_API int libssh2_banner_set(LIBSSH2_SESSION *session, char *banner)
 	}

 	memcpy(session->local.banner, banner, banner_len);
+#ifdef LIBSSH2_DEBUG_TRANSPORT
+	session->local.banner[banner_len] = '\0';
+	_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Setting local Banner: %s", session->local.banner);
+#endif
 	session->local.banner[banner_len++] = '\r';
 	session->local.banner[banner_len++] = '\n';
 	session->local.banner[banner_len++] = '\0';
@@ -188,6 +231,9 @@ LIBSSH2_API LIBSSH2_SESSION *libssh2_session_init_ex(
 	session->free		= local_free;
 	session->realloc	= local_realloc;
 	session->abstract	= abstract;
+#ifdef LIBSSH2_DEBUG_TRANSPORT
+	_libssh2_debug(session, LIBSSH2_DBG_TRANS, "New session resource allocated");
+#endif

 	return session;
 }
@@ -228,6 +274,9 @@ LIBSSH2_API void* libssh2_session_callback_set(LIBSSH2_SESSION *session, int cbt
 			return oldcb;
 			break;
 	}
+#ifdef LIBSSH2_DEBUG_TRANSPORT
+	_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Setting Callback %d", cbtype);
+#endif

 	return NULL;
 }
@@ -246,6 +295,9 @@ LIBSSH2_API int libssh2_session_startup(LIBSSH2_SESSION *session, int socket)
 	unsigned char service[sizeof("ssh-userauth") + 5 - 1];
 	unsigned long service_length;

+#ifdef LIBSSH2_DEBUG_TRANSPORT
+	_libssh2_debug(session, LIBSSH2_DBG_TRANS, "session_startup for socket %d", socket);
+#endif
 	if (socket <= 0) {
 		/* Did we forget something? */
 		libssh2_error(session, LIBSSH2_ERROR_SOCKET_NONE, "No socket provided", 0);
@@ -254,23 +306,26 @@ LIBSSH2_API int libssh2_session_startup(LIBSSH2_SESSION *session, int socket)
 	session->socket_fd = socket;

 	/* TODO: Liveness check */
-	if (libssh2_banner_receive(session)) {
-		/* Unable to receive banner from remote */
-		libssh2_error(session, LIBSSH2_ERROR_BANNER_NONE, "Timeout waiting for banner", 0);
-		return LIBSSH2_ERROR_BANNER_NONE;
-	}
-
 	if (libssh2_banner_send(session)) {
 		/* Unable to send banner? */
 		libssh2_error(session, LIBSSH2_ERROR_BANNER_SEND, "Error sending banner to remote host", 0);
 		return LIBSSH2_ERROR_BANNER_SEND;
 	}

+	if (libssh2_banner_receive(session)) {
+		/* Unable to receive banner from remote */
+		libssh2_error(session, LIBSSH2_ERROR_BANNER_NONE, "Timeout waiting for banner", 0);
+		return LIBSSH2_ERROR_BANNER_NONE;
+	}
+
 	if (libssh2_kex_exchange(session, 0)) {
 		libssh2_error(session, LIBSSH2_ERROR_KEX_FAILURE, "Unable to exchange encryption keys", 0);
 		return LIBSSH2_ERROR_KEX_FAILURE;
 	}

+#ifdef LIBSSH2_DEBUG_TRANSPORT
+	_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Requesting userauth service");
+#endif
 	/* Request the userauth service */
 	service[0] = SSH_MSG_SERVICE_REQUEST;
 	libssh2_htonu32(service + 1, sizeof("ssh-userauth") - 1);
@@ -303,6 +358,9 @@ LIBSSH2_API int libssh2_session_startup(LIBSSH2_SESSION *session, int socket)
 */
 LIBSSH2_API void libssh2_session_free(LIBSSH2_SESSION *session)
 {
+#ifdef LIBSSH2_DEBUG_TRANSPORT
+	_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Freeing session resource", session->remote.banner);
+#endif
 	while (session->channels.head) {
 		LIBSSH2_CHANNEL *tmp = session->channels.head;

@@ -325,7 +383,7 @@ LIBSSH2_API void libssh2_session_free(LIBSSH2_SESSION *session)
 		libssh2_channel_forward_cancel(session->listeners);
 	}

-	if (session->newkeys) {
+	if (session->state & LIBSSH2_STATE_NEWKEYS) {
 		/* hostkey */
 		if (session->hostkey && session->hostkey->dtor) {
 			session->hostkey->dtor(session, &session->server_hostkey_abstract);
@@ -444,6 +502,9 @@ LIBSSH2_API int libssh2_session_disconnect_ex(LIBSSH2_SESSION *session, int reas
 	unsigned char *s, *data;
 	unsigned long data_len, descr_len = 0, lang_len = 0;

+#ifdef LIBSSH2_DEBUG_TRANSPORT
+	_libssh2_debug(session, LIBSSH2_DBG_TRANS, "Disconnecting: reason=%d, desc=%s, lang=%s", reason, description, lang);
+#endif
 	if (description) {
 		descr_len = strlen(description);
 	}
@@ -488,46 +549,52 @@ LIBSSH2_API int libssh2_session_disconnect_ex(LIBSSH2_SESSION *session, int reas
 */
 LIBSSH2_API char *libssh2_session_methods(LIBSSH2_SESSION *session, int method_type)
 {
-	char *methodlist = NULL;
+	/* All methods have char *name as their first element */
+	LIBSSH2_KEX_METHOD *method = NULL;

 	switch(method_type) {
 		case LIBSSH2_METHOD_KEX:
-			methodlist = session->kex->name;
+			method = session->kex;
 		break;
 		case LIBSSH2_METHOD_HOSTKEY:
-			methodlist = session->hostkey->name;
+			method = (LIBSSH2_KEX_METHOD*)session->hostkey;
 		break;
 		case LIBSSH2_METHOD_CRYPT_CS:
-			methodlist = session->local.crypt->name;
+			method = (LIBSSH2_KEX_METHOD*)session->local.crypt;
 		break;
 		case LIBSSH2_METHOD_CRYPT_SC:
-			methodlist = session->remote.crypt->name;
+			method = (LIBSSH2_KEX_METHOD*)session->remote.crypt;
 		break;
 		case LIBSSH2_METHOD_MAC_CS:
-			methodlist = session->local.mac->name;
+			method = (LIBSSH2_KEX_METHOD*)session->local.mac;
 		break;
 		case LIBSSH2_METHOD_MAC_SC:
-			methodlist = session->remote.mac->name;
+			method = (LIBSSH2_KEX_METHOD*)session->remote.mac;
 		break;
 		case LIBSSH2_METHOD_COMP_CS:
-			methodlist = session->local.comp->name;
+			method = (LIBSSH2_KEX_METHOD*)session->local.comp;
 		break;
 		case LIBSSH2_METHOD_COMP_SC:
-			methodlist = session->remote.comp->name;
+			method = (LIBSSH2_KEX_METHOD*)session->remote.comp;
 		break;
 		case LIBSSH2_METHOD_LANG_CS:
-			methodlist = "";
+			return "";
 		break;
 		case LIBSSH2_METHOD_LANG_SC:
-			methodlist = "";
+			return "";
 		break;
 		default:
 			libssh2_error(session, LIBSSH2_ERROR_INVAL, "Invalid parameter specified for method_type", 0);
-			methodlist = NULL;
+			return NULL;
 		break;
 	}

-	return(methodlist);
+	if (!method) {
+		libssh2_error(session, LIBSSH2_ERROR_METHOD_NONE, "No method negotiated", 0);
+		return NULL;
+	}
+
+	return method->name;
 }
 /* }}} */

@@ -594,3 +661,306 @@ LIBSSH2_API int libssh2_session_last_error(LIBSSH2_SESSION *session, char **errm
 	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_poll_channel_read
+ * Returns 0 if no data is waiting on channel,
+ * non-0 if data is available
+ */
+static int libssh2_poll_channel_read(LIBSSH2_CHANNEL *channel, int extended)
+{
+	LIBSSH2_SESSION *session = channel->session;
+	LIBSSH2_PACKET *packet = session->packets.head;
+
+	while (packet) {
+		if (((packet->data[0] == SSH_MSG_CHANNEL_DATA) && (extended == 0) && (channel->local.id == libssh2_ntohu32(packet->data + 1))) ||
+			((packet->data[0] == SSH_MSG_CHANNEL_EXTENDED_DATA) && (extended != 0) && (channel->local.id == libssh2_ntohu32(packet->data + 1)))) {
+			/* Found data waiting to be read */
+			return 1;
+		}
+		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
+ */
+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
+ */
+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;
+	int i, active_fds;
+#ifdef HAVE_POLL
+	LIBSSH2_SESSION *session = NULL;
+	struct pollfd sockets[nfds];
+
+	/* 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 -= ceil((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) > 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) > 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, &rfds, &wfds, NULL, &tv);
+		gettimeofday((struct timeval *)&tv_end, NULL);
+
+		timeout_remaining -= (tv_end.tv_sec - tv_begin.tv_sec) * 1000;
+		timeout_remaining -= ceil((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, &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) > 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) > 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;
+}
+/* }}} */
+
--- a/src/sftp.c
+++ b/src/sftp.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2004, Sara Golemon <sarag@libssh2.org>
+/* Copyright (c) 2004-2005, Sara Golemon <sarag@libssh2.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms,
@@ -89,6 +89,11 @@ struct _LIBSSH2_SFTP {
 #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
+
 struct _LIBSSH2_SFTP_HANDLE {
 	LIBSSH2_SFTP *sftp;
 	LIBSSH2_SFTP_HANDLE *prev, *next;
@@ -118,6 +123,9 @@ static int libssh2_sftp_packet_add(LIBSSH2_SFTP *sftp, unsigned char *data, unsi
 	LIBSSH2_SESSION *session = sftp->channel->session;
 	LIBSSH2_PACKET *packet;

+#ifdef LIBSSH2_DEBUG_SFTP
+	_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Received packet %d", (int)data[0]);
+#endif
 	packet = LIBSSH2_ALLOC(session, sizeof(LIBSSH2_PACKET));
 	if (!packet) {
 		libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate datablock for SFTP packet", 0);
@@ -151,8 +159,11 @@ static int libssh2_sftp_packet_read(LIBSSH2_SFTP *sftp, int should_block)
 	LIBSSH2_SESSION *session = channel->session;
 	unsigned char buffer[4]; /* To store the packet length */
 	unsigned char *packet;
-	unsigned long packet_len;
+	unsigned long packet_len, packet_received;

+#ifdef LIBSSH2_DEBUG_SFTP
+	_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Waiting for packet: %s block", should_block ? "will" : "willnot");
+#endif
 	if (should_block) {
 		libssh2_channel_set_blocking(channel, 1);
 		if (4 != libssh2_channel_read(channel, buffer, 4)) {
@@ -172,6 +183,9 @@ static int libssh2_sftp_packet_read(LIBSSH2_SFTP *sftp, int should_block)
 		}
 	}
 	packet_len = libssh2_ntohu32(buffer);
+#ifdef LIBSSH2_DEBUG_SFTP
+	_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Data begin - Packet Length: %lu", packet_len);
+#endif
 	if (packet_len > LIBSSH2_SFTP_PACKET_MAXLEN) {
 		libssh2_error(session, LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED, "SFTP packet too large", 0);
 		return -1;
@@ -183,10 +197,16 @@ static int libssh2_sftp_packet_read(LIBSSH2_SFTP *sftp, int should_block)
 		return -1;
 	}

-	if (packet_len != libssh2_channel_read(channel, packet, packet_len)) {
-		libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, "Timeout waiting for SFTP packet", 0);
-		LIBSSH2_FREE(session, packet);
-		return -1;
+	packet_received = 0;
+	while (packet_len > packet_received) {
+		long bytes_received = libssh2_channel_read(channel, packet + packet_received, packet_len - packet_received);
+
+		if (bytes_received < 0) {
+			libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, "Receive error waiting for SFTP packet", 0);
+			LIBSSH2_FREE(session, packet);
+			return -1;
+		}
+		packet_received += bytes_received;
 	}

 	if (libssh2_sftp_packet_add(sftp, packet, packet_len)) {
@@ -206,7 +226,11 @@ static int libssh2_sftp_packet_ask(LIBSSH2_SFTP *sftp, unsigned char packet_type
 	LIBSSH2_SESSION *session = sftp->channel->session;
 	LIBSSH2_PACKET *packet = sftp->packets.head;
 	unsigned char match_buf[5];
+	int match_len = 5;

+#ifdef LIBSSH2_DEBUG_SFTP
+	_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Asking for %d packet", (int)packet_type);
+#endif
 	if (poll_channel) {
 		if (libssh2_sftp_packet_read(sftp, 0) < 0) {
 			return -1;
@@ -214,10 +238,15 @@ static int libssh2_sftp_packet_ask(LIBSSH2_SFTP *sftp, unsigned char packet_type
 	}

 	match_buf[0] = packet_type;
-	libssh2_htonu32(match_buf + 1, request_id);
+	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(packet->data, match_buf, 5) == 0) {
+		if (strncmp(packet->data, match_buf, match_len) == 0) {
 			*data = packet->data;
 			*data_len = packet->data_len;

@@ -250,6 +279,9 @@ static int libssh2_sftp_packet_require(LIBSSH2_SFTP *sftp, unsigned char packet_
 {
 	LIBSSH2_SESSION *session = sftp->channel->session;

+#ifdef LIBSSH2_DEBUG_SFTP
+	_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Requiring %d packet", (int)packet_type);
+#endif
 	if (libssh2_sftp_packet_ask(sftp, packet_type, request_id, data, data_len, 0) == 0) {
 		/* A packet was available in the packet brigade */
 		return 0;
@@ -280,12 +312,21 @@ static int libssh2_sftp_packet_requirev(LIBSSH2_SFTP *sftp, int num_valid_respon
 {
 	int i;

+	/* Flush */
+	while (libssh2_sftp_packet_read(sftp, 0) > 0);
+
 	while (sftp->channel->session->socket_state == LIBSSH2_SOCKET_CONNECTED) {
+		int ret;
 		for(i = 0; i < num_valid_responses; i++) {
-			if (libssh2_sftp_packet_ask(sftp, valid_responses[i], request_id, data, data_len, !i) == 0) {
+			if (libssh2_sftp_packet_ask(sftp, valid_responses[i], request_id, data, data_len, 0) == 0) {
 				return 0;
 			}
 		}
+		ret = libssh2_sftp_packet_read(sftp, 1);
+		if (ret < 0) {
+			return -1;
+		}
+		if (ret == 0) continue;
 	}

 	return -1;
@@ -408,9 +449,12 @@ LIBSSH2_API LIBSSH2_SFTP *libssh2_sftp_init(LIBSSH2_SESSION *session)
 {
 	LIBSSH2_SFTP *sftp;
 	LIBSSH2_CHANNEL *channel;
-	unsigned char *data, *s, buffer[13]; /* sftp_header(9) + version_id(4) */
-	unsigned long data_len, request_id;
+	unsigned char *data, *s, buffer[9]; /* sftp_header(5){excludes request_id} + version_id(4) */
+	unsigned long data_len;

+#ifdef LIBSSH2_DEBUG_SFTP
+	_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Initializing SFTP subsystem");
+#endif
 	channel = libssh2_channel_open_session(session);
 	if (!channel) {
 		libssh2_error(session, LIBSSH2_ERROR_CHANNEL_FAILURE, "Unable to startup channel", 0);
@@ -424,6 +468,8 @@ LIBSSH2_API LIBSSH2_SFTP *libssh2_sftp_init(LIBSSH2_SESSION *session)

 	libssh2_channel_set_blocking(channel, 1);

+	libssh2_channel_handle_extended_data(channel, LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE);
+
 	sftp = LIBSSH2_ALLOC(session, sizeof(LIBSSH2_SFTP));
 	if (!sftp) {
 		libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate a new SFTP structure", 0);
@@ -432,21 +478,23 @@ LIBSSH2_API LIBSSH2_SFTP *libssh2_sftp_init(LIBSSH2_SESSION *session)
 	}
 	memset(sftp, 0, sizeof(LIBSSH2_SFTP));
 	sftp->channel = channel;
+	sftp->request_id = 0;

-	request_id = sftp->request_id++;
-	libssh2_htonu32(buffer, 4 + 5);
+	libssh2_htonu32(buffer, 5);
 	buffer[4] = SSH_FXP_INIT;
-	libssh2_htonu32(buffer + 5, request_id);
-	libssh2_htonu32(buffer + 9, 6);
+	libssh2_htonu32(buffer + 5, LIBSSH2_SFTP_VERSION);

-	if (13 != libssh2_channel_write(channel, buffer, 13)) {
+#ifdef LIBSSH2_DEBUG_SFTP
+	_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Sending FXP_INIT packet advertising version %d support", (int)LIBSSH2_SFTP_VERSION);
+#endif
+	if (9 != libssh2_channel_write(channel, buffer, 9)) {
 		libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send SSH_FXP_INIT", 0);
 		libssh2_channel_free(channel);
 		LIBSSH2_FREE(session, sftp);
 		return NULL;
 	}

-	if (libssh2_sftp_packet_require(sftp, SSH_FXP_VERSION, request_id, &data, &data_len)) {
+	if (libssh2_sftp_packet_require(sftp, SSH_FXP_VERSION, 0, &data, &data_len)) {
 		libssh2_error(session, LIBSSH2_ERROR_SOCKET_TIMEOUT, "Timeout waiting for response from SFTP subsystem", 0);
 		libssh2_channel_free(channel);
 		LIBSSH2_FREE(session, sftp);
@@ -462,8 +510,14 @@ LIBSSH2_API LIBSSH2_SFTP *libssh2_sftp_init(LIBSSH2_SESSION *session)
 	s = data + 1;
 	sftp->version = libssh2_ntohu32(s);					s += 4;
 	if (sftp->version > LIBSSH2_SFTP_VERSION) {
+#ifdef LIBSSH2_DEBUG_SFTP
+		_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Truncating remote SFTP version from %lu", sftp->version);
+#endif
 		sftp->version = LIBSSH2_SFTP_VERSION;
 	}
+#ifdef LIBSSH2_DEBUG_SFTP
+	_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Enabling SFTP version %lu compatability", sftp->version);
+#endif
 	while (s < (data + data_len)) {
 		char *extension_name, *extension_data;
 		unsigned long extname_len, extdata_len;
@@ -518,7 +572,8 @@ LIBSSH2_API LIBSSH2_SFTP_HANDLE *libssh2_sftp_open_ex(LIBSSH2_SFTP *sftp, char *
 		libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for FXP_REMOVE packet", 0);
 		return NULL;
 	}
-	attrs.permissions = mode;
+	/* 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, packet_len - 4);					s += 4;
 	*(s++) = (open_type == LIBSSH2_SFTP_OPENFILE) ? SSH_FXP_OPEN : SSH_FXP_OPENDIR;
@@ -531,6 +586,9 @@ LIBSSH2_API LIBSSH2_SFTP_HANDLE *libssh2_sftp_open_ex(LIBSSH2_SFTP *sftp, char *
 		s += libssh2_sftp_attr2bin(s, &attrs);
 	}

+#ifdef LIBSSH2_DEBUG_SFTP
+	_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Sending %s open request", (open_type == LIBSSH2_SFTP_OPENFILE) ? "file" : "directory");
+#endif
 	if (packet_len != libssh2_channel_write(channel, packet, packet_len)) {
 		libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send FXP_REMOVE command", 0);
 		LIBSSH2_FREE(session, packet);
@@ -583,6 +641,9 @@ LIBSSH2_API LIBSSH2_SFTP_HANDLE *libssh2_sftp_open_ex(LIBSSH2_SFTP *sftp, char *

 	fp->u.file.offset = 0;

+#ifdef LIBSSH2_DEBUG_SFTP
+	_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Open command successful");
+#endif
 	return fp;
 }
 /* }}} */
@@ -601,6 +662,9 @@ LIBSSH2_API size_t libssh2_sftp_read(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
 	unsigned char read_responses[2] = { SSH_FXP_DATA,		SSH_FXP_STATUS };
 	size_t bytes_read = 0;

+#ifdef LIBSSH2_DEBUG_SFTP
+	_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Reading %lu bytes from SFTP handle", (unsigned long)buffer_maxlen);
+#endif
 	s = packet = LIBSSH2_ALLOC(session, packet_len);
 	if (!packet) {
 		libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for FXP_CLOSE packet", 0);
@@ -639,6 +703,9 @@ LIBSSH2_API size_t libssh2_sftp_read(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
 			if (bytes_read > (data_len - 9)) {
 				return -1;
 			}
+#ifdef LIBSSH2_DEBUG_SFTP
+			_libssh2_debug(session, LIBSSH2_DBG_SFTP, "%lu bytes returned", (unsigned long)bytes_read);
+#endif
 			memcpy(buffer, data + 9, bytes_read);
 			handle->u.file.offset += bytes_read;
 			LIBSSH2_FREE(session, data);
@@ -705,6 +772,9 @@ LIBSSH2_API int libssh2_sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
 	libssh2_htonu32(s, handle->handle_len);				s += 4;
 	memcpy(s, handle->handle, handle->handle_len);		s += handle->handle_len;

+#ifdef LIBSSH2_DEBUG_SFTP
+	_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Reading entries from directory handle");
+#endif
 	if (packet_len != libssh2_channel_write(channel, packet, packet_len)) {
 		libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send FXP_READ command", 0);
 		LIBSSH2_FREE(session, packet);
@@ -732,6 +802,9 @@ LIBSSH2_API int libssh2_sftp_readdir(LIBSSH2_SFTP_HANDLE *handle, char *buffer,
 	}

 	num_names = libssh2_ntohu32(data + 5);
+#ifdef LIBSSH2_DEBUG_SFTP
+	_libssh2_debug(session, LIBSSH2_DBG_SFTP, "%lu entries returned", num_names);
+#endif
 	if (num_names <= 0) {
 		LIBSSH2_FREE(session, data);
 		return (num_names == 0) ? 0 : -1;
@@ -776,6 +849,9 @@ LIBSSH2_API size_t libssh2_sftp_write(LIBSSH2_SFTP_HANDLE *handle, const char *b
 	unsigned long packet_len = handle->handle_len + count + 25; /* packet_len(4) + packet_type(1) + request_id(4) + handle_len(4) + offset(8) + count(4) */
 	unsigned char *packet, *s, *data;

+#ifdef LIBSSH2_DEBUG_SFTP
+	_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Writing %lu bytes", (unsigned long)count);
+#endif
 	s = packet = LIBSSH2_ALLOC(session, packet_len);
 	if (!packet) {
 		libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for FXP_WRITE packet", 0);
@@ -832,6 +908,9 @@ LIBSSH2_API int libssh2_sftp_fstat_ex(LIBSSH2_SFTP_HANDLE *handle, LIBSSH2_SFTP_
 	unsigned char *packet, *s, *data;
 	unsigned char fstat_responses[2] = { SSH_FXP_ATTRS,		SSH_FXP_STATUS };

+#ifdef LIBSSH2_DEBUG_SFTP
+	_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Issuing %s command", setstat ? "set-stat" : "stat");
+#endif
 	s = packet = LIBSSH2_ALLOC(session, packet_len);
 	if (!packet) {
 		libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for FSTAT/FSETSTAT packet", 0);
@@ -912,6 +991,9 @@ LIBSSH2_API int libssh2_sftp_close_handle(LIBSSH2_SFTP_HANDLE *handle)
 	unsigned long packet_len = handle->handle_len + 13; /* packet_len(4) + packet_type(1) + request_id(4) + handle_len(4) */
 	unsigned char *packet, *s, *data;

+#ifdef LIBSSH2_DEBUG_SFTP
+	_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Closing handle");
+#endif
 	s = packet = LIBSSH2_ALLOC(session, packet_len);
 	if (!packet) {
 		libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for FXP_CLOSE packet", 0);
@@ -980,6 +1062,9 @@ LIBSSH2_API int libssh2_sftp_unlink_ex(LIBSSH2_SFTP *sftp, char *filename, int f
 	unsigned long packet_len = filename_len + 13; /* packet_len(4) + packet_type(1) + request_id(4) + filename_len(4) */
 	unsigned char *packet, *s, *data;

+#ifdef LIBSSH2_DEBUG_SFTP
+	_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Unlinking %s", filename);
+#endif
 	s = packet = LIBSSH2_ALLOC(session, packet_len);
 	if (!packet) {
 		libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for FXP_REMOVE packet", 0);
@@ -1032,6 +1117,14 @@ LIBSSH2_API int libssh2_sftp_rename_ex(LIBSSH2_SFTP *sftp,  char *source_filenam
 																				source_filename_len(4) + dest_filename_len(4) + flags(4) */
 	unsigned char *packet, *s, *data;

+	if (sftp->version < 2) {
+		libssh2_error(session, LIBSSH2_ERROR_SFTP_PROTOCOL, "Server does not support RENAME", 0);
+		return -1;
+	}
+
+#ifdef LIBSSH2_DEBUG_SFTP
+	_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Renaming %s to %s", source_filename, dest_filename);
+#endif
 	s = packet = LIBSSH2_ALLOC(session, packet_len);
 	if (!packet) {
 		libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for FXP_RENAME packet", 0);
@@ -1100,12 +1193,16 @@ LIBSSH2_API int libssh2_sftp_mkdir_ex(LIBSSH2_SFTP *sftp, char *path, int path_l
 			/* packet_len(4) + packet_type(1) + request_id(4) + path_len(4) */
 	unsigned char *packet, *s, *data;

+#ifdef LIBSSH2_DEBUG_SFTP
+	_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Creating directory %s with mode 0%lo", path, mode);
+#endif
 	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;
 	}
-	attrs.permissions = mode;
+	/* 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;
@@ -1151,6 +1248,9 @@ LIBSSH2_API int libssh2_sftp_rmdir_ex(LIBSSH2_SFTP *sftp, char *path, int path_l
 	unsigned long packet_len = path_len + 13; /* packet_len(4) + packet_type(1) + request_id(4) + path_len(4) */
 	unsigned char *packet, *s, *data;

+#ifdef LIBSSH2_DEBUG_SFTP
+	_libssh2_debug(session, LIBSSH2_DBG_SFTP, "Removing directory: %s", path);
+#endif
 	s = packet = LIBSSH2_ALLOC(session, packet_len);
 	if (!packet) {
 		libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for FXP_MKDIR packet", 0);
@@ -1202,6 +1302,9 @@ LIBSSH2_API int libssh2_sftp_stat_ex(LIBSSH2_SFTP *sftp, char *path, int path_le
 	unsigned char *packet, *s, *data;
 	unsigned char stat_responses[2] = { SSH_FXP_ATTRS,		SSH_FXP_STATUS	};

+#ifdef LIBSSH2_DEBUG_SFTP
+	_libssh2_debug(session, LIBSSH2_DBG_SFTP, "%s %s", (stat_type == LIBSSH2_SFTP_SETSTAT) ? "Set-statting" : (stat_type == LIBSSH2_SFTP_LSTAT ? "LStatting" : "Statting"), path);
+#endif
 	s = packet = LIBSSH2_ALLOC(session, packet_len);
 	if (!packet) {
 		libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for FXP_MKDIR packet", 0);
@@ -1275,12 +1378,22 @@ LIBSSH2_API int libssh2_sftp_symlink_ex(LIBSSH2_SFTP *sftp, const char *path, in
 	unsigned char *packet, *s, *data;
 	unsigned char link_responses[2] = { SSH_FXP_NAME,		SSH_FXP_STATUS	};

+	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;
+	}
+
 	s = packet = LIBSSH2_ALLOC(session, packet_len);
 	if (!packet) {
 		libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for SYMLINK/READLINK/REALPATH packet", 0);
 		return -1;
 	}

+#ifdef LIBSSH2_DEBUG_SFTP
+	_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);
+#endif
 	libssh2_htonu32(s, packet_len - 4);					s += 4;
 	switch (link_type) {
 		case LIBSSH2_SFTP_REALPATH:
--- a/src/userauth.c
+++ b/src/userauth.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2004, Sara Golemon <sarag@libssh2.org>
+/* Copyright (c) 2004-2005, Sara Golemon <sarag@libssh2.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms,
@@ -36,7 +36,12 @@
 */

 #include "libssh2_priv.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
@@ -46,6 +51,7 @@
 */
 LIBSSH2_API char *libssh2_userauth_list(LIBSSH2_SESSION *session, char *username, int username_len)
 {
+	unsigned char reply_codes[3] = { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, 0 };
 	unsigned long data_len = username_len + 31; /* packet_type(1) + username_len(4) + service_len(4) + service(14)"ssh-connection" +
 												   method_len(4) + method(4)"none" */
 	unsigned long methods_len;
@@ -76,25 +82,23 @@ LIBSSH2_API char *libssh2_userauth_list(LIBSSH2_SESSION *session, char *username
 	}
 	LIBSSH2_FREE(session, data);

-	while (1) {
-		if (libssh2_packet_ask(session, SSH_MSG_USERAUTH_SUCCESS, &data, &data_len, 1) == 0) {
-			/* Wow, who'dve thought... */
-			LIBSSH2_FREE(session, data);
-			session->authenticated = 1;
-			return NULL;
-		}
+	if (libssh2_packet_requirev(session, reply_codes, &data, &data_len)) {
+		return NULL;
+	}

-		if (libssh2_packet_ask(session, SSH_MSG_USERAUTH_FAILURE, &data, &data_len, 0) == 0) {
-			/* What we *actually* wanted to happen */
-			break;
-		}
-		/* TODO: Timeout? */
+	if (data[0] == SSH_MSG_USERAUTH_SUCCESS) {
+		/* Wow, who'dve thought... */
+		LIBSSH2_FREE(session, data);
+		session->state |= LIBSSH2_STATE_AUTHENTICATED;
+		return NULL;
 	}

 	methods_len = libssh2_ntohu32(data + 1);
 	memcpy(data, data + 5, methods_len);
 	data[methods_len] = '\0';
-
+#ifdef LIBSSH2_DEBUG_USERAUTH
+	_libssh2_debug(session, LIBSSH2_DBG_AUTH, "Permitted auth methods: %s", data);
+#endif
 	return data;
 }
 /* }}} */
@@ -105,7 +109,7 @@ LIBSSH2_API char *libssh2_userauth_list(LIBSSH2_SESSION *session, char *username
 */
 LIBSSH2_API int libssh2_userauth_authenticated(LIBSSH2_SESSION *session)
 {
-	return session->authenticated;
+	return session->state & LIBSSH2_STATE_AUTHENTICATED;
 }
 /* }}} */

@@ -116,7 +120,7 @@ LIBSSH2_API int libssh2_userauth_password_ex(LIBSSH2_SESSION *session, char *use
 																					  char *password, int password_len,
 																					  LIBSSH2_PASSWD_CHANGEREQ_FUNC((*passwd_change_cb)))
 {
-	unsigned char *data, *s;
+	unsigned char *data, *s, reply_codes[4] = { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, SSH_MSG_USERAUTH_PASSWD_CHANGEREQ, 0 };
 	unsigned long data_len = username_len + password_len + 40; /* packet_type(1) + username_len(4) + service_len(4) + service(14)"ssh-connection" + 
 																  method_len(4) + method(8)"password" + chgpwdbool(1) + password_len(4) */

@@ -141,6 +145,9 @@ LIBSSH2_API int libssh2_userauth_password_ex(LIBSSH2_SESSION *session, char *use
 	libssh2_htonu32(s, password_len);							s += 4;
 	memcpy(s, password, password_len);							s += password_len;

+#ifdef LIBSSH2_DEBUG_USERAUTH
+	_libssh2_debug(session, LIBSSH2_DBG_AUTH, "Attempting to login using password authentication");
+#endif
 	if (libssh2_packet_write(session, data, data_len)) {
 		libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send userauth-password request", 0);
 		LIBSSH2_FREE(session, data);
@@ -148,71 +155,78 @@ LIBSSH2_API int libssh2_userauth_password_ex(LIBSSH2_SESSION *session, char *use
 	}
 	LIBSSH2_FREE(session, data);

-	while (1) {
-		if (libssh2_packet_ask(session, SSH_MSG_USERAUTH_SUCCESS, &data, &data_len, 1) == 0) {
-			LIBSSH2_FREE(session, data);
-			session->authenticated = 1;
-			return 0;
-		}
-
-		if (libssh2_packet_ask(session, SSH_MSG_USERAUTH_FAILURE, &data, &data_len, 0) == 0) {
-			LIBSSH2_FREE(session, data);
-			return -1;
-		}
-
-		if (libssh2_packet_ask(session, SSH_MSG_USERAUTH_PASSWD_CHANGEREQ, &data, &data_len, 0) == 0) {
-			char *newpw = NULL;
-			int newpw_len = 0;
-
-			LIBSSH2_FREE(session, data);
-			if (passwd_change_cb) {
-				passwd_change_cb(session, &newpw, &newpw_len, &session->abstract);
-				if (!newpw) {
-					libssh2_error(session, LIBSSH2_ERROR_PASSWORD_EXPIRED, "Password expired, and callback failed", 0);
-					return -1;
-				}
-				data_len = username_len + password_len + 44 + newpw_len; /* basic data_len + newpw_len(4) */
-				s = data = LIBSSH2_ALLOC(session, data_len);
-				if (!data) {
-					libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for userauth-password-change 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 = 0xFF;													s++;
-
-				libssh2_htonu32(s, password_len);							s += 4;
-				memcpy(s, password, password_len);							s += password_len;
-
-				libssh2_htonu32(s, newpw_len);								s += 4;
-				memcpy(s, newpw, newpw_len);								s += newpw_len;
-
-				if (libssh2_packet_write(session, data, data_len)) {
-					libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send userauth-password-change request", 0);
-					LIBSSH2_FREE(session, data);
-					return -1;
-				}
-				LIBSSH2_FREE(session, data);
-				LIBSSH2_FREE(session, newpw);
-				/* TODO: Reset timeout? */
-			} else {
-				libssh2_error(session, LIBSSH2_ERROR_PASSWORD_EXPIRED, "Password Expired, and no callback specified", 0);
-				return -1;
-			}
-		}
-		/* TODO: Timeout? */
+ password_response:
+	if (libssh2_packet_requirev(session, reply_codes, &data, &data_len)) {
+		return -1;
 	}

-	return 0;
+	if (data[0] == SSH_MSG_USERAUTH_SUCCESS) {
+#ifdef LIBSSH2_DEBUG_USERAUTH
+	_libssh2_debug(session, LIBSSH2_DBG_AUTH, "Password authentication successful");
+#endif
+		LIBSSH2_FREE(session, data);
+		session->state |= LIBSSH2_STATE_AUTHENTICATED;
+		return 0;
+	}
+
+	if (data[0] == SSH_MSG_USERAUTH_PASSWD_CHANGEREQ) {
+		char *newpw = NULL;
+		int newpw_len = 0;
+
+#ifdef LIBSSH2_DEBUG_USERAUTH
+		_libssh2_debug(session, LIBSSH2_DBG_AUTH, "Password change required");
+#endif
+		LIBSSH2_FREE(session, data);
+		if (passwd_change_cb) {
+			passwd_change_cb(session, &newpw, &newpw_len, &session->abstract);
+			if (!newpw) {
+				libssh2_error(session, LIBSSH2_ERROR_PASSWORD_EXPIRED, "Password expired, and callback failed", 0);
+				return -1;
+			}
+			data_len = username_len + password_len + 44 + newpw_len; /* basic data_len + newpw_len(4) */
+			s = data = LIBSSH2_ALLOC(session, data_len);
+			if (!data) {
+				libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Unable to allocate memory for userauth-password-change 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 = 0xFF;													s++;
+
+			libssh2_htonu32(s, password_len);							s += 4;
+			memcpy(s, password, password_len);							s += password_len;
+
+			libssh2_htonu32(s, newpw_len);								s += 4;
+			memcpy(s, newpw, newpw_len);								s += newpw_len;
+
+			if (libssh2_packet_write(session, data, data_len)) {
+				libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send userauth-password-change request", 0);
+				LIBSSH2_FREE(session, data);
+				return -1;
+			}
+			LIBSSH2_FREE(session, data);
+			LIBSSH2_FREE(session, newpw);
+
+			/* Ugliest use of goto ever.  Blame it on the askN => requirev migration. */
+			goto password_response;
+		} else {
+			libssh2_error(session, LIBSSH2_ERROR_PASSWORD_EXPIRED, "Password Expired, and no callback specified", 0);
+			return -1;
+		}
+	}
+
+	/* FAILURE */
+	LIBSSH2_FREE(session, data);
+	return -1;
 }
 /* }}} */

@@ -227,6 +241,9 @@ static int libssh2_file_read_publickey(LIBSSH2_SESSION *session, unsigned char *
 	char *pubkey = NULL, c, *sp1, *sp2, *tmp;
 	int pubkey_len = 0, tmp_len;

+#ifdef LIBSSH2_DEBUG_USERAUTH
+	_libssh2_debug(session, LIBSSH2_DBG_AUTH, "Loading public key file: %s", pubkeyfile);
+#endif
 	/* Read Public Key */
 	fd = fopen(pubkeyfile, "r");
 	if (!fd) {
@@ -302,6 +319,9 @@ static int libssh2_file_read_privatekey(LIBSSH2_SESSION *session,	LIBSSH2_HOSTKE
 {
 	LIBSSH2_HOSTKEY_METHOD **hostkey_methods_avail = libssh2_hostkey_methods();

+#ifdef LIBSSH2_DEBUG_USERAUTH
+	_libssh2_debug(session, LIBSSH2_DBG_AUTH, "Loading private key file: %s", privkeyfile);
+#endif
 	*hostkey_method = NULL;
 	*hostkey_abstract = NULL;
 	while (*hostkey_methods_avail && (*hostkey_methods_avail)->name) {
@@ -326,6 +346,137 @@ static int libssh2_file_read_privatekey(LIBSSH2_SESSION *session,	LIBSSH2_HOSTKE
 } 
 /* }}} */

+/* {{{ 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, char *username, int username_len,
+                                                                                 char *publickey, char *privatekey,
+                                                                                 char *passphrase,
+																				 char *hostname, int hostname_len,
+																				 char *local_username, int local_username_len)
+{
+	LIBSSH2_HOSTKEY_METHOD *privkeyobj;
+	void *abstract;
+	unsigned char buf[5];
+	struct iovec datavec[4];
+	unsigned char *method, *pubkeydata, *packet, *s, *sig, *data, reply_codes[3] = { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, 0 };
+	unsigned long method_len, pubkeydata_len, packet_len, sig_len, data_len;
+
+	if (libssh2_file_read_publickey(session, &method, &method_len, &pubkeydata, &pubkeydata_len, publickey)) {
+		return -1;
+	}
+
+	packet_len = username_len + method_len + hostname_len + local_username_len + pubkeydata_len + 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)
+	 */
+	/* 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 */
+	s = packet = LIBSSH2_ALLOC(session, packet_len + 4 + (4 + method_len) + (4 + pubkeydata_len));
+
+	*(s++) = SSH_MSG_USERAUTH_REQUEST;
+	libssh2_htonu32(s, username_len);				s += 4;
+	memcpy(s, username, username_len);				s += username_len;
+
+	libssh2_htonu32(s, 14);							s += 4;
+	memcpy(s, "ssh-connection", 14);				s += 14;
+
+	libssh2_htonu32(s, 9);							s += 4;
+	memcpy(s, "hostbased", 9);						s += 9;
+
+	libssh2_htonu32(s, method_len);					s += 4;
+	memcpy(s, method, method_len);					s += method_len;
+
+	libssh2_htonu32(s, pubkeydata_len);				s += 4;
+	memcpy(s, pubkeydata, pubkeydata_len);			s += pubkeydata_len;
+
+	libssh2_htonu32(s, hostname_len);				s += 4;
+	memcpy(s, hostname, hostname_len);				s += hostname_len;
+
+	libssh2_htonu32(s, local_username_len);			s += 4;
+	memcpy(s, local_username, local_username_len);	s += local_username_len;
+
+	if (libssh2_file_read_privatekey(session, &privkeyobj, &abstract, method, method_len, privatekey, passphrase)) {
+		LIBSSH2_FREE(session, method);
+		LIBSSH2_FREE(session, packet);
+		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 = packet;
+	datavec[2].iov_len = packet_len;
+
+	if (privkeyobj->signv(session, &sig, &sig_len, 3, datavec, &abstract)) {
+		LIBSSH2_FREE(session, method);
+		LIBSSH2_FREE(session, packet);
+		if (privkeyobj->dtor) {
+			privkeyobj->dtor(session, &abstract);
+		}
+		return -1;
+	}
+
+	if (privkeyobj->dtor) {
+		privkeyobj->dtor(session, &abstract);
+	}
+
+	if (sig_len > pubkeydata_len ) {
+		/* Should *NEVER* happen, but...well.. better safe than sorry */
+		packet = LIBSSH2_REALLOC(session, packet, packet_len + 4 + (4 + method_len) + (4 + sig_len)); /* PK sigblob */
+		if (!packet) {
+			libssh2_error(session, LIBSSH2_ERROR_ALLOC, "Failed allocating additional space for userauth-hostbased packet", 0);
+			LIBSSH2_FREE(session, method);
+			return -1;
+		}
+	}
+
+	s = packet + packet_len;
+
+	libssh2_htonu32(s, 4 + method_len + 4 + sig_len);	s += 4;
+
+	libssh2_htonu32(s, method_len);						s += 4;
+	memcpy(s, method, method_len);						s += method_len;
+	LIBSSH2_FREE(session, method);
+
+	libssh2_htonu32(s, sig_len);						s += 4;
+	memcpy(s, sig, sig_len);							s += sig_len;
+	LIBSSH2_FREE(session, sig);
+
+#ifdef LIBSSH2_DEBUG_USERAUTH
+	_libssh2_debug(session, LIBSSH2_DBG_AUTH, "Attempting hostbased authentication");
+#endif
+	if (libssh2_packet_write(session, packet, s - packet)) {
+		libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send userauth-hostbased request", 0);
+		LIBSSH2_FREE(session, packet);
+		return -1;
+	}
+	LIBSSH2_FREE(session, packet);
+
+	if (libssh2_packet_requirev(session, reply_codes, &data, &data_len)) {
+		return -1;
+	}
+
+	if (data[0] == SSH_MSG_USERAUTH_SUCCESS) {
+#ifdef LIBSSH2_DEBUG_USERAUTH
+	_libssh2_debug(session, LIBSSH2_DBG_AUTH, "Hostbased authentication successful");
+#endif
+		/* We are us and we've proved it. */
+		LIBSSH2_FREE(session, data);
+		session->state |= LIBSSH2_STATE_AUTHENTICATED;
+		return 0;
+	}
+
+	/* This public key is not allowed for this user on this server */
+	LIBSSH2_FREE(session, data);
+	libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED, "Invalid signature for supplied public key, or bad username/public key combination", 0);
+	return -1;
+}
+/* }}} */
+
 /* {{{ libssh2_userauth_publickey_fromfile_ex
 * Authenticate using a keypair found in the named files
 */
@@ -337,8 +488,9 @@ LIBSSH2_API int libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION *session,
 	void *abstract;
 	unsigned char buf[5];
 	struct iovec datavec[4];
-	unsigned char *method, *pubkeydata, *packet, *s, *b, *sig;
-	unsigned long method_len, pubkeydata_len, packet_len, sig_len;
+	unsigned char *method, *pubkeydata, *packet, *s, *b, *sig, *data;
+	unsigned char reply_codes[4] = { SSH_MSG_USERAUTH_SUCCESS, SSH_MSG_USERAUTH_FAILURE, SSH_MSG_USERAUTH_PK_OK, 0 };
+	unsigned long method_len, pubkeydata_len, packet_len, sig_len, data_len;

 	if (libssh2_file_read_publickey(session, &method, &method_len, &pubkeydata, &pubkeydata_len, publickey)) {
 		return -1;
@@ -371,6 +523,9 @@ LIBSSH2_API int libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION *session,
 	libssh2_htonu32(s, pubkeydata_len);				s += 4;
 	memcpy(s, pubkeydata, pubkeydata_len);			s += pubkeydata_len;

+#ifdef LIBSSH2_DEBUG_USERAUTH
+	_libssh2_debug(session, LIBSSH2_DBG_AUTH, "Attempting publickey authentication");
+#endif
 	if (libssh2_packet_write(session, packet, packet_len)) {
 		libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send userauth-publickey request", 0);
 		LIBSSH2_FREE(session, packet);
@@ -379,45 +534,38 @@ LIBSSH2_API int libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION *session,
 		return -1;
 	}

-	while (1) {
-		unsigned char *data;
-		unsigned long data_len;
-
-		if (libssh2_packet_ask(session, SSH_MSG_USERAUTH_SUCCESS, &data, &data_len, 1) == 0) {
-			/* God help any SSH server that allows an UNVERIFIED public key to validate the user */
-			LIBSSH2_FREE(session, data);
-			LIBSSH2_FREE(session, packet);
-			LIBSSH2_FREE(session, method);
-			LIBSSH2_FREE(session, pubkeydata);
-			session->authenticated = 1;
-			return 0;
-		}
-
-		if (libssh2_packet_ask(session, SSH_MSG_USERAUTH_FAILURE, &data, &data_len, 0) == 0) {
-			/* This public key is not allowed for this user on this server */
-			LIBSSH2_FREE(session, data);
-			LIBSSH2_FREE(session, packet);
-			LIBSSH2_FREE(session, method);
-			LIBSSH2_FREE(session, pubkeydata);
-			libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNRECOGNIZED, "Username/PublicKey combination invalid", 0);
-			return -1;
-		}
-
-		if (libssh2_packet_ask(session, SSH_MSG_USERAUTH_PK_OK, &data, &data_len, 0) == 0) {
-			/* Semi-Success! */
-			if ((libssh2_ntohu32(data + 1) != method_len) ||
-				strncmp(data + 5, method, method_len) ||
-				(libssh2_ntohu32(data + 5 + method_len) != pubkeydata_len) ||
-				strncmp(data + 5 + method_len + 4, pubkeydata, pubkeydata_len)) {
-				/* Unlikely but possible, the server has responded to a different userauth public key request */
-				LIBSSH2_FREE(session, data);
-				continue;
-			}
-			LIBSSH2_FREE(session, data);
-			break;
-		}
-		/* TODO: Timeout? */
+	if (libssh2_packet_requirev(session, reply_codes, &data, &data_len)) {
+		LIBSSH2_FREE(session, packet);
+		LIBSSH2_FREE(session, method);
+		LIBSSH2_FREE(session, pubkeydata);
+		return -1;
 	}
+
+	if (data[0] == SSH_MSG_USERAUTH_SUCCESS) {
+#ifdef LIBSSH2_DEBUG_USERAUTH
+		_libssh2_debug(session, LIBSSH2_DBG_AUTH, "Pubkey authentication prematurely successful");
+#endif
+		/* God help any SSH server that allows an UNVERIFIED public key to validate the user */
+		LIBSSH2_FREE(session, data);
+		LIBSSH2_FREE(session, packet);
+		LIBSSH2_FREE(session, method);
+		LIBSSH2_FREE(session, pubkeydata);
+		session->state |= LIBSSH2_STATE_AUTHENTICATED;
+		return 0;
+	}
+
+	if (data[0] == SSH_MSG_USERAUTH_FAILURE) {
+		/* This public key is not allowed for this user on this server */
+		LIBSSH2_FREE(session, data);
+		LIBSSH2_FREE(session, packet);
+		LIBSSH2_FREE(session, method);
+		LIBSSH2_FREE(session, pubkeydata);
+		libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNRECOGNIZED, "Username/PublicKey combination invalid", 0);
+		return -1;
+	}
+
+	/* Semi-Success! */
+	LIBSSH2_FREE(session, data);
 	LIBSSH2_FREE(session, pubkeydata);

 	if (libssh2_file_read_privatekey(session, &privkeyobj, &abstract, method, method_len, privatekey, passphrase)) {
@@ -471,6 +619,9 @@ LIBSSH2_API int libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION *session,
 	memcpy(s, sig, sig_len);							s += sig_len;
 	LIBSSH2_FREE(session, sig);

+#ifdef LIBSSH2_DEBUG_USERAUTH
+	_libssh2_debug(session, LIBSSH2_DBG_AUTH, "Attempting publickey authentication -- phase 2");
+#endif
 	if (libssh2_packet_write(session, packet, s - packet)) {
 		libssh2_error(session, LIBSSH2_ERROR_SOCKET_SEND, "Unable to send userauth-publickey request", 0);
 		LIBSSH2_FREE(session, packet);
@@ -478,26 +629,26 @@ LIBSSH2_API int libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION *session,
 	}
 	LIBSSH2_FREE(session, packet);

-	while (1) {
-		unsigned char *data;
-		unsigned long data_len;
+	/* PK_OK is no longer valid */
+	reply_codes[2] = 0;

-		if (libssh2_packet_ask(session, SSH_MSG_USERAUTH_SUCCESS, &data, &data_len, 1) == 0) {
-			/* We are us and we've proved it. */
-			LIBSSH2_FREE(session, data);
-			session->authenticated = 1;
-			return 0;
-		}
-
-		if (libssh2_packet_ask(session, SSH_MSG_USERAUTH_FAILURE, &data, &data_len, 0) == 0) {
-			/* This public key is not allowed for this user on this server */
-			LIBSSH2_FREE(session, data);
-			libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED, "Invalid signature for supplied public key, or bad username/public key combination", 0);
-			return -1;
-		}
-		/* TODO: Timeout? */
+	if (libssh2_packet_requirev(session, reply_codes, &data, &data_len)) {
+		return -1;
 	}

-	return 0;
+	if (data[0] == SSH_MSG_USERAUTH_SUCCESS) {
+#ifdef LIBSSH2_DEBUG_USERAUTH
+		_libssh2_debug(session, LIBSSH2_DBG_AUTH, "Publickey authentication successful");
+#endif
+		/* We are us and we've proved it. */
+		LIBSSH2_FREE(session, data);
+		session->state |= LIBSSH2_STATE_AUTHENTICATED;
+		return 0;
+	}
+
+	/* This public key is not allowed for this user on this server */
+	LIBSSH2_FREE(session, data);
+	libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED, "Invalid signature for supplied public key, or bad username/public key combination", 0);
+	return -1;
 }
 /* }}} */
--- a/win32/.cvsignore
+++ b/win32/.cvsignore
@@ -7,3 +7,6 @@
 Debug
 Release
 *.exp
+*.ncb
+*.opt
+*.plg
--- a/win32/config.mk
+++ b/win32/config.mk
@@ -1,10 +1,10 @@

 # Tweak these for your system
-OPENSSLINC=\local\php\php_build\include
-OPENSSLLIB=\local\php\php_build\lib
+OPENSSLINC=..\libssh2_build\include
+OPENSSLLIB=..\libssh2_build\lib

-ZLIBINC=-DLIBSSH2_HAVE_ZLIB=1 /I\local\php\php_build\include
-ZLIBLIB=\local\php\php_build\lib
+ZLIBINC=-DLIBSSH2_HAVE_ZLIB=1 /I..\libssh2_build\include
+ZLIBLIB=..\libssh2_build\lib

 !if "$(TARGET)" == ""
 TARGET=Release
--- a/win32/libssh2.dsp
+++ b/win32/libssh2.dsp
@@ -0,0 +1,156 @@
+# Microsoft Developer Studio Project File - Name="libssh2" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=libssh2 - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "libssh2.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "libssh2.mak" CFG="libssh2 - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "libssh2 - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "libssh2 - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "libssh2 - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "libssh2___Win32_Release"
+# PROP BASE Intermediate_Dir "libssh2___Win32_Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\include" /I "..\win32" /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo
+
+!ELSEIF  "$(CFG)" == "libssh2 - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\include" /I "..\win32" /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"Debug\libssh2d.lib"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "libssh2 - Win32 Release"
+# Name "libssh2 - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=..\src\channel.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\comp.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\crypt.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\hostkey.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\kex.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\mac.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\misc.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\packet.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\scp.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\session.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\sftp.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\src\userauth.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=..\include\libssh2.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\libssh2_config.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\include\libssh2_priv.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\include\libssh2_sftp.h
+# End Source File
+# End Group
+# End Target
+# End Project
--- a/win32/libssh2.dsw
+++ b/win32/libssh2.dsw
@@ -0,0 +1,41 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "libssh2"=.\libssh2.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "ssh2_sample"=.\ssh2_sample.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
--- a/win32/libssh2_config.h
+++ b/win32/libssh2_config.h
@@ -1,4 +1,6 @@
+#ifndef WIN32
 #define WIN32
+#endif
 #include <winsock2.h>
 #include <mswsock.h>
 #include <ws2tcpip.h>
@@ -29,3 +31,8 @@ static inline int usleep(int udelay)

 #define snprintf	_snprintf

+/* Compile in zlib support */
+#define LIBSSH2_HAVE_ZLIB 1
+
+/* Enable newer diffie-hellman-group-exchange-sha1 syntax */
+#define LIBSSH2_DH_GEX_NEW 1
--- a/win32/ssh2_sample.dsp
+++ b/win32/ssh2_sample.dsp
@@ -0,0 +1,102 @@
+# Microsoft Developer Studio Project File - Name="ssh2_sample" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=ssh2_sample - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "ssh2_sample.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "ssh2_sample.mak" CFG="ssh2_sample - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "ssh2_sample - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "ssh2_sample - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "ssh2_sample - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "ssh2_sample___Win32_Release"
+# PROP BASE Intermediate_Dir "ssh2_sample___Win32_Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\include" /I "..\win32" /D "WIN32" /D "NDEBUG" /D "LIBSSH2_WIN32" /D "_CONSOLE" /D "_MBCS" /D "LIBSSH2_LIBRARY" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib libeay32.lib ssleay32.lib ws2_32.lib zlib.lib libssh2.lib /nologo /subsystem:console /machine:I386 /libpath:"Release"
+
+!ELSEIF  "$(CFG)" == "ssh2_sample - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "ssh2_sample___Win32_Debug"
+# PROP BASE Intermediate_Dir "ssh2_sample___Win32_Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\include" /I "..\win32" /D "WIN32" /D "_DEBUG" /D "LIBSSH2_WIN32" /D "_CONSOLE" /D "_MBCS" /D "LIBSSH2_LIBRARY" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib libeay32.lib ssleay32.lib ws2_32.lib zlib.lib libssh2d.lib /nologo /subsystem:console /debug /machine:I386 /nodefaultlib:"msvcrt.lib" /pdbtype:sept /libpath:"Debug"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "ssh2_sample - Win32 Release"
+# Name "ssh2_sample - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=..\ssh2_sample.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project
Author	SHA1	Message	Date
Sara Golemon	9203a62789	Late commit -- This is for release 0.10	2005-05-24 14:01:38 +00:00
Sara Golemon	6de7ed8a7b	Drop these old references to initial window size, they were a mistake	2005-05-18 17:12:40 +00:00
Sara Golemon	8937980044	BFN	2005-05-18 17:10:27 +00:00
Sara Golemon	cc7703092f	Save up multiple small refunds in order to cut down on unnecessary WINDOW_ADJUST packets	2005-05-18 17:08:29 +00:00
Sara Golemon	7502920c7f	Remove /test/*	2005-05-17 19:30:59 +00:00
Sara Golemon	ff6f2dbe52	Typo: ALWAYS TEST FIRST	2005-05-17 17:18:48 +00:00
Sara Golemon	e5ee4a5be3	Fix sftp packet queueing mechanism	2005-05-17 05:22:41 +00:00
Sara Golemon	30bb7db0d1	Reduce busy-looping of libssh2_sftp_packet_requirev()	2005-05-16 23:12:09 +00:00
Sara Golemon	8d90bbfc28	Fix segfault when client/host can't agree on hostkey/crypt/mac/comp	2005-05-16 17:16:25 +00:00
Sara Golemon	e9b0710b4b	Fix format specifiers	2005-05-11 05:26:12 +00:00
Sara Golemon	379e510c87	Whoops	2005-05-11 05:16:32 +00:00
Sara Golemon	ebfbd22e59	Add debugging hooks for development diagnostics	2005-05-11 05:11:31 +00:00
Sara Golemon	9a0ba35457	Ignore extended data in the SFTP layer.	2005-05-10 04:57:34 +00:00
Sara Golemon	023c54d95d	One last (better be last) fix for FXP_INIT	2005-05-10 04:49:43 +00:00
Sara Golemon	ba2f21eb85	More fixes for channel_write()	2005-05-06 18:30:43 +00:00
Sara Golemon	3ea661a574	Bump for release	2005-05-05 18:48:51 +00:00
Sara Golemon	30755999c5	Check for and link against libm and libsocket	2005-05-05 18:45:42 +00:00
Sara Golemon	8e0e6d81dd	Block means block	2005-05-04 19:01:48 +00:00
Sara Golemon	cba673de6f	Make blocking_read's polling loop less arbitrary	2005-05-04 18:48:47 +00:00
Sara Golemon	11b27e52c3	Put filetype into open/diropen/mkdir attributes	2005-05-04 18:06:07 +00:00
Sara Golemon	f289bcdd54	Fix constant from last patch	2005-05-04 17:52:32 +00:00
Sara Golemon	66e7462f01	Late BFN	2005-05-03 18:35:40 +00:00
Sara Golemon	ed88c32368	FXP_INIT packet should not have had a request_id component and sftp_packet_require shouldn't expect FXP_VERSION to have one when coming back. Thanks puudeli!	2005-05-03 13:57:40 +00:00
Sara Golemon	83b95eb13e	Fixed SFTP to be properly BC with version 1 and 2 servers	2005-04-07 21:53:55 +00:00
Sara Golemon	ba420fc7bf	Block means block.	2005-04-05 23:08:41 +00:00
Sara Golemon	ae9ad1ef6f	break; fallthroughs in win32 code	2005-04-02 05:43:17 +00:00
Sara Golemon	d3f854c21b	Phase II of packet loop migration: Clean code is good code	2005-04-01 20:17:09 +00:00
Sara Golemon	5d9c0d50f3	Another typo	2005-04-01 15:34:14 +00:00
Sara Golemon	35a3e7a6c0	typo	2005-04-01 06:55:44 +00:00
Sara Golemon	15b8489046	Phase 1 of the Great Timeout Cleanup	2005-04-01 06:11:34 +00:00
Sara Golemon	dce388e9c5	Nix unused variable	2005-03-28 23:03:41 +00:00
Sara Golemon	0138e36352	Add libssh2_channel_window_(read\|write)_ex()	2005-03-28 22:59:35 +00:00
Sara Golemon	d6039f39e4	Nix the memset loop Speaking of which: Why wasn't it JUST a memset() call? The encrypted version of packet_write fills in this data with OpenSSL RAND_bytes() data, and as far as the unencrypted version goes? Well, it's unencrypted, randomness doesn't help at that point.	2005-03-26 05:31:31 +00:00
Sara Golemon	0e0ed2aff4	Don't let a dead session leave poll() hanging	2005-03-26 01:26:14 +00:00
Sara Golemon	7c64e21df6	Bump for release	2005-03-23 00:30:05 +00:00
Sara Golemon	c67bb667aa	Add libssh2_poll()	2005-03-23 00:21:26 +00:00
Sara Golemon	141ac5b856	Add sys/uio.h for FBSD builds and remove old stdio references	2005-03-21 21:26:08 +00:00
Sara Golemon	9f64f34dfe	Swap compression mode preferences, prefer none over zlib by default	2005-03-17 19:20:32 +00:00
Sara Golemon	a1b87a952c	Late news	2005-03-17 19:09:45 +00:00
Sara Golemon	7db9aeecf8	Possible fix for compatability with OpenSSL < 0.9.7	2005-03-02 01:55:51 +00:00
Sara Golemon	99e5547442	strm->next_out doesn't stay == out, only free out	2005-02-28 17:02:39 +00:00
Sara Golemon	ef7496b29a	Update copyright year	2005-02-18 16:32:02 +00:00
Sara Golemon	37c55becdc	Bump for release	2005-02-18 16:19:34 +00:00
Sara Golemon	47b96a9771	Add win32/ files to dist	2005-02-18 16:15:24 +00:00
Sara Golemon	0a9a5ffc22	Genericise win32 build params	2005-02-18 16:13:03 +00:00
Sara Golemon	c6e5188fb4	Add support for MacOSX(Darwin)	2005-02-17 20:41:34 +00:00
Sara Golemon	fe7ea0df58	Add support for hostbased pubkey authentication	2005-02-14 05:51:06 +00:00
Sara Golemon	500169bf97	Acknowledge window adjustments and fix the paren bug I just introduced :)	2005-02-14 03:16:42 +00:00
Sara Golemon	10a0c20eae	Fix extended data identification and make window adjust always be sent	2005-02-14 03:06:35 +00:00
Sara Golemon	2427c1b803	Remove TODO file	2005-02-09 19:26:42 +00:00
Sara Golemon	159120f844	Bump for release	2005-02-09 19:22:34 +00:00
Sara Golemon	fc1563a41d	These aren't meaningful since we don't bring libssh2_config.h in	2005-02-09 18:52:59 +00:00
Sara Golemon	c6bbe0d42f	Added libssh2_session_flag() and LIBSSH2_FLAG_SIGPIPE with hooks	2005-02-03 05:57:43 +00:00
Sara Golemon	a05bf84ecf	Collapse state flags into single bitmask attribute	2005-02-03 05:41:35 +00:00
Sara Golemon	2c5c54e999	Fix zlib compression when internal buffer not empty	2005-02-01 05:37:42 +00:00
Bert Vermeulen	5f2864c0b4	some more info on the tests done	2005-01-25 17:15:51 +00:00
Bert Vermeulen	4675d1242b	Improved error handling	2005-01-25 06:03:16 +00:00
Bert Vermeulen	b59f2ccc1b	Erm... don't know what that was doing here	2005-01-25 05:47:49 +00:00
Bert Vermeulen	b25446d0a5	methods now tests all methods separately, and reports which one goes wrong Corrected Makefile dependency	2005-01-25 05:46:00 +00:00
Bert Vermeulen	064c6cde3a	First checkin of the test suite	2005-01-22 23:11:13 +00:00
Edin Kadribasic	2c5a8480b0	Silence warnings when win32 is already defined. Enable zlib and newer diffie-hellman-group-exchange-sha1 syntax.	2005-01-22 02:29:37 +00:00
Edin Kadribasic	87d61a39e8	Adjust project files to live in /win32	2005-01-22 02:28:22 +00:00
Edin Kadribasic	0e878271db	Add windows build files to ignore list	2005-01-22 01:39:50 +00:00
Edin Kadribasic	bc16411dd3	Correct line endings	2005-01-22 01:34:02 +00:00
Sara Golemon	096ef86627	Avoid segfault when libssh2_session_methods() called too early	2005-01-21 23:30:28 +00:00
Sara Golemon	2b414db02e	BFN	2005-01-20 21:35:24 +00:00
Sara Golemon	5f7470700e	Handle Client-To-Server channel windowing.	2005-01-20 21:33:30 +00:00
Bert Vermeulen	bfc2f5039e	Added a couple of comments to keep my last-error-not-set-o-meter from going off	2005-01-19 16:29:53 +00:00
Sara Golemon	a3735795dd	Can't remember why I did this, banner should always be sent before trying to receive	2005-01-18 19:17:29 +00:00
Sara Golemon	a891971a63	Simplify DSA signing process	2005-01-18 06:31:41 +00:00
Sara Golemon	d4677dba5b	Fix u64int ifdef statement	2005-01-18 06:30:02 +00:00
Sara Golemon	d1ae5a501f	Add MSVC6 build files	2005-01-11 19:10:53 +00:00
Sara Golemon	72c4c38e37	Finish making msvc6 happy	2005-01-11 19:05:47 +00:00