release: updated to hold 1.2.7 info

This makefile compiles already all files fine for static lib, but needs
final touch when I have OpenSSL fully working with shared libs and Watcom.

NEWS

@@ -1,3 +1,30 @@
+libssh2 1.2.7 (August 17, 2010)
+
+This release includes the following changes:
+
+ o Added Watcom makefile
+
+This release includes the following bugfixes:
+
+ o Better handling of invalid key files
+ o inputchecks: make lots of API functions check for NULL pointers
+ o libssh2_session_callback_set: extended the man page
+ o SFTP: limit write() to not produce overly large packets
+ o agent: make libssh2_agent_userauth() work blocking properly
+ o _libssh2_userauth_publickey: reject method names longer than the data
+ o channel_free: ignore problems with channel_close()
+ o typedef: make ssize_t get typedef without LIBSSH2_WIN32
+ o _libssh2_wait_socket: poll needs milliseconds
+ o libssh2_wait_socket: reset error code to "leak" EAGAIN less
+ o Added include for sys/select.h to get fd.set on some platforms
+ o session_free: free more data to avoid memory leaks
+ o openssl: make use of the EVP interface
+ o Fix underscore typo for 64-bit printf format specifiers on Windows
+ o Make libssh2_debug() create a correctly terminated string
+ o userauth_hostbased_fromfile: packet length too short
+ o handshake: Compression enabled at the wrong time
+ o Don't overflow MD5 server hostkey
+
 libssh2 1.2.6 (June 10, 2010)
 
 This release includes the following changes:

RELEASE-NOTES

@@ -1,32 +1,34 @@
-libssh2 1.2.6
+libssh2 1.2.7
 
 This release includes the following changes:
 
- o Added libssh2_sftp_statvfs() and libssh2_sftp_fstatvfs()
+ o Added Watcom makefile
- o Added libssh2_knownhost_checkp()
- o Added libssh2_scp_send64()
 
 This release includes the following bugfixes:
 
- o wait_socket: make c89 compliant and use two fd_sets for select()
+ o Better handling of invalid key files
- o OpenSSL AES-128-CTR detection
+ o inputchecks: make lots of API functions check for NULL pointers
- o proper keyboard-interactive user dialog in the sftp.c example
+ o libssh2_session_callback_set: extended the man page
- o build procedure for VMS
+ o SFTP: limit write() to not produce overly large packets
- o fixed libssh2.dsw to use the generated libssh2.dsp
+ o agent: make libssh2_agent_userauth() work blocking properly
- o several Windows-related build fixes
+ o _libssh2_userauth_publickey: reject method names longer than the data
- o fail to init SFTP if session isn't already authenticated
+ o channel_free: ignore problems with channel_close()
- o many tiny fixes that address clang-analyzer warnings
+ o typedef: make ssize_t get typedef without LIBSSH2_WIN32
- o sftp_open: deal with short channel_write calls
+ o _libssh2_wait_socket: poll needs milliseconds
- o libssh2_publickey_init: fixed to work better non-blocking
+ o libssh2_wait_socket: reset error code to "leak" EAGAIN less
- o sftp_close_handle: add precation to not access NULL pointer
+ o Added include for sys/select.h to get fd.set on some platforms
- o sftp_readdir: simplified and bugfixed
+ o session_free: free more data to avoid memory leaks
- o channel_write: if data has been sent, don't return EAGAIN
+ o openssl: make use of the EVP interface
+ o Fix underscore typo for 64-bit printf format specifiers on Windows
+ o Make libssh2_debug() create a correctly terminated string
+ o userauth_hostbased_fromfile: packet length too short
+ o handshake: Compression enabled at the wrong time
+ o Don't overflow MD5 server hostkey
 
 This release would not have looked like this without help, code, reports and
 advice from friends like these:
 
- Alexander Lamaison, Guenter Knauf, Dan Fandrich, Grubsky Grigory,
+ Alexander Lamaison, Guenter Knauf, Peter Stuge, Simon Josefsson, Lars Nordin,
- Joey Degges, Jose Baars, Mikhail Gusarov, Peter Stuge, Simon Josefsson,
+ John Little, Daniel Stenberg, TJ Saunders, Tor Arntsen
- Daniel Stenberg
  
         Thanks! (and sorry if I forgot to mention someone)

docs/libssh2_channel_eof.3

@@ -13,6 +13,7 @@ libssh2_channel_eof(LIBSSH2_CHANNEL *channel);
 
 Check if the remote host has sent an EOF status for the selected stream.
 .SH RETURN VALUE
-Returns 1 if the remote host has sent EOF, otherwise 0.
+Returns 1 if the remote host has sent EOF, otherwise 0. Negative on
+failure.
 .SH SEE ALSO
 .BR libssh2_channel_close(3)

docs/libssh2_channel_write.3

@@ -2,12 +2,13 @@
 .\"
 .TH libssh2_channel_write 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
 .SH NAME
-libssh2_channel_write - convenience macro for \fIlibssh2_channel_write_ex(3)\fP calls
+libssh2_channel_write - convenience macro for \fIlibssh2_channel_write_ex(3)\fP
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-libssh2_channel_write(arguments)
+#define libssh2_channel_write(channel, buf, buflen) \\
-
+  libssh2_channel_write_ex((channel), 0, (buf), (buflen))
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_channel_write_ex(3)\fP.

docs/libssh2_channel_write_ex.3

@@ -4,16 +4,12 @@
 .SH NAME
 libssh2_channel_write_ex - write data to a channel stream blocking
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-ssize_t
+ssize_t libssh2_channel_write_ex(LIBSSH2_CHANNEL *channel,
-libssh2_channel_write_ex(LIBSSH2_CHANNEL *channel, int stream_id, char *buf, size_t buflen);
+                                 int stream_id, char *buf,
-
+                                 size_t buflen);
-ssize_t
-libssh2_channel_write(LIBSSH2_CHANNEL *channel, char *buf, size_t buflen);
-
-ssize_t
-libssh2_channel_write_stderr(LIBSSH2_CHANNEL *channel, char *buf, size_t buflen);
 .SH DESCRIPTION
 Write data to a channel stream. All channel streams have one standard I/O
 substream (stream_id == 0), and may have up to 2^32 extended data streams as
@@ -29,7 +25,12 @@ defines a stream ID of 1 to be the stderr substream.
 \fIbuflen\fP - size of the data to write
 
 \fIlibssh2_channel_write(3)\fP and \fIlibssh2_channel_write_stderr(3)\fP are
-macros.
+convenience macros for this function.
+
+\fIlibssh2_channel_write_ex(3)\fP will use as much as possible of the buffer
+and put it into a single SSH protocol packet. This means that to get maximum
+performance when sending larger files, you should try to always pass in at
+least 32K of data to this function.
 .SH RETURN VALUE
 Actual number of bytes written or negative on failure.
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While

docs/libssh2_channel_write_stderr.3

@@ -2,12 +2,13 @@
 .\"
 .TH libssh2_channel_write_stderr 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
 .SH NAME
-libssh2_channel_write_stderr - convenience macro for \fIlibssh2_channel_write_ex(3)\fP calls
+libssh2_channel_write_stderr - convenience macro for \fIlibssh2_channel_write_ex(3)\fP
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-libssh2_channel_write_stderr(arguments)
+#define libssh2_channel_write_stderr(channel, buf, buflen)  \\
-
+  libssh2_channel_write_ex((channel), SSH_EXTENDED_DATA_STDERR, (buf), (buflen))
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_channel_write_ex(3)\fP.

docs/libssh2_session_callback_set.3

@@ -4,12 +4,16 @@
 .SH NAME
 libssh2_session_callback_set - set a callback function
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-void *
+void *libssh2_session_callback_set(LIBSSH2_SESSION *session,
-libssh2_session_callback_set(LIBSSH2_SESSION *session, int cbtype, void *callback);
+                                   int cbtype, void *callback);
-
 .SH DESCRIPTION
+Sets a custom callback handler for a previously initialized session
+object. Callbacks are triggered by the receipt of special packets at the
+Transport layer. To disable a callback, set it to NULL.
+
 \fIsession\fP - Session instance as returned by 
 .BR libssh2_session_init_ex(3)
 
@@ -17,14 +21,19 @@ libssh2_session_callback_set(LIBSSH2_SESSION *session, int cbtype, void *callbac
 
 \fIcallback\fP - Pointer to custom callback function. The prototype for 
 this function must match the associated callback declaration macro.
-
+.SH CALLBACK TYPES
-Sets a custom callback handler for a previously initialized session 
+.IP LIBSSH2_CALLBACK_IGNORE
-object. Callbacks are triggered by the receipt of special packets at 
+Called when a SSH_MSG_IGNORE message is received
-the Transport layer. To disable a callback, set it to NULL.
+.IP LIBSSH2_CALLBACK_DEBUG
-
+Called when a SSH_MSG_DEBUG message is received
+.IP LIBSSH2_CALLBACK_DISCONNECT
+Called when a SSH_MSG_DISCONNECT message is received
+.IP LIBSSH2_CALLBACK_MACERROR
+Called when a mismatched MAC has been detected in the transport layer
+.IP LIBSSH2_CALLBACK_X11
+Called when an X11 connection has been accepted
 .SH RETURN VALUE
-Pointer to previous callback handler. Returns NULL if no 
+Pointer to previous callback handler. Returns NULL if no prior callback
-prior callback handler was set.
+handler was set or the callback type was unknown.
-
 .SH SEE ALSO
 .BR libssh2_session_init_ex(3)

docs/libssh2_sftp_readlink.3

@@ -2,12 +2,14 @@
 .\"
 .TH libssh2_sftp_readlink 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
 .SH NAME
-libssh2_sftp_readlink - convenience macro for \fIlibssh2_sftp_symlink_ex(3)\fP calls
+libssh2_sftp_readlink - convenience macro for \fIlibssh2_sftp_symlink_ex(3)\fP
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-libssh2_sftp_readlink(arguments)
+#define libssh2_sftp_readlink(sftp, path, target, maxlen) \\
-
+    libssh2_sftp_symlink_ex((sftp), (path), strlen(path), (target), (maxlen), \\
+    LIBSSH2_SFTP_READLINK)
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_symlink_ex(3)\fP.

docs/libssh2_sftp_realpath.3

@@ -2,12 +2,14 @@
 .\"
 .TH libssh2_sftp_realpath 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
 .SH NAME
-libssh2_sftp_realpath - convenience macro for \fIlibssh2_sftp_symlink_ex(3)\fP calls
+libssh2_sftp_realpath - convenience macro for \fIlibssh2_sftp_symlink_ex(3)\fP
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-libssh2_sftp_realpath(arguments)
+#define libssh2_sftp_realpath(sftp, path, target, maxlen) \\
-
+  libssh2_sftp_symlink_ex((sftp), (path), strlen(path), (target), (maxlen), \\
+                          LIBSSH2_SFTP_REALPATH)
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_symlink_ex(3)\fP.

docs/libssh2_sftp_rmdir.3

@@ -2,12 +2,13 @@
 .\"
 .TH libssh2_sftp_rmdir 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
 .SH NAME
-libssh2_sftp_rmdir - convenience macro for \fIlibssh2_sftp_rmdir_ex(3)\fP calls
+libssh2_sftp_rmdir - convenience macro for \fIlibssh2_sftp_rmdir_ex(3)\fP
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-libssh2_sftp_rmdir(arguments)
+#define libssh2_sftp_rmdir(sftp, path) \\
-
+    libssh2_sftp_rmdir_ex((sftp), (path), strlen(path))
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_rmdir_ex(3)\fP.

docs/libssh2_sftp_rmdir_ex.3

@@ -4,30 +4,26 @@
 .SH NAME
 libssh2_sftp_rmdir_ex - remove an SFTP directory
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-int 
+int libssh2_sftp_rmdir_ex(LIBSSH2_SFTP *sftp, const char *path,
-libssh2_sftp_rmdir_ex(LIBSSH2_SFTP *sftp, const char *path, unsigned int path_len);
+                          unsigned int path_len);
-
-int 
-libssh2_sftp_rmdir_ex(LIBSSH2_SFTP *sftp, const char *path);
-
 .SH DESCRIPTION
+Remove a directory from the remote file system.
+
 \fIsftp\fP - SFTP instance as returned by 
 .BR libssh2_sftp_init(3)
 
 \fIsourcefile\fP - Full path of the existing directory to remove.
 
-\fIsourcefile_len\fP - Length of the full path of the existing directory to remove. 
+\fIsourcefile_len\fP - Length of the full path of the existing directory to
-
+remove.
-Remove a directory from the remote file system.
-
 .SH RETURN VALUE
 Return 0 on success or negative on failure.  It returns
 LIBSSH2_ERROR_EAGAIN when it would otherwise block. While
 LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
-
 .SH ERRORS
 \fILIBSSH2_ERROR_ALLOC\fP -  An internal memory allocation call failed.
 
@@ -38,6 +34,5 @@ LIBSSH2_ERROR_EAGAIN is a negative number, it isn't really a failure per se.
 \fILIBSSH2_ERROR_SFTP_PROTOCOL\fP - An invalid SFTP protocol response was 
 received on the socket, or an SFTP operation caused an errorcode to 
 be returned by the server.
-
 .SH SEE ALSO
 .BR libssh2_sftp_init(3)

docs/libssh2_sftp_symlink.3

@@ -2,12 +2,14 @@
 .\"
 .TH libssh2_sftp_symlink 3 "20 Feb 2010" "libssh2 1.2.4" "libssh2 manual"
 .SH NAME
-libssh2_sftp_symlink - convenience macro for \fIlibssh2_sftp_symlink_ex(3)\fP calls
+libssh2_sftp_symlink - convenience macro for \fIlibssh2_sftp_symlink_ex(3)\fP
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 
-libssh2_sftp_symlink(arguments)
+#define libssh2_sftp_symlink(sftp, orig, linkpath) \\
-
+    libssh2_sftp_symlink_ex((sftp), (orig), strlen(orig), (linkpath), \\
+                            strlen(linkpath), LIBSSH2_SFTP_SYMLINK)
 .SH DESCRIPTION
 This is a macro defined in a public libssh2 header file that is using the
 underlying function \fIlibssh2_sftp_symlink_ex(3)\fP.

docs/libssh2_sftp_symlink_ex.3

@@ -12,14 +12,6 @@ int
 libssh2_sftp_symlink_ex(LIBSSH2_SFTP *sftp, const char *path,
                         unsigned int path_len, char *target,
                         unsigned int target_len, int link_type);
-
-int 
-libssh2_sftp_symlink(LIBSSH2_SFTP *sftp, const char *path, char *target);
-
-int 
-libssh2_sftp_readlink(LIBSSH2_SFTP *sftp, const char *path, char *target,
-                      unsigned int target_len);
-
 int 
 libssh2_sftp_realpath(LIBSSH2_SFTP *sftp, const char *path, char *target,
                       unsigned int target_len);

docs/libssh2_sftp_write.3

@@ -4,23 +4,29 @@
 .SH NAME
 libssh2_sftp_write - write SFTP data
 .SH SYNOPSIS
+.nf
 #include <libssh2.h>
 #include <libssh2_sftp.h>
 
-ssize_t 
+ssize_t libssh2_sftp_write(LIBSSH2_SFTP_HANDLE *handle,
-libssh2_sftp_write(LIBSSH2_SFTP_HANDLE *handle, const char *buffer, size_t count);
+                           const char *buffer,
-
+                           size_t count);
 .SH DESCRIPTION
+\fBlibssh2_sftp_write(3)\fP writes a block of data to the SFTP server. This
+method is modeled after the POSIX write() function and uses the same calling
+semantics.
+
 \fIhandle\fP - SFTP file handle as returned by \fIlibssh2_sftp_open_ex(3)\fP.
 
-\fIbuffer\fP - points to the data to send off
+\fIbuffer\fP - points to the data to send off.
 
 \fIcount\fP - Number of bytes from 'buffer' to write. Note that it may not be
 possible to write all bytes as requested.
 
-\fBlibssh2_sftp_write(3)\fP writes a block of data to the SFTP server. This
+\fIlibssh2_sftp_handle(3)\fP will use as much as possible of the buffer and
-method is modeled after the POSIX write() function and uses the same calling
+put it into a single SFTP protocol packet. This means that to get maximum
-semantics.
+performance when sending larger files, you should try to always pass in at
+least 32K of data to this function.
 .SH RETURN VALUE
 Actual number of bytes written or negative on failure.
 

example/scp.c

@@ -151,10 +151,10 @@ int main(int argc, char *argv[])
         }
 
         rc = libssh2_channel_read(channel, mem, amount);
-        if(rc == amount) {
+        if(rc > 0) {
             write(1, mem, rc);
         }
-        else {
+        else if(rc < 0) {
             fprintf(stderr, "libssh2_channel_read() failed: %d\n", rc);
             break;
         }

example/scp_write_nonblock.c

@@ -32,6 +32,7 @@
 #include <errno.h>
 #include <stdio.h>
 #include <ctype.h>
+#include <time.h>
 
 int main(int argc, char *argv[])
 {
@@ -50,10 +51,13 @@ int main(int argc, char *argv[])
 #if defined(HAVE_IOCTLSOCKET)
     long flag = 1;
 #endif
-    char mem[1024];
+    char mem[1024*100];
     size_t nread;
     char *ptr;
     struct stat fileinfo;
+    time_t start;
+    long total = 0;
+    int duration;
 
 #ifdef WIN32
     WSADATA wsadata;
@@ -175,6 +179,7 @@ int main(int argc, char *argv[])
     } while (!channel);
 
     fprintf(stderr, "SCP session waiting to send file\n");
+    start = time(NULL);
     do {
         nread = fread(mem, 1, sizeof(mem), local);
         if (nread <= 0) {
@@ -183,6 +188,8 @@ int main(int argc, char *argv[])
         }
         ptr = mem;
 
+        total += nread;
+
         do {
             /* write the same data over and over, until error or completion */
             rc = libssh2_channel_write(channel, ptr, nread);
@@ -199,6 +206,11 @@ int main(int argc, char *argv[])
         } while (nread);
     } while (!nread); /* only continue if nread was drained */
 
+    duration = (int)(time(NULL)-start);
+
+    printf("%ld bytes in %d seconds makes %.1f bytes/sec\n",
+           total, duration, total/(double)duration);
+
     fprintf(stderr, "Sending EOF\n");
     while (libssh2_channel_send_eof(channel) == LIBSSH2_ERROR_EAGAIN);
 

example/sftp_write_nonblock.c

@@ -22,6 +22,9 @@
 #ifdef HAVE_NETINET_IN_H
 # include <netinet/in.h>
 #endif
+#ifdef HAVE_SYS_SELECT_H
+# include <sys/select.h>
+#endif
 # ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
@@ -34,6 +37,37 @@
 #include <errno.h>
 #include <stdio.h>
 #include <ctype.h>
+#include <time.h>
+
+static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
+{
+    struct timeval timeout;
+    int rc;
+    fd_set fd;
+    fd_set *writefd = NULL;
+    fd_set *readfd = NULL;
+    int dir;
+
+    timeout.tv_sec = 10;
+    timeout.tv_usec = 0;
+
+    FD_ZERO(&fd);
+
+    FD_SET(socket_fd, &fd);
+
+    /* now make sure we wait in the correct direction */
+    dir = libssh2_session_block_directions(session);
+
+    if(dir & LIBSSH2_SESSION_BLOCK_INBOUND)
+        readfd = &fd;
+
+    if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
+        writefd = &fd;
+
+    rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
+
+    return rc;
+}
 
 int main(int argc, char *argv[])
 {
@@ -53,9 +87,12 @@ int main(int argc, char *argv[])
     FILE *local;
     LIBSSH2_SFTP *sftp_session;
     LIBSSH2_SFTP_HANDLE *sftp_handle;
-    char mem[1024];
+    char mem[1024 * 100];
     size_t nread;
     char *ptr;
+    time_t start;
+    long total = 0;
+    int duration;
 
 #ifdef WIN32
     WSADATA wsadata;
@@ -142,17 +179,19 @@ int main(int argc, char *argv[])
 
     if (auth_pw) {
         /* We could authenticate via password */
-        while ((rc = libssh2_userauth_password(session, username, password)) == LIBSSH2_ERROR_EAGAIN);
+        while ((rc = libssh2_userauth_password(session, username, password)) ==
-    if (rc) {
+               LIBSSH2_ERROR_EAGAIN);
+        if (rc) {
             printf("Authentication by password failed.\n");
             goto shutdown;
         }
     } else {
         /* Or by public key */
         while ((rc = libssh2_userauth_publickey_fromfile(session, username,
-                                                "/home/username/.ssh/id_rsa.pub",
+                                                         "/home/username/.ssh/id_rsa.pub",
-                                                "/home/username/.ssh/id_rsa",
+                                                         "/home/username/.ssh/id_rsa",
-                                                password)) == LIBSSH2_ERROR_EAGAIN);
+                                                         password)) ==
+               LIBSSH2_ERROR_EAGAIN);
     if (rc) {
             printf("\tAuthentication by public key failed\n");
             goto shutdown;
@@ -163,7 +202,8 @@ int main(int argc, char *argv[])
     do {
         sftp_session = libssh2_sftp_init(session);
 
-        if ((!sftp_session) && (libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN)) {
+        if (!sftp_session &&
+            (libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN)) {
             fprintf(stderr, "Unable to init SFTP session\n");
             goto shutdown;
         }
@@ -178,13 +218,17 @@ int main(int argc, char *argv[])
                           LIBSSH2_SFTP_S_IRUSR|LIBSSH2_SFTP_S_IWUSR|
                           LIBSSH2_SFTP_S_IRGRP|LIBSSH2_SFTP_S_IROTH);
 
-        if ((!sftp_handle) && (libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN)) {
+        if (!sftp_handle &&
+            (libssh2_session_last_errno(session) != LIBSSH2_ERROR_EAGAIN)) {
             fprintf(stderr, "Unable to open file with SFTP\n");
             goto shutdown;
         }
     } while (!sftp_handle);
 
     fprintf(stderr, "libssh2_sftp_open() is done, now send data!\n");
+
+    start = time(NULL);
+
     do {
         nread = fread(mem, 1, sizeof(mem), local);
         if (nread <= 0) {
@@ -193,16 +237,28 @@ int main(int argc, char *argv[])
         }
         ptr = mem;
 
+        total += nread;
+
         do {
             /* write data in a loop until we block */
-            while ((rc = libssh2_sftp_write(sftp_handle, ptr, nread)) == LIBSSH2_ERROR_EAGAIN) {
+            while ((rc = libssh2_sftp_write(sftp_handle, ptr, nread)) ==
-                ;
+                   LIBSSH2_ERROR_EAGAIN) {
+                waitsocket(sock, session);
             }
+            if(rc < 0)
+                break;
             ptr += rc;
             nread -= rc;
+
         } while (nread);
     } while (rc > 0);
 
+    duration = (int)(time(NULL)-start);
+
+    printf("%ld bytes in %d seconds makes %.1f bytes/sec\n",
+           total, duration, total/(double)duration);
+
+
     fclose(local);
     libssh2_sftp_close(sftp_handle);
     libssh2_sftp_shutdown(sftp_session);

get_ver.awk

@@ -1,7 +1,10 @@
 # fetch libssh2 version number from input file and write them to STDOUT
 BEGIN {
   while ((getline < ARGV[1]) > 0) {
-    if (match ($0, /^#define LIBSSH2_VERSION[ |\t]+"[^"]+"/)) {
+    if (match ($0, /^#define LIBSSH2_COPYRIGHT "[^"]+"$/)) {
+      my_copyright_str = substr($0, 28, length($0)-28);
+    }
+    else if (match ($0, /^#define LIBSSH2_VERSION[ |\t]+"[^"]+"/)) {
       my_ver_str = substr($3, 2, length($3) - 2);
       split(my_ver_str, v, ".");
       if (v[3])
@@ -17,4 +20,5 @@ BEGIN {
   }
   print "LIBSSH2_VERSION = " my_ver "";
   print "LIBSSH2_VERSION_STR = " my_ver_str "";
+  print "LIBSSH2_COPYRIGHT_STR = " my_copyright_str "";
 }

include/libssh2.h

@@ -40,6 +40,50 @@
 #ifndef LIBSSH2_H
 #define LIBSSH2_H 1
 
+#define LIBSSH2_COPYRIGHT "2004-2010 The libssh2 project and its contributors."
+
+/* We use underscore instead of dash when appending DEV in dev versions just
+   to make the BANNER define (used by src/session.c) be a valid SSH
+   banner. Release versions have no appended strings and may of course not
+   have dashes either. */
+#define LIBSSH2_VERSION                             "1.2.7_DEV"
+
+/* The numeric version number is also available "in parts" by using these
+   defines: */
+#define LIBSSH2_VERSION_MAJOR                       1
+#define LIBSSH2_VERSION_MINOR                       2
+#define LIBSSH2_VERSION_PATCH                       7
+
+/* This is the numeric version of the libssh2 version number, meant for easier
+   parsing and comparions by programs. The LIBSSH2_VERSION_NUM define will
+   always follow this syntax:
+
+         0xXXYYZZ
+
+   Where XX, YY and ZZ are the main version, release and patch numbers in
+   hexadecimal (using 8 bits each). All three numbers are always represented
+   using two digits.  1.2 would appear as "0x010200" while version 9.11.7
+   appears as "0x090b07".
+
+   This 6-digit (24 bits) hexadecimal number does not show pre-release number,
+   and it is always a greater number in a more recent release. It makes
+   comparisons with greater than and less than work.
+*/
+#define LIBSSH2_VERSION_NUM                         0x010207
+
+/*
+ * This is the date and time when the full source package was created. The
+ * timestamp is not stored in the source code repo, as the timestamp is
+ * properly set in the tarballs by the maketgz script.
+ *
+ * The format of the date should follow this template:
+ *
+ * "Mon Feb 12 11:35:33 UTC 2007"
+ */
+#define LIBSSH2_TIMESTAMP "DEV"
+
+#ifndef LIBSSH2_VERSION_ONLY
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -73,7 +117,7 @@ typedef unsigned char uint8_t;
 typedef unsigned int uint32_t;
 #endif
 
-#if defined(LIBSSH2_WIN32) && defined(_MSC_VER)
+#ifdef _MSC_VER
 typedef unsigned char uint8_t;
 typedef unsigned int uint32_t;
 typedef unsigned __int64 libssh2_uint64_t;
@@ -87,46 +131,6 @@ typedef unsigned long long libssh2_uint64_t;
 typedef long long libssh2_int64_t;
 #endif
 
-/* We use underscore instead of dash when appending DEV in dev versions just
-   to make the BANNER define (used by src/session.c) be a valid SSH
-   banner. Release versions have no appended strings and may of course not
-   have dashes either. */
-#define LIBSSH2_VERSION                             "1.2.6_DEV"
-
-/* The numeric version number is also available "in parts" by using these
-   defines: */
-#define LIBSSH2_VERSION_MAJOR                       1
-#define LIBSSH2_VERSION_MINOR                       2
-#define LIBSSH2_VERSION_PATCH                       6
-
-/* This is the numeric version of the libssh2 version number, meant for easier
-   parsing and comparions by programs. The LIBSSH2_VERSION_NUM define will
-   always follow this syntax:
-
-         0xXXYYZZ
-
-   Where XX, YY and ZZ are the main version, release and patch numbers in
-   hexadecimal (using 8 bits each). All three numbers are always represented
-   using two digits.  1.2 would appear as "0x010200" while version 9.11.7
-   appears as "0x090b07".
-
-   This 6-digit (24 bits) hexadecimal number does not show pre-release number,
-   and it is always a greater number in a more recent release. It makes
-   comparisons with greater than and less than work.
-*/
-#define LIBSSH2_VERSION_NUM                         0x010206
-
-/*
- * This is the date and time when the full source package was created. The
- * timestamp is not stored in the source code repo, as the timestamp is
- * properly set in the tarballs by the maketgz script.
- *
- * The format of the date should follow this template:
- *
- * "Mon Feb 12 11:35:33 UTC 2007"
- */
-#define LIBSSH2_TIMESTAMP "DEV"
-
 /* Part of every banner, user specified or not */
 #define LIBSSH2_SSH_BANNER                  "SSH-2.0-libssh2_" LIBSSH2_VERSION
 
@@ -1108,4 +1112,6 @@ LIBSSH2_API int libssh2_trace_sethandler(LIBSSH2_SESSION *session,
 } /* extern "C" */
 #endif
 
+#endif /* LIBSSH2_VERSION_ONLY */
+
 #endif /* LIBSSH2_H */

nw/Makefile.netware

@@ -3,9 +3,7 @@
 ## Makefile for building libssh2 (NetWare version - gnu make)
 ## Use: make -f Makefile.netware [help|all|clean|dev|devclean|dist|distclean|lib|nlm|objclean]
 ##
-## Comments to: Guenter Knauf <eflash@gmx.net>
+## Comments to: Guenter Knauf http://www.gknw.net/phpbb
-##
-## $Id: Makefile.netware,v 1.14 2009/04/09 03:13:51 gknauf Exp $
 #
 #########################################################################
 
@@ -21,7 +19,7 @@ endif
 
 # Edit the path below to point to the base of your OpenSSL package.
 ifndef OPENSSL_PATH
-OPENSSL_PATH = ../../openssl-0.9.8n
+OPENSSL_PATH = ../../openssl-0.9.8o
 endif
 
 # Edit the path below to point to your Distribution folder.
@@ -39,7 +37,7 @@ DEVLARC	= $(DEVLDIR).zip
 # Edit the vars below to change NLM target settings.
 TARGET	= libssh2
 VERSION	= $(LIBSSH2_VERSION)
-COPYR	= Copyright (c) 2004-2010 The libssh2 project and its contributors.
+COPYR	= Copyright (c) $(LIBSSH2_COPYRIGHT_STR)
 WWWURL	= http://www.libssh2.org/
 DESCR	= libssh2 $(LIBSSH2_VERSION_STR) ($(LIBARCH)) - $(WWWURL)
 MTSAFE	= YES
@@ -81,9 +79,9 @@ endif
 CP	= cp -afv
 # RM	= rm -f
 # Here you can find a native Win32 binary of the original awk:
-# http://www.gknw.net/development/prgtools/awk.zip
+# http://www.gknw.net/development/prgtools/awk-20070501.zip
 AWK	= awk
-# if you want to mark the target as MTSAFE you will need a tool for
+# If you want to mark the target as MTSAFE you will need a tool for
 # generating the xdc data for the linker; here's a minimal tool:
 # http://www.gknw.net/development/prgtools/mkxdc.zip
 MPKXDC	= mkxdc
@@ -507,6 +505,7 @@ endif
 	@echo $(DL)  libssh2_channel_write_ex,$(DL) >> $@
 	@echo $(DL)  libssh2_hostkey_hash,$(DL) >> $@
 	@echo $(DL)  libssh2_scp_recv,$(DL) >> $@
+	@echo $(DL)  libssh2_scp_send64,$(DL) >> $@
 	@echo $(DL)  libssh2_scp_send_ex,$(DL) >> $@
 	@echo $(DL)  libssh2_knownhost_add,$(DL) >> $@
 	@echo $(DL)  libssh2_knownhost_check,$(DL) >> $@

nw/test/Makefile.netware

@@ -3,9 +3,7 @@
 ## Makefile for building libssh2 (NetWare version - gnu make)
 ## Use: make -f Makefile.netware
 ##
-## Comments to: Guenter Knauf <eflash@gmx.net>
+## Comments to: Guenter Knauf http://www.gknw.net/phpbb
-##
-## $Id: Makefile.netware,v 1.10 2009/04/09 03:13:52 gknauf Exp $
 #
 #########################################################################
 
@@ -21,7 +19,7 @@ endif
 
 # Edit the path below to point to the base of your OpenSSL package.
 ifndef OPENSSL_PATH
-OPENSSL_PATH = ../../../openssl-0.9.8n
+OPENSSL_PATH = ../../../openssl-0.9.8o
 endif
 
 # Edit the var below to enable static linking of libssh2 and libz
@@ -75,9 +73,9 @@ endif
 CP	= cp -afv
 # RM	= rm -f
 # Here you can find a native Win32 binary of the original awk:
-# http://www.gknw.net/development/prgtools/awk.zip
+# http://www.gknw.net/development/prgtools/awk-20070501.zip
 AWK	= awk
-# if you want to mark the target as MTSAFE you will need a tool for
+# If you want to mark the target as MTSAFE you will need a tool for
 # generating the xdc data for the linker; here's a minimal tool:
 # http://www.gknw.net/development/prgtools/mkxdc.zip
 MPKXDC	= mkxdc

src/agent.c

@@ -48,6 +48,7 @@
 #undef PF_UNIX
 #endif
 #include "userauth.h"
+#include "session.h"
 
 /* Requests from client to agent for protocol 1 key operations */
 #define SSH_AGENTC_REQUEST_RSA_IDENTITIES 1
@@ -146,23 +147,24 @@ agent_connect_unix(LIBSSH2_AGENT *agent)
     struct sockaddr_un s_un;
 
     path = getenv("SSH_AUTH_SOCK");
-    if (!path) {
+    if (!path)
-        return -1;
+        return _libssh2_error(agent->session, LIBSSH2_ERROR_BAD_USE,
-    }
+                              "no auth sock variable");
 
     agent->fd = socket(PF_UNIX, SOCK_STREAM, 0);
-    if (agent->fd < 0) {
+    if (agent->fd < 0)
-        return -1;
+        return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_NONE,
-    }
+                              "failed creating socket");
 
     s_un.sun_family = AF_UNIX;
     strncpy (s_un.sun_path, path, sizeof s_un.sun_path);
     if (connect(agent->fd, (struct sockaddr*)(&s_un), sizeof s_un) != 0) {
         close (agent->fd);
-        return -1;
+        return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_NONE,
+                              "failed connecting");
     }
 
-    return 0;
+    return LIBSSH2_ERROR_NONE;
 }
 
 static int
@@ -178,7 +180,8 @@ agent_transact_unix(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
         if (rc < 0) {
             if (errno == EAGAIN)
                 return LIBSSH2_ERROR_EAGAIN;
-            return -1;
+            return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_SEND,
+                                  "agent send failed");
         }
         transctx->state = agent_NB_state_request_length_sent;
     }
@@ -190,7 +193,8 @@ agent_transact_unix(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
         if (rc < 0) {
             if (errno == EAGAIN)
                 return LIBSSH2_ERROR_EAGAIN;
-            return -1;
+            return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_SEND,
+                                  "agent send failed");
         }
         transctx->state = agent_NB_state_request_sent;
     }
@@ -201,14 +205,15 @@ agent_transact_unix(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
         if (rc < 0) {
             if (errno == EAGAIN)
                 return LIBSSH2_ERROR_EAGAIN;
-            return -1;
+            return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_NONE,
+                                  "agent recv failed");
         }
         transctx->response_len = _libssh2_ntohu32(buf);
         transctx->response = LIBSSH2_ALLOC(agent->session,
                                            transctx->response_len);
-        if (!transctx->response) {
+        if (!transctx->response)
             return LIBSSH2_ERROR_ALLOC;
-        }
+
         transctx->state = agent_NB_state_response_length_received;
     }
 
@@ -218,7 +223,8 @@ agent_transact_unix(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
         if (rc < 0) {
             if (errno == EAGAIN)
                 return LIBSSH2_ERROR_EAGAIN;
-            return -1;
+            return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_SEND,
+                                  "agent recv failed");
         }
         transctx->state = agent_NB_state_response_received;
     }
@@ -229,7 +235,13 @@ agent_transact_unix(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
 static int
 agent_disconnect_unix(LIBSSH2_AGENT *agent)
 {
-    return close(agent->fd);
+    int ret;
+    ret = close(agent->fd);
+
+    if(ret == -1)
+        return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_DISCONNECT,
+                              "failed closing the agent socket");
+    return LIBSSH2_ERROR_NONE;
 }
 
 struct agent_ops agent_ops_unix = {
@@ -256,9 +268,10 @@ agent_connect_pageant(LIBSSH2_AGENT *agent)
     HWND hwnd;
     hwnd = FindWindow("Pageant", "Pageant");
     if (!hwnd)
-	return -1;
+	return _libssh2_error(agent->session, LIBSSH2_ERROR_SOCKET_NONE,
+                              "failed connecting agent");
     agent->fd = 0;         /* Mark as the connection has been established */
-    return 0;
+    return LIBSSH2_ERROR_NONE;
 }
 
 static int
@@ -272,21 +285,26 @@ agent_transact_pageant(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
     int id;
     COPYDATASTRUCT cds;
 
-    if (!transctx || 4 + transctx->request_len > PAGEANT_MAX_MSGLEN) {
+    if (!transctx || 4 + transctx->request_len > PAGEANT_MAX_MSGLEN)
-        return LIBSSH2_ERROR_INVAL;
+        return _libssh2_error(agent->session, LIBSSH2_ERROR_INVAL,
-    }
+                              "illegal input");
+
     hwnd = FindWindow("Pageant", "Pageant");
-    if (!hwnd) {
+    if (!hwnd)
-	return -1;
+        return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
-    }
+                              "found no pageant");
+
     sprintf(mapname, "PageantRequest%08x", (unsigned)GetCurrentThreadId());
     filemap = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
 				0, PAGEANT_MAX_MSGLEN, mapname);
-    if (filemap == NULL || filemap == INVALID_HANDLE_VALUE) {
+
-	return -1;
+    if (filemap == NULL || filemap == INVALID_HANDLE_VALUE)
-    }
+        return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
+                              "failed setting up pageant filemap");
+
     p2 = p = MapViewOfFile(filemap, FILE_MAP_WRITE, 0, 0, 0);
-    _libssh2_store_str(&p2, transctx->request, transctx->request_len);
+    _libssh2_store_str(&p2, (const char *)transctx->request,
+                       transctx->request_len);
 
     cds.dwData = PAGEANT_COPYDATA_ID;
     cds.cbData = 1 + strlen(mapname);
@@ -298,14 +316,16 @@ agent_transact_pageant(LIBSSH2_AGENT *agent, agent_transaction_ctx_t transctx)
         if (transctx->response_len > PAGEANT_MAX_MSGLEN) {
             UnmapViewOfFile(p);
             CloseHandle(filemap);
-            return LIBSSH2_ERROR_AGENT_PROTOCOL;
+            return _libssh2_error(agent->session, LIBSSH2_ERROR_AGENT_PROTOCOL,
+                                  "agent setup fail");
         }
 	transctx->response = LIBSSH2_ALLOC(agent->session,
                                            transctx->response_len);
 	if (!transctx->response) {
             UnmapViewOfFile(p);
             CloseHandle(filemap);
-            return LIBSSH2_ERROR_ALLOC;
+            return _libssh2_error(agent->session, LIBSSH2_ERROR_ALLOC,
+                                  "agent malloc");
         }
         memcpy(transctx->response, p + 4, transctx->response_len);
     }
@@ -357,9 +377,9 @@ agent_sign(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
     /* Create a request to sign the data */
     if (transctx->state == agent_NB_state_init) {
         s = transctx->request = LIBSSH2_ALLOC(session, len);
-        if (!transctx->request) {
+        if (!transctx->request)
-            return LIBSSH2_ERROR_ALLOC;
+            return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
-        }
+                                  "out of memory");
 
         *s++ = SSH2_AGENTC_SIGN_REQUEST;
         /* key blob */
@@ -376,9 +396,14 @@ agent_sign(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
     }
 
     /* Make sure to be re-called as a result of EAGAIN. */
-    if (*transctx->request != SSH2_AGENTC_SIGN_REQUEST) {
+    if (*transctx->request != SSH2_AGENTC_SIGN_REQUEST)
-        return LIBSSH2_ERROR_BAD_USE;
+        return _libssh2_error(session, LIBSSH2_ERROR_BAD_USE,
-    }
+                              "illegal request");
+
+    if (!agent->ops)
+        /* if no agent has been connected, bail out */
+        return _libssh2_error(session, LIBSSH2_ERROR_BAD_USE,
+                              "agent not connected");
 
     rc = agent->ops->transact(agent, transctx);
     if (rc) {
@@ -451,7 +476,7 @@ agent_sign(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len,
     LIBSSH2_FREE(session, transctx->response);
     transctx->response = NULL;
 
-    return rc;
+    return _libssh2_error(session, rc, "agent sign failure");
 }
 
 static int
@@ -471,9 +496,14 @@ agent_list_identities(LIBSSH2_AGENT *agent)
     }
 
     /* Make sure to be re-called as a result of EAGAIN. */
-    if (*transctx->request != SSH2_AGENTC_REQUEST_IDENTITIES) {
+    if (*transctx->request != SSH2_AGENTC_REQUEST_IDENTITIES)
-        return LIBSSH2_ERROR_BAD_USE;
+        return _libssh2_error(agent->session, LIBSSH2_ERROR_BAD_USE,
-    }
+                              "illegal agent request");
+
+    if (!agent->ops)
+        /* if no agent has been connected, bail out */
+        return _libssh2_error(agent->session, LIBSSH2_ERROR_BAD_USE,
+                              "agent not connected");
 
     rc = agent->ops->transact(agent, transctx);
     if (rc) {
@@ -568,7 +598,8 @@ agent_list_identities(LIBSSH2_AGENT *agent)
     LIBSSH2_FREE(agent->session, transctx->response);
     transctx->response = NULL;
 
-    return rc;
+    return _libssh2_error(agent->session, rc,
+                          "agent list id failed");
 }
 
 static void
@@ -713,17 +744,21 @@ libssh2_agent_userauth(LIBSSH2_AGENT *agent,
                        struct libssh2_agent_publickey *identity)
 {
     void *abstract = agent;
+    int rc;
 
     if (agent->session->userauth_pblc_state == libssh2_NB_state_idle) {
         memset(&agent->transctx, 0, sizeof agent->transctx);
         agent->identity = identity->node;
     }
-    return _libssh2_userauth_publickey(agent->session, username,
+
-                                       strlen(username),
+    BLOCK_ADJUST(rc, agent->session,
-                                       identity->blob,
+                 _libssh2_userauth_publickey(agent->session, username,
-                                       identity->blob_len,
+                                             strlen(username),
-                                       agent_sign,
+                                             identity->blob,
-                                       &abstract);
+                                             identity->blob_len,
+                                             agent_sign,
+                                             &abstract));
+    return rc;
 }
 
 /*

src/channel.c

@@ -329,6 +329,10 @@ libssh2_channel_open_ex(LIBSSH2_SESSION *session, const char *type,
                         const char *msg, unsigned int msg_len)
 {
     LIBSSH2_CHANNEL *ptr;
+
+    if(!session)
+        return NULL;
+
     BLOCK_ADJUST_ERRNO(ptr, session,
                        _libssh2_channel_open(session, type, type_len,
                                              window_size, packet_size,
@@ -402,10 +406,14 @@ channel_direct_tcpip(LIBSSH2_SESSION * session, const char *host,
  * Tunnel TCP/IP connect through the SSH session to direct host/port
  */
 LIBSSH2_API LIBSSH2_CHANNEL *
-libssh2_channel_direct_tcpip_ex(LIBSSH2_SESSION * session, const char *host,
+libssh2_channel_direct_tcpip_ex(LIBSSH2_SESSION *session, const char *host,
                                 int port, const char *shost, int sport)
 {
     LIBSSH2_CHANNEL *ptr;
+
+    if(!session)
+        return NULL;
+
     BLOCK_ADJUST_ERRNO(ptr, session,
                        channel_direct_tcpip(session, host, port, shost, sport));
     return ptr;
@@ -569,6 +577,10 @@ libssh2_channel_forward_listen_ex(LIBSSH2_SESSION *session, const char *host,
                                   int port, int *bound_port, int queue_maxsize)
 {
     LIBSSH2_LISTENER *ptr;
+
+    if(!session)
+        return NULL;
+
     BLOCK_ADJUST_ERRNO(ptr, session,
                        channel_forward_listen(session, host, port, bound_port,
                                               queue_maxsize));
@@ -673,6 +685,10 @@ LIBSSH2_API int
 libssh2_channel_forward_cancel(LIBSSH2_LISTENER *listener)
 {
     int rc;
+
+    if(!listener)
+        return LIBSSH2_ERROR_BAD_USE;
+
     BLOCK_ADJUST(rc, listener->session,
                  _libssh2_channel_forward_cancel(listener));
     return rc;
@@ -725,6 +741,10 @@ LIBSSH2_API LIBSSH2_CHANNEL *
 libssh2_channel_forward_accept(LIBSSH2_LISTENER *listener)
 {
     LIBSSH2_CHANNEL *ptr;
+
+    if(!listener)
+        return NULL;
+
     BLOCK_ADJUST_ERRNO(ptr, listener->session,
                        channel_forward_accept(listener));
     return ptr;
@@ -838,6 +858,10 @@ libssh2_channel_setenv_ex(LIBSSH2_CHANNEL *channel,
                           const char *value, unsigned int value_len)
 {
     int rc;
+
+    if(!channel)
+        return LIBSSH2_ERROR_BAD_USE;
+
     BLOCK_ADJUST(rc, channel->session,
                  channel_setenv(channel, varname, varname_len,
                                 value, value_len));
@@ -955,6 +979,10 @@ libssh2_channel_request_pty_ex(LIBSSH2_CHANNEL *channel, const char *term,
                                int width_px, int height_px)
 {
     int rc;
+
+    if(!channel)
+        return LIBSSH2_ERROR_BAD_USE;
+
     BLOCK_ADJUST(rc, channel->session,
                  channel_request_pty(channel, term, term_len, modes,
                                      modes_len, width, height,
@@ -1031,6 +1059,10 @@ libssh2_channel_request_pty_size_ex(LIBSSH2_CHANNEL *channel, int width,
                                     int height, int width_px, int height_px)
 {
     int rc;
+
+    if(!channel)
+        return LIBSSH2_ERROR_BAD_USE;
+
     BLOCK_ADJUST(rc, channel->session,
                  channel_request_pty_size(channel, width, height, width_px,
                                           height_px));
@@ -1175,6 +1207,10 @@ libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL *channel, int single_connection,
                            int screen_number)
 {
     int rc;
+
+    if(!channel)
+        return LIBSSH2_ERROR_BAD_USE;
+
     BLOCK_ADJUST(rc, channel->session,
                  channel_x11_req(channel, single_connection, auth_proto,
                                  auth_cookie, screen_number));
@@ -1206,21 +1242,19 @@ _libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel,
         memset(&channel->process_packet_requirev_state, 0,
                sizeof(channel->process_packet_requirev_state));
 
-        if (message) {
+        if (message)
             channel->process_packet_len += message_len + 4;
-        }
 
         _libssh2_debug(session, LIBSSH2_TRACE_CONN,
                        "starting request(%s) on channel %lu/%lu, message=%s",
                        request, channel->local.id, channel->remote.id,
-                       message);
+                       message?message:"<null>");
         s = channel->process_packet =
             LIBSSH2_ALLOC(session, channel->process_packet_len);
-        if (!channel->process_packet) {
+        if (!channel->process_packet)
             return _libssh2_error(session, LIBSSH2_ERROR_ALLOC,
                                   "Unable to allocate memory "
                                   "for channel-process request");
-        }
 
         *(s++) = SSH_MSG_CHANNEL_REQUEST;
         _libssh2_store_u32(&s, channel->remote.id);
@@ -1293,6 +1327,10 @@ libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel,
                                 const char *msg, unsigned int msg_len)
 {
     int rc;
+
+    if(!channel)
+        return LIBSSH2_ERROR_BAD_USE;
+
     BLOCK_ADJUST(rc, channel->session,
                  _libssh2_channel_process_startup(channel, req, req_len,
                                                   msg, msg_len));
@@ -1309,7 +1347,8 @@ libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel,
 LIBSSH2_API void
 libssh2_channel_set_blocking(LIBSSH2_CHANNEL * channel, int blocking)
 {
-    (void) _libssh2_session_set_blocking(channel->session, blocking);
+    if(channel)
+        (void) _libssh2_session_set_blocking(channel->session, blocking);
 }
 
 /*
@@ -1394,6 +1433,10 @@ LIBSSH2_API int
 libssh2_channel_flush_ex(LIBSSH2_CHANNEL *channel, int stream)
 {
     int rc;
+
+    if(!channel)
+        return LIBSSH2_ERROR_BAD_USE;
+
     BLOCK_ADJUST(rc, channel->session,
                  _libssh2_channel_flush(channel, stream));
     return rc;
@@ -1402,11 +1445,17 @@ libssh2_channel_flush_ex(LIBSSH2_CHANNEL *channel, int stream)
 /*
  * libssh2_channel_get_exit_status
  *
- * Return the channel's program exit status
+ * Return the channel's program exit status. Note that the actual protocol
+ * provides the full 32bit this function returns.  We cannot abuse it to
+ * return error values in case of errors so we return a zero if channel is
+ * NULL.
  */
 LIBSSH2_API int
-libssh2_channel_get_exit_status(LIBSSH2_CHANNEL * channel)
+libssh2_channel_get_exit_status(LIBSSH2_CHANNEL *channel)
 {
+    if(!channel)
+        return 0;
+
     return channel->exit_status;
 }
 
@@ -1502,6 +1551,10 @@ libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL *channel,
 {
     unsigned int window;
     int rc;
+
+    if(!channel)
+        return LIBSSH2_ERROR_BAD_USE;
+
     BLOCK_ADJUST(rc, channel->session,
                  _libssh2_channel_receive_window_adjust(channel, adj,
                                                         force, &window));
@@ -1529,6 +1582,10 @@ libssh2_channel_receive_window_adjust2(LIBSSH2_CHANNEL *channel,
                                        unsigned int *window)
 {
     int rc;
+
+    if(!channel)
+        return LIBSSH2_ERROR_BAD_USE;
+
     BLOCK_ADJUST(rc, channel->session,
                  _libssh2_channel_receive_window_adjust(channel, adj, force,
                                                         window));
@@ -1571,6 +1628,10 @@ libssh2_channel_handle_extended_data2(LIBSSH2_CHANNEL *channel,
                                       int mode)
 {
     int rc;
+
+    if(!channel)
+        return LIBSSH2_ERROR_BAD_USE;
+
     BLOCK_ADJUST(rc, channel->session, _libssh2_channel_extended_data(channel,
                                                                       mode));
     return rc;
@@ -1776,6 +1837,10 @@ libssh2_channel_read_ex(LIBSSH2_CHANNEL *channel, int stream_id, char *buf,
                         size_t buflen)
 {
     int rc;
+
+    if(!channel)
+        return LIBSSH2_ERROR_BAD_USE;
+
     BLOCK_ADJUST(rc, channel->session,
                  _libssh2_channel_read(channel, stream_id, buf, buflen));
     return rc;
@@ -2000,6 +2065,10 @@ libssh2_channel_write_ex(LIBSSH2_CHANNEL *channel, int stream_id,
                          const char *buf, size_t buflen)
 {
     ssize_t rc;
+
+    if(!channel)
+        return LIBSSH2_ERROR_BAD_USE;
+
     BLOCK_ADJUST(rc, channel->session,
                  _libssh2_channel_write(channel, stream_id, buf, buflen));
     return rc;
@@ -2042,6 +2111,10 @@ LIBSSH2_API int
 libssh2_channel_send_eof(LIBSSH2_CHANNEL *channel)
 {
     int rc;
+
+    if(!channel)
+        return LIBSSH2_ERROR_BAD_USE;
+
     BLOCK_ADJUST(rc, channel->session, channel_send_eof(channel));
     return rc;
 }
@@ -2054,8 +2127,14 @@ libssh2_channel_send_eof(LIBSSH2_CHANNEL *channel)
 LIBSSH2_API int
 libssh2_channel_eof(LIBSSH2_CHANNEL * channel)
 {
-    LIBSSH2_SESSION *session = channel->session;
+    LIBSSH2_SESSION *session;
-    LIBSSH2_PACKET *packet = _libssh2_list_first(&session->packets);
+    LIBSSH2_PACKET *packet;
+
+    if(!channel)
+        return LIBSSH2_ERROR_BAD_USE;
+
+    session = channel->session;
+    packet = _libssh2_list_first(&session->packets);
 
     while (packet) {
         if (((packet->data[0] == SSH_MSG_CHANNEL_DATA)
@@ -2120,6 +2199,10 @@ LIBSSH2_API int
 libssh2_channel_wait_eof(LIBSSH2_CHANNEL *channel)
 {
     int rc;
+
+    if(!channel)
+        return LIBSSH2_ERROR_BAD_USE;
+
     BLOCK_ADJUST(rc, channel->session, channel_wait_eof(channel));
     return rc;
 }
@@ -2202,6 +2285,10 @@ LIBSSH2_API int
 libssh2_channel_close(LIBSSH2_CHANNEL *channel)
 {
     int rc;
+
+    if(!channel)
+        return LIBSSH2_ERROR_BAD_USE;
+
     BLOCK_ADJUST(rc, channel->session, _libssh2_channel_close(channel) );
     return rc;
 }
@@ -2259,6 +2346,10 @@ LIBSSH2_API int
 libssh2_channel_wait_closed(LIBSSH2_CHANNEL *channel)
 {
     int rc;
+
+    if(!channel)
+        return LIBSSH2_ERROR_BAD_USE;
+
     BLOCK_ADJUST(rc, channel->session, channel_wait_closed(channel));
     return rc;
 }
@@ -2296,10 +2387,9 @@ int _libssh2_channel_free(LIBSSH2_CHANNEL *channel)
 
         if(rc == LIBSSH2_ERROR_EAGAIN)
             return rc;
-        else if (rc < 0) {
+
-            channel->free_state = libssh2_NB_state_idle;
+        /* ignore all other errors as they otherwise risk blocking the channel
-            return rc;
+           free from happening */
-        }
     }
 
     channel->free_state = libssh2_NB_state_idle;
@@ -2358,12 +2448,16 @@ int _libssh2_channel_free(LIBSSH2_CHANNEL *channel)
  * Make sure a channel is closed, then remove the channel from the session
  * and free its resource(s)
  *
- * Returns 0 on success, -1 on failure
+ * Returns 0 on success, negative on failure
  */
 LIBSSH2_API int
 libssh2_channel_free(LIBSSH2_CHANNEL *channel)
 {
     int rc;
+
+    if(!channel)
+        return LIBSSH2_ERROR_BAD_USE;
+
     BLOCK_ADJUST(rc, channel->session, _libssh2_channel_free(channel));
     return rc;
 }
@@ -2377,10 +2471,13 @@ libssh2_channel_free(LIBSSH2_CHANNEL *channel)
  * window_size_initial as defined by the channel_open request
  */
 LIBSSH2_API unsigned long
-libssh2_channel_window_read_ex(LIBSSH2_CHANNEL * channel,
+libssh2_channel_window_read_ex(LIBSSH2_CHANNEL *channel,
                                unsigned long *read_avail,
                                unsigned long *window_size_initial)
 {
+    if(!channel)
+        return 0; /* no channel, no window! */
+
     if (window_size_initial) {
         *window_size_initial = channel->remote.window_size_initial;
     }
@@ -2417,9 +2514,12 @@ libssh2_channel_window_read_ex(LIBSSH2_CHANNEL * channel,
  * the channel_open request
  */
 LIBSSH2_API unsigned long
-libssh2_channel_window_write_ex(LIBSSH2_CHANNEL * channel,
+libssh2_channel_window_write_ex(LIBSSH2_CHANNEL *channel,
                                 unsigned long *window_size_initial)
 {
+    if(!channel)
+        return 0; /* no channel, no window! */
+
     if (window_size_initial) {
         /* For locally initiated channels this is very often 0, so it's not
          * *that* useful as information goes */

src/comp.c

@@ -170,6 +170,15 @@ comp_method_zlib_comp(LIBSSH2_SESSION * session,
     int out_maxlen = compress ? (src_len + 4) : (2 * src_len);
     int limiter = 0;
 
+    /* If strm is null, then we have not yet been initialized. */
+    if (strm == NULL) {
+        *dest = (unsigned char *) src;
+        *dest_len = src_len;
+
+        *free_dest = 0;
+        return 0;
+    }
+
     /* In practice they never come smaller than this */
     if (out_maxlen < 25) {
         out_maxlen = 25;

src/kex.c

@@ -600,6 +600,40 @@ static int diffie_hellman_sha1(LIBSSH2_SESSION *session,
         }
         _libssh2_debug(session, LIBSSH2_TRACE_KEX,
                        "Server to Client HMAC Key calculated");
+
+        /* Initialize compression for each direction */
+
+        /* Cleanup any existing compression */
+        if (session->local.comp && session->local.comp->dtor) {
+            session->local.comp->dtor(session, 1,
+                                      &session->local.comp_abstract);
+        }
+
+        if (session->local.comp && session->local.comp->init) {
+            if (session->local.comp->init(session, 1,
+                                          &session->local.comp_abstract)) {
+                ret = LIBSSH2_ERROR_KEX_FAILURE;
+                goto clean_exit;
+            }
+        }
+        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
+                       "Client to Server compression initialized");
+
+        if (session->remote.comp && session->remote.comp->dtor) {
+            session->remote.comp->dtor(session, 0,
+                                       &session->remote.comp_abstract);
+        }
+
+        if (session->remote.comp && session->remote.comp->init) {
+            if (session->remote.comp->init(session, 0,
+                                           &session->remote.comp_abstract)) {
+                ret = LIBSSH2_ERROR_KEX_FAILURE;
+                goto clean_exit;
+            }
+        }
+        _libssh2_debug(session, LIBSSH2_TRACE_KEX,
+                       "Server to Client compression initialized");
+
     }
 
   clean_exit:
@@ -1099,6 +1133,9 @@ static int kexinit(LIBSSH2_SESSION * session)
     } else {
         data = session->kexinit_data;
         data_len = session->kexinit_data_len;
+	/* zap the variables to ensure there is NOT a double free later */
+        session->kexinit_data = NULL;
+        session->kexinit_data_len = 0;
     }
 
     rc = _libssh2_transport_write(session, data, data_len);
@@ -1609,18 +1646,6 @@ static int kex_agree_methods(LIBSSH2_SESSION * session, unsigned char *data,
     _libssh2_debug(session, LIBSSH2_TRACE_KEX, "Agreed on COMP_SC method: %s",
                    session->remote.comp->name);
 
-    /* Initialize compression layer */
-    if (session->local.comp && session->local.comp->init &&
-        session->local.comp->init(session, 1, &session->local.comp_abstract)) {
-        return -1;
-    }
-
-    if (session->remote.comp && session->remote.comp->init &&
-        session->remote.comp->init(session, 0,
-                                   &session->remote.comp_abstract)) {
-        return -1;
-    }
-
     return 0;
 }
 

src/libgcrypt.h

@@ -63,7 +63,7 @@
 #define libssh2_sha1_init(ctx) gcry_md_open (ctx,  GCRY_MD_SHA1, 0);
 #define libssh2_sha1_update(ctx, data, len) gcry_md_write (ctx, data, len)
 #define libssh2_sha1_final(ctx, out) \
-  memcpy (out, gcry_md_read (ctx, 0), 20), gcry_md_close (ctx)
+  memcpy (out, gcry_md_read (ctx, 0), SHA_DIGEST_LENGTH), gcry_md_close (ctx)
 #define libssh2_sha1(message, len, out) \
   gcry_md_hash_buffer (GCRY_MD_SHA1, out, message, len)
 
@@ -71,7 +71,7 @@
 #define libssh2_md5_init(ctx) gcry_md_open (ctx,  GCRY_MD_MD5, 0);
 #define libssh2_md5_update(ctx, data, len) gcry_md_write (ctx, data, len)
 #define libssh2_md5_final(ctx, out) \
-  memcpy (out, gcry_md_read (ctx, 0), 20), gcry_md_close (ctx)
+  memcpy (out, gcry_md_read (ctx, 0), MD5_DIGEST_LENGTH), gcry_md_close (ctx)
 #define libssh2_md5(message, len, out) \
   gcry_md_hash_buffer (GCRY_MD_MD5, out, message, len)
 

src/libssh2_priv.h

@@ -172,9 +172,9 @@ typedef int libssh2_socket_t;
  session->ssh_msg_ignore((session), (data), (datalen), &(session)->abstract)
 #define LIBSSH2_DEBUG(session, always_display, message, message_len, \
                       language, language_len)    \
-    session->ssh_msg_disconnect((session), (always_display), (message), \
+    session->ssh_msg_debug((session), (always_display), (message), \
-                                (message_len), (language), (language_len), \
+                           (message_len), (language), (language_len), \
-                                &(session)->abstract)
+                           &(session)->abstract)
 #define LIBSSH2_DISCONNECT(session, reason, message, message_len, language, language_len)   \
                 session->ssh_msg_disconnect((session), (reason), (message), (message_len), (language), (language_len), &(session)->abstract)
 
@@ -583,7 +583,7 @@ struct _LIBSSH2_SFTP
     /* a list of _LIBSSH2_SFTP_HANDLE structs */
     struct list_head sftp_handles;
 
-    unsigned long last_errno;
+    uint32_t last_errno;
 
     /* Holder for partial packet, use in libssh2_sftp_packet_read() */
     unsigned char *partial_packet;      /* The data                */
@@ -1149,4 +1149,11 @@ void _libssh2_init_if_needed (void);
 
 #define ARRAY_SIZE(a) (sizeof ((a)) / sizeof ((a)[0]))
 
+/* define to output the libssh2_int64_t type in a *printf() */
+#if defined( __BORLANDC__ ) || defined( _MSC_VER ) || defined( __MINGW32__ )
+#define LIBSSH2_INT64_T_FORMAT "I64"
+#else
+#define LIBSSH2_INT64_T_FORMAT "ll"
+#endif
+
 #endif /* LIBSSH2_H */

src/misc.c

@@ -47,6 +47,7 @@
 #include <sys/time.h>
 #endif
 
+#include <stdio.h>
 #include <errno.h>
 
 int _libssh2_error(LIBSSH2_SESSION* session, int errcode, const char* errmsg)
@@ -114,7 +115,8 @@ _libssh2_recv(libssh2_socket_t socket, void *buffer, size_t length, int flags)
  * to set errno
  */
 ssize_t
-_libssh2_send(libssh2_socket_t socket, const void *buffer, size_t length, int flags)
+_libssh2_send(libssh2_socket_t socket, const void *buffer, size_t length,
+              int flags)
 {
     ssize_t rc = send(socket, buffer, length, flags);
 #ifdef WIN32
@@ -259,8 +261,7 @@ libssh2_base64_decode(LIBSSH2_SESSION *session, char **data,
         /* Invalid -- We have a byte which belongs exclusively to a partial
            octet */
         LIBSSH2_FREE(session, *data);
-        return _libssh2_error(session, LIBSSH2_ERROR_INVAL,
+        return _libssh2_error(session, LIBSSH2_ERROR_INVAL, "Invalid base64");
-                              "Invalid data (byte belonging to partial octet)");
     }
 
     *datalen = len;
@@ -356,7 +357,8 @@ libssh2_trace(LIBSSH2_SESSION * session, int bitmask)
 }
 
 LIBSSH2_API int
-libssh2_trace_sethandler(LIBSSH2_SESSION *session, void* handler_context, libssh2_trace_handler_func callback)
+libssh2_trace_sethandler(LIBSSH2_SESSION *session, void* handler_context,
+                         libssh2_trace_handler_func callback)
 {
     session->tracehandler = callback;
     session->tracehandler_context = handler_context;
@@ -367,7 +369,7 @@ void
 _libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, ...)
 {
     char buffer[1536];
-    int len;
+    int len, msglen, buflen = sizeof(buffer);
     va_list vargs;
     struct timeval now;
     static int firstsec;
@@ -392,7 +394,8 @@ _libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, ...)
     }
 
     /* Find the first matching context string for this message */
-    for (contextindex = 0; contextindex < ARRAY_SIZE(contexts); contextindex++) {
+    for (contextindex = 0; contextindex < ARRAY_SIZE(contexts);
+         contextindex++) {
         if ((context & (1 << contextindex)) != 0) {
             contexttext = contexts[contextindex];
             break;
@@ -405,19 +408,25 @@ _libssh2_debug(LIBSSH2_SESSION * session, int context, const char *format, ...)
     }
     now.tv_sec -= firstsec;
 
-    len = snprintf(buffer, sizeof(buffer), "[libssh2] %d.%06d %s: ",
+    len = snprintf(buffer, buflen, "[libssh2] %d.%06d %s: ",
                    (int)now.tv_sec, (int)now.tv_usec, contexttext);
 
-    va_start(vargs, format);
+    if (len >= buflen)
-    len += vsnprintf(buffer + len, 1535 - len, format, vargs);
+        msglen = buflen - 1;
-    buffer[len] = '\n';
+    else {
-    va_end(vargs);
+        buflen -= len;
-
+        msglen = len;
-    if (session->tracehandler) {
+        va_start(vargs, format);
-        (session->tracehandler)(session, session->tracehandler_context, buffer, len + 1);
+        len = vsnprintf(buffer + msglen, buflen, format, vargs);
-    } else {
+        va_end(vargs);
-        write(2, buffer, len + 1);
+        msglen += len < buflen ? len : buflen - 1;
     }
+
+    if (session->tracehandler)
+        (session->tracehandler)(session, session->tracehandler_context, buffer,
+                                msglen);
+    else
+        fprintf(stderr, "%s\n", buffer);
 }
 
 #else
@@ -430,7 +439,8 @@ libssh2_trace(LIBSSH2_SESSION * session, int bitmask)
 }
 
 LIBSSH2_API int
-libssh2_trace_sethandler(LIBSSH2_SESSION *session, void* handler_context, libssh2_trace_handler_func callback)
+libssh2_trace_sethandler(LIBSSH2_SESSION *session, void* handler_context,
+                         libssh2_trace_handler_func callback)
 {
     (void) session;
     (void) handler_context;

src/openssl.c

@@ -204,10 +204,12 @@ _libssh2_cipher_crypt(_libssh2_cipher_ctx * ctx,
 #if LIBSSH2_AES_CTR && !defined(HAVE_EVP_AES_128_CTR)
 
 #include <openssl/aes.h>
+#include <openssl/evp.h>
 
 typedef struct
 {
     AES_KEY       key;
+    EVP_CIPHER_CTX *aes_ctx;
     unsigned char ctr[AES_BLOCK_SIZE];
 } aes_ctr_ctx;
 
@@ -216,12 +218,35 @@ aes_ctr_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 	     const unsigned char *iv, int enc) /* init key */
 {
     aes_ctr_ctx *c = malloc(sizeof(*c));
+    const EVP_CIPHER *aes_cipher;
     (void) enc;
 
     if (c == NULL)
 	return 0;
 
-    AES_set_encrypt_key(key, 8 * ctx->key_len, &c->key);
+    switch (ctx->key_len) {
+        case 16:
+            aes_cipher = EVP_aes_128_ecb();
+            break;
+        case 24:
+            aes_cipher = EVP_aes_192_ecb();
+            break;
+        case 32:
+            aes_cipher = EVP_aes_256_ecb();
+            break;
+        default:
+            return 0;
+    }
+    c->aes_ctx = malloc(sizeof(EVP_CIPHER_CTX));
+    if (c->aes_ctx == NULL)
+	return 0;
+
+    if (EVP_EncryptInit(c->aes_ctx, aes_cipher, key, NULL) != 1) {
+        return 0;
+    }
+
+    EVP_CIPHER_CTX_set_padding(c->aes_ctx, 0);
+
     memcpy(c->ctr, iv, AES_BLOCK_SIZE);
 
     EVP_CIPHER_CTX_set_app_data(ctx, c);
@@ -236,11 +261,16 @@ aes_ctr_do_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 {
     aes_ctr_ctx *c = EVP_CIPHER_CTX_get_app_data(ctx);
     unsigned char b1[AES_BLOCK_SIZE];
-    size_t i;
+    size_t i = 0;
+    int outlen = 0;
 
     if (inl != 16) /* libssh2 only ever encrypt one block */
 	return 0;
 
+    if (c == NULL) {
+        return 0;
+    }
+
 /*
   To encrypt a packet P=P1||P2||...||Pn (where P1, P2, ..., Pn are each
   blocks of length L), the encryptor first encrypts <X> with <cipher>
@@ -248,7 +278,9 @@ aes_ctr_do_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
   the ciphertext block C1.  The counter X is then incremented
 */
 
-    AES_encrypt(c->ctr, b1, &c->key);
+    if (EVP_EncryptUpdate(c->aes_ctx, b1, &outlen, c->ctr, AES_BLOCK_SIZE) != 1) {
+        return 0;
+    }
 
     for (i = 0; i < 16; i++)
 	*out++ = *in++ ^ b1[i];
@@ -266,7 +298,18 @@ aes_ctr_do_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 static int
 aes_ctr_cleanup(EVP_CIPHER_CTX *ctx) /* cleanup ctx */
 {
-    free(EVP_CIPHER_CTX_get_app_data(ctx));
+    aes_ctr_ctx *c = EVP_CIPHER_CTX_get_app_data(ctx);
+
+    if (c == NULL) {
+        return 1;
+    }
+
+    if (c->aes_ctx != NULL) {
+        free(c->aes_ctx);
+    }
+
+    free(c);
+
     return 1;
 }
 

src/publickey.c

@@ -43,7 +43,7 @@
 
 #define LIBSSH2_PUBLICKEY_VERSION               2
 
-/* Numericised response codes -- Not IETF standard, just a local representation */
+/* Numericised response codes -- Not IETF, just local representation */
 #define LIBSSH2_PUBLICKEY_RESPONSE_STATUS       0
 #define LIBSSH2_PUBLICKEY_RESPONSE_VERSION      1
 #define LIBSSH2_PUBLICKEY_RESPONSE_PUBLICKEY    2
@@ -259,12 +259,13 @@ publickey_response_success(LIBSSH2_PUBLICKEY * pkey)
         default:
             LIBSSH2_FREE(session, data);
             if (response < 0) {
-                return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
+                return _libssh2_error(session,
-                                      "Invalid publickey subsystem response code");
+                                      LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
+                                      "Invalid publickey subsystem response");
             }
             /* Unknown/Unexpected */
             _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
-                           "Unexpected publickey subsystem response, ignoring");
+                           "Unexpected publickey subsystem response");
             data = NULL;
         }
     }
@@ -321,7 +322,8 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
         rc = _libssh2_channel_process_startup(session->pkeyInit_channel,
                                               "subsystem",
                                               sizeof("subsystem") - 1,
-                                              "publickey", strlen("publickey"));
+                                              "publickey",
+                                              sizeof("publickey") - 1);
         if (rc == LIBSSH2_ERROR_EAGAIN) {
             _libssh2_error(session, LIBSSH2_ERROR_EAGAIN,
                            "Would block starting publickey subsystem");
@@ -368,7 +370,7 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
         session->pkeyInit_buffer_sent = 0;
 
         _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
-                       "Sending publickey version packet advertising version %d support",
+                       "Sending publickey advertising version %d support",
                        (int) LIBSSH2_PUBLICKEY_VERSION);
 
         session->pkeyInit_state = libssh2_NB_state_sent2;
@@ -459,7 +461,7 @@ static LIBSSH2_PUBLICKEY *publickey_init(LIBSSH2_SESSION *session)
                 if (session->pkeyInit_pkey->version >
                     LIBSSH2_PUBLICKEY_VERSION) {
                     _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
-                                   "Truncating remote publickey version from %lu",
+                                   "Truncate remote publickey version from %lu",
                                    session->pkeyInit_pkey->version);
                     session->pkeyInit_pkey->version =
                         LIBSSH2_PUBLICKEY_VERSION;
@@ -529,20 +531,27 @@ libssh2_publickey_init(LIBSSH2_SESSION *session)
  * Add a new public key entry
  */
 LIBSSH2_API int
-libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY * pkey, const unsigned char *name,
+libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY *pkey, const unsigned char *name,
                          unsigned long name_len, const unsigned char *blob,
                          unsigned long blob_len, char overwrite,
                          unsigned long num_attrs,
                          const libssh2_publickey_attribute attrs[])
 {
-    LIBSSH2_CHANNEL *channel = pkey->channel;
+    LIBSSH2_CHANNEL *channel;
-    LIBSSH2_SESSION *session = channel->session;
+    LIBSSH2_SESSION *session;
-    /*  19 = packet_len(4) + add_len(4) + "add"(3) + name_len(4) + {name} blob_len(4) + {blob} */
+    /*  19 = packet_len(4) + add_len(4) + "add"(3) + name_len(4) + {name}
+        blob_len(4) + {blob} */
     unsigned long i, packet_len = 19 + name_len + blob_len;
     unsigned char *comment = NULL;
     unsigned long comment_len = 0;
     int rc;
 
+    if(!pkey)
+        return LIBSSH2_ERROR_BAD_USE;
+
+    channel = pkey->channel;
+    session = channel->session;
+
     if (pkey->add_state == libssh2_NB_state_idle) {
         pkey->add_packet = NULL;
 
@@ -627,7 +636,8 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY * pkey, const unsigned char *name,
         }
 
         _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
-                       "Sending publickey \"add\" packet: type=%s blob_len=%ld num_attrs=%ld",
+                       "Sending publickey \"add\" packet: "
+                       "type=%s blob_len=%ld num_attrs=%ld",
                        name, blob_len, num_attrs);
 
         pkey->add_state = libssh2_NB_state_created;
@@ -661,19 +671,27 @@ libssh2_publickey_add_ex(LIBSSH2_PUBLICKEY * pkey, const unsigned char *name,
 }
 
 /* libssh2_publickey_remove_ex
- * Remove an existing publickey so that authentication can no longer be performed using it
+ * Remove an existing publickey so that authentication can no longer be
+ * performed using it
  */
 LIBSSH2_API int
 libssh2_publickey_remove_ex(LIBSSH2_PUBLICKEY * pkey,
                             const unsigned char *name, unsigned long name_len,
                             const unsigned char *blob, unsigned long blob_len)
 {
-    LIBSSH2_CHANNEL *channel = pkey->channel;
+    LIBSSH2_CHANNEL *channel;
-    LIBSSH2_SESSION *session = channel->session;
+    LIBSSH2_SESSION *session;
-    /* 22 = packet_len(4) + remove_len(4) + "remove"(6) + name_len(4) + {name} + blob_len(4) + {blob} */
+    /* 22 = packet_len(4) + remove_len(4) + "remove"(6) + name_len(4) + {name}
+       + blob_len(4) + {blob} */
     unsigned long packet_len = 22 + name_len + blob_len;
     int rc;
 
+    if(!pkey)
+        return LIBSSH2_ERROR_BAD_USE;
+
+    channel = pkey->channel;
+    session = channel->session;
+
     if (pkey->remove_state == libssh2_NB_state_idle) {
         pkey->remove_packet = NULL;
 
@@ -701,7 +719,8 @@ libssh2_publickey_remove_ex(LIBSSH2_PUBLICKEY * pkey,
         pkey->remove_s += blob_len;
 
         _libssh2_debug(session, LIBSSH2_TRACE_PUBLICKEY,
-                       "Sending publickey \"remove\" packet: type=%s blob_len=%ld",
+                       "Sending publickey \"remove\" packet: "
+                       "type=%s blob_len=%ld",
                        name, blob_len);
 
         pkey->remove_state = libssh2_NB_state_created;
@@ -742,14 +761,20 @@ LIBSSH2_API int
 libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
                              libssh2_publickey_list ** pkey_list)
 {
-    LIBSSH2_CHANNEL *channel = pkey->channel;
+    LIBSSH2_CHANNEL *channel;
-    LIBSSH2_SESSION *session = channel->session;
+    LIBSSH2_SESSION *session;
     libssh2_publickey_list *list = NULL;
     unsigned long buffer_len = 12, keys = 0, max_keys = 0, i;
     /* 12 = packet_len(4) + list_len(4) + "list"(4) */
     int response;
     int rc;
 
+    if(!pkey)
+        return LIBSSH2_ERROR_BAD_USE;
+
+    channel = pkey->channel;
+    session = channel->session;
+
     if (pkey->listFetch_state == libssh2_NB_state_idle) {
         pkey->listFetch_data = NULL;
 
@@ -927,13 +952,16 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
                         pkey->listFetch_s += 4;
                         list[keys].attrs[i].value = (char *) pkey->listFetch_s;
                         pkey->listFetch_s += list[keys].attrs[i].value_len;
-                        list[keys].attrs[i].mandatory = 0;      /* actually an ignored value */
+
+                        /* actually an ignored value */
+                        list[keys].attrs[i].mandatory = 0;
                     }
                 } else {
                     list[keys].attrs = NULL;
                 }
             }
-            list[keys].packet = pkey->listFetch_data;   /* To be FREEd in libssh2_publickey_list_free() */
+            /* To be FREEd in libssh2_publickey_list_free() */
+            list[keys].packet = pkey->listFetch_data;
             keys++;
 
             list[keys].packet = NULL;   /* Terminate the list */
@@ -942,7 +970,7 @@ libssh2_publickey_list_fetch(LIBSSH2_PUBLICKEY * pkey, unsigned long *num_keys,
         default:
             /* Unknown/Unexpected */
             _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_PROTOCOL,
-                           "Unexpected publickey subsystem response, ignoring");
+                           "Unexpected publickey subsystem response");
             LIBSSH2_FREE(session, pkey->listFetch_data);
             pkey->listFetch_data = NULL;
         }
@@ -968,9 +996,14 @@ LIBSSH2_API void
 libssh2_publickey_list_free(LIBSSH2_PUBLICKEY * pkey,
                             libssh2_publickey_list * pkey_list)
 {
-    LIBSSH2_SESSION *session = pkey->channel->session;
+    LIBSSH2_SESSION *session;
     libssh2_publickey_list *p = pkey_list;
 
+    if(!pkey || !p)
+        return;
+
+    session = pkey->channel->session;
+
     while (p->packet) {
         if (p->attrs) {
             LIBSSH2_FREE(session, p->attrs);
@@ -986,11 +1019,16 @@ libssh2_publickey_list_free(LIBSSH2_PUBLICKEY * pkey,
  * Shutdown the publickey subsystem
  */
 LIBSSH2_API int
-libssh2_publickey_shutdown(LIBSSH2_PUBLICKEY * pkey)
+libssh2_publickey_shutdown(LIBSSH2_PUBLICKEY *pkey)
 {
-    LIBSSH2_SESSION *session = pkey->channel->session;
+    LIBSSH2_SESSION *session;
     int rc;
 
+    if(!pkey)
+        return LIBSSH2_ERROR_BAD_USE;
+
+    session = pkey->channel->session;
+
     /*
      * Make sure all memory used in the state variables are free
      */

src/scp.c

@@ -939,7 +939,8 @@ scp_send(LIBSSH2_SESSION * session, const char *path, int mode,
 
         session->scpSend_response_len =
             snprintf((char *) session->scpSend_response,
-                     LIBSSH2_SCP_RESPONSE_BUFLEN, "C0%o %llu %s\n", mode,
+                     LIBSSH2_SCP_RESPONSE_BUFLEN, "C0%o %"
+                     LIBSSH2_INT64_T_FORMAT "u %s\n", mode,
                      size, base);
         _libssh2_debug(session, LIBSSH2_TRACE_SCP, "Sent %s",
                        session->scpSend_response);

src/session.c

@@ -543,6 +543,12 @@ int _libssh2_wait_socket(LIBSSH2_SESSION *session)
     int seconds_to_next;
     int dir;
 
+    /* since libssh2 often sets EAGAIN internally before this function is
+       called, we can decrease some amount of confusion in user programs by
+       resetting the error code in this function to reduce the risk of EAGAIN
+       being stored as error when a blocking function has returned */
+    session->err_code = LIBSSH2_ERROR_NONE;
+
     rc = libssh2_keepalive_send (session, &seconds_to_next);
     if (rc < 0)
         return rc;
@@ -564,7 +570,8 @@ int _libssh2_wait_socket(LIBSSH2_SESSION *session)
             if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
                 sockets[0].events |= POLLOUT;
 
-            rc = poll(sockets, 1, seconds_to_next ? seconds_to_next / 1000 : -1);
+            rc = poll(sockets, 1, seconds_to_next ?
+                      seconds_to_next * 1000 : -1);
 #else
             fd_set rfd;
             fd_set wfd;
@@ -836,6 +843,9 @@ session_free(LIBSSH2_SESSION *session)
         LIBSSH2_FREE(session, session->hostkey_prefs);
     }
 
+    if (session->local.kexinit) {
+        LIBSSH2_FREE(session, session->local.kexinit);
+    }
     if (session->local.crypt_prefs) {
         LIBSSH2_FREE(session, session->local.crypt_prefs);
     }
@@ -849,6 +859,9 @@ session_free(LIBSSH2_SESSION *session)
         LIBSSH2_FREE(session, session->local.lang_prefs);
     }
 
+    if (session->remote.kexinit) {
+        LIBSSH2_FREE(session, session->remote.kexinit);
+    }
     if (session->remote.crypt_prefs) {
         LIBSSH2_FREE(session, session->remote.crypt_prefs);
     }
@@ -865,6 +878,9 @@ session_free(LIBSSH2_SESSION *session)
     /*
      * Make sure all memory used in the state variables are free
      */
+    if (session->kexinit_data) {
+        LIBSSH2_FREE(session, session->kexinit_data);
+    }
     if (session->startup_data) {
         LIBSSH2_FREE(session, session->startup_data);
     }
@@ -1252,10 +1268,16 @@ libssh2_session_get_blocking(LIBSSH2_SESSION * session)
  * non-0 if data is available
  */
 LIBSSH2_API int
-libssh2_poll_channel_read(LIBSSH2_CHANNEL * channel, int extended)
+libssh2_poll_channel_read(LIBSSH2_CHANNEL *channel, int extended)
 {
-    LIBSSH2_SESSION *session = channel->session;
+    LIBSSH2_SESSION *session;
-    LIBSSH2_PACKET *packet = _libssh2_list_first(&session->packets);
+    LIBSSH2_PACKET *packet;
+
+    if(!channel)
+        return LIBSSH2_ERROR_BAD_USE;
+
+    session = channel->session;
+    packet = _libssh2_list_first(&session->packets);
 
     while (packet) {
         if ( channel->local.id == _libssh2_ntohu32(packet->data + 1)) {

src/sftp.c

@@ -698,7 +698,8 @@ static LIBSSH2_SFTP *sftp_init(LIBSSH2_SESSION *session)
     return sftp_handle;
 
   sftp_init_error:
-    while (_libssh2_channel_free(session->sftpInit_channel) == LIBSSH2_ERROR_EAGAIN);
+    while (_libssh2_channel_free(session->sftpInit_channel) ==
+           LIBSSH2_ERROR_EAGAIN);
     session->sftpInit_channel = NULL;
     if (session->sftpInit_sftp) {
         LIBSSH2_FREE(session, session->sftpInit_sftp);
@@ -717,6 +718,9 @@ LIBSSH2_API LIBSSH2_SFTP *libssh2_sftp_init(LIBSSH2_SESSION *session)
 {
     LIBSSH2_SFTP *ptr;
 
+    if(!session)
+        return NULL;
+
     if(!(session->state & LIBSSH2_STATE_AUTHENTICATED)) {
         _libssh2_error(session, LIBSSH2_ERROR_INVAL,
                        "session not authenticated yet");
@@ -808,6 +812,8 @@ LIBSSH2_API int
 libssh2_sftp_shutdown(LIBSSH2_SFTP *sftp)
 {
     int rc;
+    if(!sftp)
+        return LIBSSH2_ERROR_BAD_USE;
     BLOCK_ADJUST(rc, sftp->channel->session, sftp_shutdown(sftp));
     return rc;
 }
@@ -1016,6 +1022,10 @@ libssh2_sftp_open_ex(LIBSSH2_SFTP *sftp, const char *filename,
                      int open_type)
 {
     LIBSSH2_SFTP_HANDLE *hnd;
+
+    if(!sftp)
+        return NULL;
+
     BLOCK_ADJUST_ERRNO(hnd, sftp->channel->session,
                        sftp_open(sftp, filename, filename_len, flags, mode,
                                  open_type));
@@ -1192,6 +1202,8 @@ libssh2_sftp_read(LIBSSH2_SFTP_HANDLE *hnd, char *buffer,
                   size_t buffer_maxlen)
 {
     ssize_t rc;
+    if(!hnd)
+        return LIBSSH2_ERROR_BAD_USE;
     BLOCK_ADJUST(rc, hnd->sftp->channel->session,
                  sftp_read(hnd, buffer, buffer_maxlen));
     return rc;
@@ -1363,6 +1375,8 @@ libssh2_sftp_readdir_ex(LIBSSH2_SFTP_HANDLE *hnd, char *buffer,
                         LIBSSH2_SFTP_ATTRIBUTES *attrs)
 {
     int rc;
+    if(!hnd)
+        return LIBSSH2_ERROR_BAD_USE;
     BLOCK_ADJUST(rc, hnd->sftp->channel->session,
                  sftp_readdir(hnd, buffer, buffer_maxlen, longentry,
                               longentry_maxlen, attrs));
@@ -1388,12 +1402,9 @@ static ssize_t sftp_write(LIBSSH2_SFTP_HANDLE *handle, const char *buffer,
     unsigned char *s, *data;
     int rc;
 
-    /* There's no point in us accepting a VERY large packet here since we
+    /* we limit this to just send a single SSH packet at a time */
-       cannot send it anyway. We just accept 4 times the big size to fill up
+    if(count > 32500)
-       the queue somewhat. */
+        count = 32500;
-
-    if(count > (MAX_SSH_PACKET_LEN*4))
-        count = MAX_SSH_PACKET_LEN*4;
 
     packet_len = handle->handle_len + count + 25;
 
@@ -1470,6 +1481,8 @@ libssh2_sftp_write(LIBSSH2_SFTP_HANDLE *hnd, const char *buffer,
                    size_t count)
 {
     ssize_t rc;
+    if(!hnd)
+        return LIBSSH2_ERROR_BAD_USE;
     BLOCK_ADJUST(rc, hnd->sftp->channel->session,
                  sftp_write(hnd, buffer, count));
     return rc;
@@ -1575,10 +1588,12 @@ static int sftp_fstat(LIBSSH2_SFTP_HANDLE *handle,
  * Get or Set stat on a file
  */
 LIBSSH2_API int
-libssh2_sftp_fstat_ex(LIBSSH2_SFTP_HANDLE * hnd,
+libssh2_sftp_fstat_ex(LIBSSH2_SFTP_HANDLE *hnd,
                       LIBSSH2_SFTP_ATTRIBUTES *attrs, int setstat)
 {
     int rc;
+    if(!hnd || !attrs)
+        return LIBSSH2_ERROR_BAD_USE;
     BLOCK_ADJUST(rc, hnd->sftp->channel->session,
                  sftp_fstat(hnd, attrs, setstat));
     return rc;
@@ -1588,26 +1603,31 @@ libssh2_sftp_fstat_ex(LIBSSH2_SFTP_HANDLE * hnd,
  * Set the read/write pointer to an arbitrary position within the file
  */
 LIBSSH2_API void
-libssh2_sftp_seek(LIBSSH2_SFTP_HANDLE * handle, size_t offset)
+libssh2_sftp_seek(LIBSSH2_SFTP_HANDLE *handle, size_t offset)
 {
-    handle->u.file.offset = offset;
+    if(handle)
+        handle->u.file.offset = offset;
 }
 
 /* libssh2_sftp_seek64
  * Set the read/write pointer to an arbitrary position within the file
  */
 LIBSSH2_API void
-libssh2_sftp_seek64(LIBSSH2_SFTP_HANDLE * handle, libssh2_uint64_t offset)
+libssh2_sftp_seek64(LIBSSH2_SFTP_HANDLE *handle, libssh2_uint64_t offset)
 {
-    handle->u.file.offset = offset;
+    if(handle)
+        handle->u.file.offset = offset;
 }
 
 /* libssh2_sftp_tell
  * Return the current read/write pointer's offset
  */
 LIBSSH2_API size_t
-libssh2_sftp_tell(LIBSSH2_SFTP_HANDLE * handle)
+libssh2_sftp_tell(LIBSSH2_SFTP_HANDLE *handle)
 {
+    if(!handle)
+        return 0; /* no handle, no size */
+
     /* NOTE: this may very well truncate the size if it is larger than what
        size_t can hold, so libssh2_sftp_tell64() is really the function you
        should use */
@@ -1618,8 +1638,11 @@ libssh2_sftp_tell(LIBSSH2_SFTP_HANDLE * handle)
  * Return the current read/write pointer's offset
  */
 LIBSSH2_API libssh2_uint64_t
-libssh2_sftp_tell64(LIBSSH2_SFTP_HANDLE * handle)
+libssh2_sftp_tell64(LIBSSH2_SFTP_HANDLE *handle)
 {
+    if(!handle)
+        return 0; /* no handle, no size */
+
     return handle->u.file.offset;
 }
 
@@ -1731,6 +1754,8 @@ LIBSSH2_API int
 libssh2_sftp_close_handle(LIBSSH2_SFTP_HANDLE *hnd)
 {
     int rc;
+    if(!hnd)
+        return LIBSSH2_ERROR_BAD_USE;
     BLOCK_ADJUST(rc, hnd->sftp->channel->session, sftp_close_handle(hnd));
     return rc;
 }
@@ -1819,6 +1844,8 @@ libssh2_sftp_unlink_ex(LIBSSH2_SFTP *sftp, const char *filename,
                        unsigned int filename_len)
 {
     int rc;
+    if(!sftp)
+        return LIBSSH2_ERROR_BAD_USE;
     BLOCK_ADJUST(rc, sftp->channel->session,
                  sftp_unlink(sftp, filename, filename_len));
     return rc;
@@ -1949,6 +1976,8 @@ libssh2_sftp_rename_ex(LIBSSH2_SFTP *sftp, const char *source_filename,
                        unsigned int dest_filename_len, long flags)
 {
     int rc;
+    if(!sftp)
+        return LIBSSH2_ERROR_BAD_USE;
     BLOCK_ADJUST(rc, sftp->channel->session,
                  sftp_rename(sftp, source_filename, source_filename_len,
                              dest_filename, dest_filename_len, flags));
@@ -2061,6 +2090,8 @@ LIBSSH2_API int
 libssh2_sftp_fstatvfs(LIBSSH2_SFTP_HANDLE *handle, LIBSSH2_SFTP_STATVFS *st)
 {
     int rc;
+    if(!handle || !st)
+        return LIBSSH2_ERROR_BAD_USE;
     BLOCK_ADJUST(rc, handle->sftp->channel->session, sftp_fstatvfs(handle, st));
     return rc;
 }
@@ -2172,6 +2203,8 @@ libssh2_sftp_statvfs(LIBSSH2_SFTP *sftp, const char *path,
                      size_t path_len, LIBSSH2_SFTP_STATVFS *st)
 {
     int rc;
+    if(!sftp || !st)
+        return LIBSSH2_ERROR_BAD_USE;
     BLOCK_ADJUST(rc, sftp->channel->session, sftp_statvfs(sftp, path, path_len,
                                                           st));
     return rc;
@@ -2277,6 +2310,8 @@ libssh2_sftp_mkdir_ex(LIBSSH2_SFTP *sftp, const char *path,
                       unsigned int path_len, long mode)
 {
     int rc;
+    if(!sftp)
+        return LIBSSH2_ERROR_BAD_USE;
     BLOCK_ADJUST(rc, sftp->channel->session,
                  sftp_mkdir(sftp, path, path_len, mode));
     return rc;
@@ -2366,6 +2401,8 @@ libssh2_sftp_rmdir_ex(LIBSSH2_SFTP *sftp, const char *path,
                       unsigned int path_len)
 {
     int rc;
+    if(!sftp)
+        return LIBSSH2_ERROR_BAD_USE;
     BLOCK_ADJUST(rc, sftp->channel->session,
                  sftp_rmdir(sftp, path, path_len));
     return rc;
@@ -2488,6 +2525,8 @@ libssh2_sftp_stat_ex(LIBSSH2_SFTP *sftp, const char *path,
                      LIBSSH2_SFTP_ATTRIBUTES *attrs)
 {
     int rc;
+    if(!sftp)
+        return LIBSSH2_ERROR_BAD_USE;
     BLOCK_ADJUST(rc, sftp->channel->session,
                  sftp_stat(sftp, path, path_len, stat_type, attrs));
     return rc;
@@ -2629,6 +2668,8 @@ libssh2_sftp_symlink_ex(LIBSSH2_SFTP *sftp, const char *path,
                         unsigned int target_len, int link_type)
 {
     int rc;
+    if(!sftp)
+        return LIBSSH2_ERROR_BAD_USE;
     BLOCK_ADJUST(rc, sftp->channel->session,
                  sftp_symlink(sftp, path, path_len, target, target_len,
                               link_type));
@@ -2641,5 +2682,8 @@ libssh2_sftp_symlink_ex(LIBSSH2_SFTP *sftp, const char *path,
 LIBSSH2_API unsigned long
 libssh2_sftp_last_error(LIBSSH2_SFTP *sftp)
 {
+    if(!sftp)
+       return 0;
+
     return sftp->last_errno;
 }

src/userauth.c

@@ -657,14 +657,14 @@ userauth_hostbased_fromfile(LIBSSH2_SESSION *session,
             return rc;
 
         /*
-         * 48 = packet_type(1) + username_len(4) + servicename_len(4) +
+         * 52 = 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)
+         * hostname_len(4) + local_username_len(4)
          */
         session->userauth_host_packet_len =
             username_len + session->userauth_host_method_len + hostname_len +
-            local_username_len + pubkeydata_len + 48;
+            local_username_len + pubkeydata_len + 52;
 
         /*
          * Preallocate space for an overall length,  method name again,
@@ -876,6 +876,15 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
     unsigned char *s;
 
     if (session->userauth_pblc_state == libssh2_NB_state_idle) {
+
+        /*
+         * The call to _libssh2_ntohu32 later relies on pubkeydata having at
+         * least 4 valid bytes containing the length of the method name.
+         */
+        if (pubkeydata_len < 4)
+            return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
+                                  "Invalid public key, too short");
+
         /* Zero the whole thing out */
         memset(&session->userauth_pblc_packet_requirev_state, 0,
                sizeof(session->userauth_pblc_packet_requirev_state));
@@ -888,6 +897,15 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
          */
         if (!session->userauth_pblc_method) {
             session->userauth_pblc_method_len = _libssh2_ntohu32(pubkeydata);
+
+            if(session->userauth_pblc_method_len > pubkeydata_len)
+                /* the method length simply cannot be longer than the entire
+                   passed in data, so we use this to detect crazy input
+                   data */
+                return _libssh2_error(session,
+                                      LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
+                                      "Invalid public key");
+
             session->userauth_pblc_method =
                 LIBSSH2_ALLOC(session, session->userauth_pblc_method_len);
             if (!session->userauth_pblc_method) {
@@ -898,8 +916,15 @@ _libssh2_userauth_publickey(LIBSSH2_SESSION *session,
             memcpy(session->userauth_pblc_method, pubkeydata + 4,
                    session->userauth_pblc_method_len);
         }
-        assert( /* preallocated method len should match what we expect */
+        /*
-            session->userauth_pblc_method_len == _libssh2_ntohu32(pubkeydata));
+         * The length of the method name read from plaintext prefix in the
+         * file must match length embedded in the key.
+         * TODO: The data should match too but we don't check that. Should we?
+         */
+        else if (session->userauth_pblc_method_len !=
+                 _libssh2_ntohu32(pubkeydata))
+            return _libssh2_error(session, LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED,
+                                 "Invalid public key");
 
         /*
          * 45 = packet_type(1) + username_len(4) + servicename_len(4) +
@@ -1234,6 +1259,10 @@ libssh2_userauth_publickey(LIBSSH2_SESSION *session,
                            void **abstract)
 {
     int rc;
+
+    if(!session)
+        return LIBSSH2_ERROR_BAD_USE;
+
     BLOCK_ADJUST(rc, session,
                  _libssh2_userauth_publickey(session, user, strlen(user),
                                              pubkeydata, pubkeydata_len,

win32/Makefile.Watcom

@@ -0,0 +1,179 @@
+#
+#  Watcom / OpenWatcom Win32 makefile for libssh2.
+#
+#  Comments to: Guenter Knauf http://www.gknw.net/phpbb
+#
+
+!ifndef %watcom
+!error WATCOM environment variable not set!
+!else
+SYS_INCL = -I$(%watcom)\h\nt -I$(%watcom)\h
+SYS_LIBS = $(%watcom)\lib386\nt;$(%watcom)\lib386
+!endif
+
+!ifdef %libname
+LIBNAME = $(%libname)
+!else
+LIBNAME = libssh2
+!endif
+TARGETS = $(LIBNAME).dll $(LIBNAME)_imp.lib $(LIBNAME).lib
+
+CC = wcc386
+LD = wlink
+AR = wlib
+RC = wrc
+
+!ifdef __LOADDLL__
+!  loaddll wcc386  wccd386
+!  loaddll wpp386  wppd386
+!  loaddll wlib    wlibd
+!  if $(__VERSION__) > 1270
+!    loaddll wlink   wlinkd
+!  else
+!    loaddll wlink   wlink
+!  endif
+!endif
+
+!if $(__VERSION__) < 1250                                                                                                           
+RM = del /q /f >NUL 2>&1
+!else                                                                                                                               
+RM = rm -f                                                                                                                          
+!endif
+MD = mkdir
+RD = rmdir /q /s >NUL 2>&1
+CP = copy
+
+CFLAGS = -3r -mf -hc -zff -zgf -zq -zm -zc -s -fr=nul -w2 -fpi -oilrtfm &
+         -wcd=201 -bt=nt -d+ -dWIN32 -DLIBSSH2_WIN32 &
+         -I. -I..\include $(SYS_INCL)
+
+!ifdef %debug
+DEBUG  = -dDEBUG=1 -dDEBUGBUILD
+CFLAGS += -d3 $(DEBUG)
+!else
+CFLAGS += -d0
+!endif
+
+!ifdef %use_ipv6
+CFLAGS += -d_WIN32_WINNT=0x0501 -dENABLE_IPV6
+!endif
+
+#
+# Change to suite.
+#
+!ifdef %zlib_root
+ZLIB_ROOT = $(%zlib_root)
+!else
+ZLIB_ROOT = ..\..\zlib-1.2.5
+!endif
+
+!ifdef %openssl_root
+OPENSSL_ROOT = $(%openssl_root)
+!else
+OPENSSL_ROOT = ..\..\openssl-0.9.8o
+!endif
+
+#!ifdef %use_zlib
+CFLAGS += -dHAVE_ZLIB_H -dHAVE_LIBZ -I$(ZLIB_ROOT)
+#!endif
+
+#!ifdef %use_ssl
+CFLAGS += -wcd=138 -dUSE_OPENSSL -dUSE_SSLEAY -I$(OPENSSL_ROOT)\inc32
+#!endif
+
+!ifdef %use_watt32
+CFLAGS += -dUSE_WATT32 -I$(%watt_root)\inc
+!endif
+
+OBJ_BASE = WC_Win32.obj
+LINK_ARG = $(OBJ_BASE)\dyn\wlink.arg
+LIB_ARG  = $(OBJ_BASE)\stat\wlib.arg
+
+# In order to process Makefile.inc wmake must be called with -u switch!
+!ifndef %MAKEFLAGS
+!error You MUST call wmake with the -u switch!
+!else
+!include ..\Makefile.inc
+!endif
+
+OBJS = $(CSOURCES:.c=.obj)
+OBJS = $OBJ_DIR\$(OBJS: = $OBJ_DIR\)
+
+#
+# Use $(OBJS) as a template to generate $(OBJS_STAT) and $(OBJS_DYN).
+#
+OBJ_DIR    = $(OBJ_BASE)\stat
+OBJS_STAT  = $+ $(OBJS) $-
+
+OBJ_DIR    = $(OBJ_BASE)\dyn
+OBJS_DYN   = $+ $(OBJS) $-
+
+RESOURCE   = $(OBJ_BASE)\dyn\libssh2.res
+
+.c: ..\src
+
+
+all: $(OBJ_BASE) $(TARGETS) .SYMBOLIC
+	@echo Welcome to libssh2
+
+clean: .SYMBOLIC
+	-$(RM) $(OBJS_STAT)
+	-$(RM) $(OBJS_DYN)
+	-$(RM) $(RESOURCE) $(LINK_ARG) $(LIB_ARG)
+
+vclean realclean: clean .SYMBOLIC
+	-$(RM) $(TARGETS) $(LIBNAME).map $(LIBNAME).sym
+	-$(RD) $(OBJ_BASE)\stat
+	-$(RD) $(OBJ_BASE)\dyn
+	-$(RD) $(OBJ_BASE)
+
+$(OBJ_BASE):
+	-$(MD) $^@
+	-$(MD) $^@\stat
+	-$(MD) $^@\dyn
+
+$(LIBNAME).dll: $(OBJS_DYN) $(RESOURCE) $(LINK_ARG)
+	$(LD) name $^@ @$]@
+
+$(LIBNAME).lib: $(OBJS_STAT) $(LIB_ARG)
+	$(AR) -q -b -c $^@ @$]@
+
+.ERASE
+$(RESOURCE): libssh2.rc
+	$(RC) $(DEBUG) -q -r -zm -DLIBSSH2_VERSION_ONLY -I..\include $(SYS_INCL) $[@ -fo=$^@
+
+.ERASE
+.c{$(OBJ_BASE)\dyn}.obj:
+	$(CC) $(CFLAGS) -bd -br $[@ -fo=$^@
+
+.ERASE
+.c{$(OBJ_BASE)\stat}.obj:
+	$(CC) $(CFLAGS) $[@ -fo=$^@
+
+$(LINK_ARG): $(__MAKEFILES__)
+	%create $^@
+	@%append $^@ system nt dll
+	@%append $^@ file { $(OBJS_DYN) }
+!ifdef %debug
+	@%append $^@ debug all
+	@%append $^@ option symfile
+!endif
+	@%append $^@ option quiet, map, caseexact, eliminate, implib=$(LIBNAME)_imp.lib,
+	@%append $^@ res=$(RESOURCE) libpath $(SYS_LIBS)
+!ifdef %use_watt32
+	@%append $^@ library $(%watt_root)\lib\wattcpw_imp.lib
+!else
+	@%append $^@ library ws2_32.lib
+!endif
+#!ifdef %use_zlib
+	@%append $^@ library $(ZLIB_ROOT)\zlib.lib
+#!endif
+#!ifdef %use_ssl
+	@%append $^@ library $(OPENSSL_ROOT)\out32\libeay32.lib, $(OPENSSL_ROOT)\out32\ssleay32.lib
+#!endif
+
+$(LIB_ARG): $(__MAKEFILES__)
+	%create $^@
+	@for %f in ($(OBJS_STAT)) do @%append $^@ +- %f
+
+

win32/Makefile.win32

@@ -3,9 +3,7 @@
 ## Makefile for building libssh2 (Win32 version - gnu make)
 ## Use: make -f Makefile.win32 [help|all|clean|dev|devclean|dist|distclean|dll|objclean]
 ##
-## Comments to: Guenter Knauf <eflash@gmx.net>
+## Comments to: Guenter Knauf http://www.gknw.net/phpbb
-##
-## $Id: Makefile.win32,v 1.11 2009/04/09 03:13:52 gknauf Exp $
 #
 #########################################################################
 
@@ -18,7 +16,7 @@ WITH_ZLIB = 1
 
 # Edit the path below to point to the base of your OpenSSL package.
 ifndef OPENSSL_PATH
-OPENSSL_PATH = ../../openssl-0.9.8n
+OPENSSL_PATH = ../../openssl-0.9.8o
 endif
 
 # Edit the path below to point to your Distribution folder.
@@ -36,7 +34,7 @@ DEVLARC	= $(DEVLDIR).zip
 # Edit the vars below to change target settings.
 TARGET	= libssh2
 VERSION	= $(LIBSSH2_VERSION)
-COPYR	= (c) 2004-2010 The libssh2 project and its contributors.
+COPYR   = (c) $(LIBSSH2_COPYRIGHT_STR)
 WWWURL	= http://www.libssh2.org/
 DESCR	= libssh2 $(LIBSSH2_VERSION_STR)
 #STACK	= 64000
@@ -68,7 +66,7 @@ endif
 CP	= cp -afv
 # RM	= rm -f
 # Here you can find a native Win32 binary of the original awk:
-# http://www.gknw.net/development/prgtools/awk.zip
+# http://www.gknw.net/development/prgtools/awk-20070501.zip
 AWK	= awk
 ZIP	= zip -qzr9
 
@@ -222,46 +220,10 @@ $(TARGET).dll $(TARGET)dll.a: $(OBJL)
 	@$(LD) $(LDFLAGS) $^ -o $@ $(LIBPATH) $(LDLIBS)
 
 
-$(OBJDIR)/%.res: $(OBJDIR)/%.rc
+$(OBJDIR)/%.res: %.rc
 	@echo Creating $@
-	@$(RC) $(RCFLAGS) $< -o $@
+	@$(RC) $(RCFLAGS) -DLIBSSH2_VERSION_ONLY -I. -I ../include $< -o $@
 
-$(OBJDIR)/%.rc: Makefile.win32 $(OBJDIR)/version.inc
-	@echo $(DL)1 VERSIONINFO$(DL) > $@
-	@echo $(DL) FILEVERSION $(LIBSSH2_VERSION),0$(DL) >> $@
-	@echo $(DL) PRODUCTVERSION $(LIBSSH2_VERSION),0$(DL) >> $@
-	@echo $(DL) FILEFLAGSMASK 0x3fL$(DL) >> $@
-	@echo $(DL) FILEOS 0x40004L$(DL) >> $@
-	@echo $(DL) FILEFLAGS 0x0L$(DL) >> $@
-	@echo $(DL) FILETYPE 0x1L$(DL) >> $@
-	@echo $(DL) FILESUBTYPE 0x0L$(DL) >> $@
-	@echo $(DL)BEGIN$(DL) >> $@
-	@echo $(DL)  BLOCK "StringFileInfo"$(DL) >> $@
-	@echo $(DL)  BEGIN$(DL) >> $@
-	@echo $(DL)    BLOCK "040904E4"$(DL) >> $@
-	@echo $(DL)    BEGIN$(DL) >> $@
-	@echo $(DL)      VALUE "LegalCopyright","$(COPYR)\0"$(DL) >> $@
-ifdef COMPANY
-	@echo $(DL)      VALUE "CompanyName","$(COMPANY)\0"$(DL) >> $@
-endif
-	@echo $(DL)      VALUE "ProductName","$(notdir $(@:.rc=.dll))\0"$(DL) >> $@
-	@echo $(DL)      VALUE "ProductVersion","$(LIBSSH2_VERSION_STR)\0"$(DL) >> $@
-	@echo $(DL)      VALUE "License","Released under the Modified BSD license.\0"$(DL) >> $@
-	@echo $(DL)      VALUE "FileDescription","$(DESCR)\0"$(DL) >> $@
-	@echo $(DL)      VALUE "FileVersion","$(LIBSSH2_VERSION_STR)\0"$(DL) >> $@
-	@echo $(DL)      VALUE "InternalName","$(notdir $(@:.rc=))\0"$(DL) >> $@
-	@echo $(DL)      VALUE "OriginalFilename","$(notdir $(@:.rc=.dll))\0"$(DL) >> $@
-	@echo $(DL)      VALUE "WWW","$(WWWURL)\0"$(DL) >> $@
-	@echo $(DL)    END$(DL) >> $@
-	@echo $(DL)  END$(DL) >> $@
-	@echo $(DL)  BLOCK "VarFileInfo"$(DL) >> $@
-	@echo $(DL)  BEGIN$(DL) >> $@
-	@echo $(DL)    VALUE "Translation", 0x409, 1252$(DL) >> $@
-	@echo $(DL)  END$(DL) >> $@
-	@echo $(DL)END$(DL) >> $@
-ifdef ICON
-	@echo $(DL)10 ICON DISCARDABLE "$(ICON)"$(DL) >> $@
-endif
 
 $(DISTDIR)/readme.txt: Makefile.win32
 	@echo Creating $@

win32/config.mk

@@ -1,10 +1,10 @@
 
 # Tweak these for your system
-OPENSSLINC=..\openssl-0.9.8e\inc32
+OPENSSLINC=..\openssl-0.9.8o\inc32
-OPENSSLLIB=..\openssl-0.9.8e\out32dll
+OPENSSLLIB=..\openssl-0.9.8o\out32dll
 
-ZLIBINC=-DLIBSSH2_HAVE_ZLIB=1 /I..\zlib-1.2.3
+ZLIBINC=-DLIBSSH2_HAVE_ZLIB=1 /I..\zlib-1.2.5
-ZLIBLIB=..\zlib-1.2.3
+ZLIBLIB=..\zlib-1.2.5
 
 !if "$(TARGET)" == ""
 TARGET=Release

win32/libssh2.rc

@@ -0,0 +1,45 @@
+/***************************************************************************
+* libssh2 Win32 resource file                                              *
+***************************************************************************/
+#include <winver.h>
+#include "../include/libssh2.h"
+
+LANGUAGE  0x09,0x01
+
+#define RC_VERSION  LIBSSH2_VERSION_MAJOR, LIBSSH2_VERSION_MINOR, LIBSSH2_VERSION_PATCH, 0
+
+VS_VERSION_INFO VERSIONINFO
+  FILEVERSION     RC_VERSION
+  PRODUCTVERSION  RC_VERSION
+  FILEFLAGSMASK   0x3fL
+#if defined(DEBUGBUILD) || defined(_DEBUG)
+  FILEFLAGS 1
+#else
+  FILEFLAGS 0
+#endif
+  FILEOS      VOS__WINDOWS32
+  FILETYPE    VFT_DLL
+  FILESUBTYPE 0x0L
+
+BEGIN
+  BLOCK "StringFileInfo"
+  BEGIN
+    BLOCK "040904b0"
+    BEGIN
+      VALUE "CompanyName",      "The libssh2 library, http://www.libssh2.org/\0"
+      VALUE "FileDescription",  "libssh2 Shared Library\0"
+      VALUE "FileVersion",      LIBSSH2_VERSION "\0"
+      VALUE "InternalName",     "libssh2\0"
+      VALUE "OriginalFilename", "libssh2.dll\0"
+      VALUE "ProductName",      "The libssh2 library\0"
+      VALUE "ProductVersion",   LIBSSH2_VERSION "\0"
+      VALUE "LegalCopyright",   "<22> " LIBSSH2_COPYRIGHT "\0"
+      VALUE "License",          "http://www.libssh2.org/license.html\0"
+    END
+  END
+
+  BLOCK "VarFileInfo"
+  BEGIN
+    VALUE "Translation", 0x409, 1200
+  END
+END

win32/test/Makefile.win32

@@ -3,9 +3,7 @@
 ## Makefile for building libssh2 samples (Win32 version - gnu make)
 ## Use: make -f Makefile.win32 [help]
 ##
-## Comments to: Guenter Knauf <eflash@gmx.net>
+## Comments to: Guenter Knauf http://www.gknw.net/phpbb
-##
-## $Id: Makefile.win32,v 1.8 2009/04/09 03:14:05 gknauf Exp $
 #
 #########################################################################
 
@@ -16,7 +14,7 @@ endif
 
 # Edit the path below to point to the base of your OpenSSL package.
 ifndef OPENSSL_PATH
-OPENSSL_PATH = ../../../openssl-0.9.8n
+OPENSSL_PATH = ../../../openssl-0.9.8o
 endif
 
 # Edit the var below to enable static linking of libssh2 and libz
@@ -56,7 +54,7 @@ endif
 CP	= cp -afv
 # RM	= rm -f
 # Here you can find a native Win32 binary of the original awk:
-# http://www.gknw.net/development/prgtools/awk.zip
+# http://www.gknw.net/development/prgtools/awk-20070501.zip
 AWK	= awk
 ZIP	= zip -qzr9