summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorCarlos Martín Nieto <cmn@dwim.me>2016-12-18 18:47:25 +0000
committerCarlos Martín Nieto <cmn@dwim.me>2017-03-12 15:16:29 +0100
commit9cc10d48a9d188b268e380c8d94aa88288230d12 (patch)
treead0cdcca055a4ea4dbc25e3fca0b384214991f10
parent9c7b952055c99a98efba34d6c05db9ed0e6486d4 (diff)
downloadlibgit2-9cc10d48a9d188b268e380c8d94aa88288230d12.tar.gz
ssh: don't try to link against libssh2
Part of the point of this is being able to load libssh2 regardless of whether it was available upon building, as the resulting shared object might move. Make USE_SSH mean to try to load it at runtime. We still need to know the signatures of the functions for our macros to work, so include a copy of the header as a vendored dependency.
-rw-r--r--CMakeLists.txt41
-rw-r--r--COPYING43
-rw-r--r--deps/libssh2/libssh2.h1294
-rw-r--r--src/transports/ssh.c76
4 files changed, 1395 insertions, 59 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt
index c492897cb..4cae01720 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -39,7 +39,7 @@ OPTION( LIBGIT2_FILENAME "Name of the produced binary" OFF )
OPTION( USE_SHA1DC "Use SHA-1 with collision detection" OFF )
OPTION( USE_ICONV "Link with and use iconv library" OFF )
-OPTION( USE_SSH "Link with libssh to enable SSH support" ON )
+OPTION( USE_SSH "Enable runtime detection of libssh2 for SSH support" ON )
OPTION( USE_GSSAPI "Link with libgssapi for SPNEGO auth" OFF )
OPTION( VALGRIND "Configure build for valgrind" OFF )
OPTION( CURL "Use curl for HTTP if available" ON)
@@ -68,10 +68,6 @@ IF(MSVC)
# are linking statically
OPTION( STATIC_CRT "Link the static CRT libraries" ON )
- # If you want to embed a copy of libssh2 into libgit2, pass a
- # path to libssh2
- OPTION( EMBED_SSH_PATH "Path to libssh2 to embed (Windows)" OFF )
-
ADD_DEFINITIONS(-D_SCL_SECURE_NO_WARNINGS)
ADD_DEFINITIONS(-D_CRT_SECURE_NO_DEPRECATE)
ADD_DEFINITIONS(-D_CRT_NONSTDC_NO_DEPRECATE)
@@ -229,13 +225,6 @@ IF (COREFOUNDATION_FOUND)
ENDIF()
-IF (WIN32 AND EMBED_SSH_PATH)
- FILE(GLOB SRC_SSH "${EMBED_SSH_PATH}/src/*.c")
- INCLUDE_DIRECTORIES("${EMBED_SSH_PATH}/include")
- FILE(WRITE "${EMBED_SSH_PATH}/src/libssh2_config.h" "#define HAVE_WINCNG\n#define LIBSSH2_WINCNG\n#include \"../win32/libssh2_config.h\"")
- ADD_DEFINITIONS(-DGIT_SSH)
-ENDIF()
-
IF (WIN32 AND WINHTTP)
ADD_DEFINITIONS(-DGIT_WINHTTP)
@@ -352,32 +341,10 @@ ELSE()
FILE(GLOB SRC_ZLIB deps/zlib/*.c deps/zlib/*.h)
ENDIF()
-# Optional external dependency: libssh2
+# Optional dependency to load at run-time: libssh2
IF (USE_SSH)
- PKG_CHECK_MODULES(LIBSSH2 libssh2)
-ENDIF()
-IF (LIBSSH2_FOUND)
- ADD_DEFINITIONS(-DGIT_SSH)
- INCLUDE_DIRECTORIES(${LIBSSH2_INCLUDE_DIRS})
- LINK_DIRECTORIES(${LIBSSH2_LIBRARY_DIRS})
- LIST(APPEND LIBGIT2_PC_LIBS ${LIBSSH2_LDFLAGS})
- #SET(LIBGIT2_PC_LIBS "${LIBGIT2_PC_LIBS} ${LIBSSH2_LDFLAGS}")
- IF(WIN32)
- ADD_DEFINITIONS(-DGIT_LIBSSH2_SOVERSION="libssh2.dll")
- ELSEIF(DARWIN)
- ADD_DEFINITIONS(-DGIT_LIBSSH2_SOVERSION="libssh2.1.dylib")
- ELSE()
- ADD_DEFINITIONS(-DGIT_LIBSSH2_SOVERSION="libssh2.so.2.1.0")
- ENDIF()
-
- SET(SSH_LIBRARIES ${LIBSSH2_LIBRARIES})
-
- CHECK_LIBRARY_EXISTS("${LIBSSH2_LIBRARIES}" libssh2_userauth_publickey_frommemory "${LIBSSH2_LIBRARY_DIRS}" HAVE_LIBSSH2_MEMORY_CREDENTIALS)
- IF (HAVE_LIBSSH2_MEMORY_CREDENTIALS)
- ADD_DEFINITIONS(-DGIT_SSH_MEMORY_CREDENTIALS)
- ENDIF()
-ELSE()
- MESSAGE(STATUS "LIBSSH2 not found. Set CMAKE_PREFIX_PATH if it is installed outside of the default search path.")
+ ADD_DEFINITIONS(-DGIT_SSH)
+ INCLUDE_DIRECTORIES(deps/libssh2)
ENDIF()
# Optional external dependency: libgssapi
diff --git a/COPYING b/COPYING
index da695ebdb..9fd884779 100644
--- a/COPYING
+++ b/COPYING
@@ -454,6 +454,49 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
----------------------------------------------------------------------
+We include a header file from libssh2 (deps/libssh2/), which is licensed under the BSD license.
+
+Copyright (c) 2004-2009, Sara Golemon <sarag@libssh2.org>
+Copyright (c) 2009-2015 Daniel Stenberg
+Copyright (c) 2010 Simon Josefsson <simon@josefsson.org>
+All rights reserved.
+
+Redistribution and use in source and binary forms,
+with or without modification, are permitted provided
+that the following conditions are met:
+
+ Redistributions of source code must retain the above
+ copyright notice, this list of conditions and the
+ following disclaimer.
+
+ Redistributions in binary form must reproduce the above
+ copyright notice, this list of conditions and the following
+ disclaimer in the documentation and/or other materials
+ provided with the distribution.
+
+ Neither the name of the copyright holder nor the names
+ of any other contributors may be used to endorse or
+ promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+OF SUCH DAMAGE.
+
+
+----------------------------------------------------------------------
+
GNU LESSER GENERAL PUBLIC LICENSE
Version 2.1, February 1999
diff --git a/deps/libssh2/libssh2.h b/deps/libssh2/libssh2.h
new file mode 100644
index 000000000..34d284210
--- /dev/null
+++ b/deps/libssh2/libssh2.h
@@ -0,0 +1,1294 @@
+/* Copyright (c) 2004-2009, Sara Golemon <sarag@libssh2.org>
+ * Copyright (c) 2009-2015 Daniel Stenberg
+ * Copyright (c) 2010 Simon Josefsson <simon@josefsson.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms,
+ * with or without modification, are permitted provided
+ * that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above
+ * copyright notice, this list of conditions and the
+ * following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials
+ * provided with the distribution.
+ *
+ * Neither the name of the copyright holder nor the names
+ * of any other contributors may be used to endorse or
+ * promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ */
+
+#ifndef LIBSSH2_H
+#define LIBSSH2_H 1
+
+#define LIBSSH2_COPYRIGHT "2004-2016 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.8.0"
+
+/* The numeric version number is also available "in parts" by using these
+ defines: */
+#define LIBSSH2_VERSION_MAJOR 1
+#define LIBSSH2_VERSION_MINOR 8
+#define LIBSSH2_VERSION_PATCH 0
+
+/* 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 0x010800
+
+/*
+ * 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 "Tue Oct 25 06:44:33 UTC 2016"
+
+#ifndef RC_INVOKED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#ifdef _WIN32
+# include <basetsd.h>
+# include <winsock2.h>
+#endif
+
+#include <stddef.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+/* Allow alternate API prefix from CFLAGS or calling app */
+#ifndef LIBSSH2_API
+# ifdef LIBSSH2_WIN32
+# ifdef _WINDLL
+# ifdef LIBSSH2_LIBRARY
+# define LIBSSH2_API __declspec(dllexport)
+# else
+# define LIBSSH2_API __declspec(dllimport)
+# endif /* LIBSSH2_LIBRARY */
+# else
+# define LIBSSH2_API
+# endif
+# else /* !LIBSSH2_WIN32 */
+# define LIBSSH2_API
+# endif /* LIBSSH2_WIN32 */
+#endif /* LIBSSH2_API */
+
+#ifdef HAVE_SYS_UIO_H
+# include <sys/uio.h>
+#endif
+
+#if (defined(NETWARE) && !defined(__NOVELL_LIBC__))
+# include <sys/bsdskt.h>
+typedef unsigned char uint8_t;
+typedef unsigned int uint32_t;
+#endif
+
+#ifdef _MSC_VER
+typedef unsigned char uint8_t;
+typedef unsigned int uint32_t;
+typedef unsigned __int64 libssh2_uint64_t;
+typedef __int64 libssh2_int64_t;
+#ifndef ssize_t
+typedef SSIZE_T ssize_t;
+#endif
+#else
+typedef unsigned long long libssh2_uint64_t;
+typedef long long libssh2_int64_t;
+#endif
+
+#ifdef WIN32
+typedef SOCKET libssh2_socket_t;
+#define LIBSSH2_INVALID_SOCKET INVALID_SOCKET
+#else /* !WIN32 */
+typedef int libssh2_socket_t;
+#define LIBSSH2_INVALID_SOCKET -1
+#endif /* WIN32 */
+
+/*
+ * Determine whether there is small or large file support on windows.
+ */
+
+#if defined(_MSC_VER) && !defined(_WIN32_WCE)
+# if (_MSC_VER >= 900) && (_INTEGRAL_MAX_BITS >= 64)
+# define LIBSSH2_USE_WIN32_LARGE_FILES
+# else
+# define LIBSSH2_USE_WIN32_SMALL_FILES
+# endif
+#endif
+
+#if defined(__MINGW32__) && !defined(LIBSSH2_USE_WIN32_LARGE_FILES)
+# define LIBSSH2_USE_WIN32_LARGE_FILES
+#endif
+
+#if defined(__WATCOMC__) && !defined(LIBSSH2_USE_WIN32_LARGE_FILES)
+# define LIBSSH2_USE_WIN32_LARGE_FILES
+#endif
+
+#if defined(__POCC__)
+# undef LIBSSH2_USE_WIN32_LARGE_FILES
+#endif
+
+#if defined(_WIN32) && !defined(LIBSSH2_USE_WIN32_LARGE_FILES) && \
+ !defined(LIBSSH2_USE_WIN32_SMALL_FILES)
+# define LIBSSH2_USE_WIN32_SMALL_FILES
+#endif
+
+/*
+ * Large file (>2Gb) support using WIN32 functions.
+ */
+
+#ifdef LIBSSH2_USE_WIN32_LARGE_FILES
+# include <io.h>
+# include <sys/types.h>
+# include <sys/stat.h>
+# define LIBSSH2_STRUCT_STAT_SIZE_FORMAT "%I64d"
+typedef struct _stati64 libssh2_struct_stat;
+typedef __int64 libssh2_struct_stat_size;
+#endif
+
+/*
+ * Small file (<2Gb) support using WIN32 functions.
+ */
+
+#ifdef LIBSSH2_USE_WIN32_SMALL_FILES
+# include <sys/types.h>
+# include <sys/stat.h>
+# ifndef _WIN32_WCE
+# define LIBSSH2_STRUCT_STAT_SIZE_FORMAT "%d"
+typedef struct _stat libssh2_struct_stat;
+typedef off_t libssh2_struct_stat_size;
+# endif
+#endif
+
+#ifndef LIBSSH2_STRUCT_STAT_SIZE_FORMAT
+# ifdef __VMS
+/* We have to roll our own format here because %z is a C99-ism we don't have. */
+# if __USE_OFF64_T || __USING_STD_STAT
+# define LIBSSH2_STRUCT_STAT_SIZE_FORMAT "%Ld"
+# else
+# define LIBSSH2_STRUCT_STAT_SIZE_FORMAT "%d"
+# endif
+# else
+# define LIBSSH2_STRUCT_STAT_SIZE_FORMAT "%zd"
+# endif
+typedef struct stat libssh2_struct_stat;
+typedef off_t libssh2_struct_stat_size;
+#endif
+
+/* Part of every banner, user specified or not */
+#define LIBSSH2_SSH_BANNER "SSH-2.0-libssh2_" LIBSSH2_VERSION
+
+/* We *could* add a comment here if we so chose */
+#define LIBSSH2_SSH_DEFAULT_BANNER LIBSSH2_SSH_BANNER
+#define LIBSSH2_SSH_DEFAULT_BANNER_WITH_CRLF LIBSSH2_SSH_DEFAULT_BANNER "\r\n"
+
+/* Default generate and safe prime sizes for diffie-hellman-group-exchange-sha1 */
+#define LIBSSH2_DH_GEX_MINGROUP 1024
+#define LIBSSH2_DH_GEX_OPTGROUP 1536
+#define LIBSSH2_DH_GEX_MAXGROUP 2048
+
+/* Defaults for pty requests */
+#define LIBSSH2_TERM_WIDTH 80
+#define LIBSSH2_TERM_HEIGHT 24
+#define LIBSSH2_TERM_WIDTH_PX 0
+#define LIBSSH2_TERM_HEIGHT_PX 0
+
+/* 1/4 second */
+#define LIBSSH2_SOCKET_POLL_UDELAY 250000
+/* 0.25 * 120 == 30 seconds */
+#define LIBSSH2_SOCKET_POLL_MAXLOOPS 120
+
+/* Maximum size to allow a payload to compress to, plays it safe by falling
+ short of spec limits */
+#define LIBSSH2_PACKET_MAXCOMP 32000
+
+/* Maximum size to allow a payload to deccompress to, plays it safe by
+ allowing more than spec requires */
+#define LIBSSH2_PACKET_MAXDECOMP 40000
+
+/* Maximum size for an inbound compressed payload, plays it safe by
+ overshooting spec limits */
+#define LIBSSH2_PACKET_MAXPAYLOAD 40000
+
+/* Malloc callbacks */
+#define LIBSSH2_ALLOC_FUNC(name) void *name(size_t count, void **abstract)
+#define LIBSSH2_REALLOC_FUNC(name) void *name(void *ptr, size_t count, \
+ void **abstract)
+#define LIBSSH2_FREE_FUNC(name) void name(void *ptr, void **abstract)
+
+typedef struct _LIBSSH2_USERAUTH_KBDINT_PROMPT
+{
+ char* text;
+ unsigned int length;
+ unsigned char echo;
+} LIBSSH2_USERAUTH_KBDINT_PROMPT;
+
+typedef struct _LIBSSH2_USERAUTH_KBDINT_RESPONSE
+{
+ char* text;
+ unsigned int length;
+} LIBSSH2_USERAUTH_KBDINT_RESPONSE;
+
+/* 'publickey' authentication callback */
+#define LIBSSH2_USERAUTH_PUBLICKEY_SIGN_FUNC(name) \
+ int name(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len, \
+ const unsigned char *data, size_t data_len, void **abstract)
+
+/* 'keyboard-interactive' authentication callback */
+#define LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC(name_) \
+ void name_(const char* name, int name_len, const char* instruction, \
+ int instruction_len, int num_prompts, \
+ const LIBSSH2_USERAUTH_KBDINT_PROMPT* prompts, \
+ LIBSSH2_USERAUTH_KBDINT_RESPONSE* responses, void **abstract)
+
+/* Callbacks for special SSH packets */
+#define LIBSSH2_IGNORE_FUNC(name) \
+ void name(LIBSSH2_SESSION *session, const char *message, int message_len, \
+ void **abstract)
+
+#define LIBSSH2_DEBUG_FUNC(name) \
+ void name(LIBSSH2_SESSION *session, int always_display, const char *message, \
+ int message_len, const char *language, int language_len, \
+ void **abstract)
+
+#define LIBSSH2_DISCONNECT_FUNC(name) \
+ void name(LIBSSH2_SESSION *session, int reason, const char *message, \
+ int message_len, const char *language, int language_len, \
+ void **abstract)
+
+#define LIBSSH2_PASSWD_CHANGEREQ_FUNC(name) \
+ void name(LIBSSH2_SESSION *session, char **newpw, int *newpw_len, \
+ void **abstract)
+
+#define LIBSSH2_MACERROR_FUNC(name) \
+ int name(LIBSSH2_SESSION *session, const char *packet, int packet_len, \
+ void **abstract)
+
+#define LIBSSH2_X11_OPEN_FUNC(name) \
+ void name(LIBSSH2_SESSION *session, LIBSSH2_CHANNEL *channel, \
+ const char *shost, int sport, void **abstract)
+
+#define LIBSSH2_CHANNEL_CLOSE_FUNC(name) \
+ void name(LIBSSH2_SESSION *session, void **session_abstract, \
+ LIBSSH2_CHANNEL *channel, void **channel_abstract)
+
+/* I/O callbacks */
+#define LIBSSH2_RECV_FUNC(name) ssize_t name(libssh2_socket_t socket, \
+ void *buffer, size_t length, \
+ int flags, void **abstract)
+#define LIBSSH2_SEND_FUNC(name) ssize_t name(libssh2_socket_t socket, \
+ const void *buffer, size_t length,\
+ int flags, void **abstract)
+
+/* libssh2_session_callback_set() constants */
+#define LIBSSH2_CALLBACK_IGNORE 0
+#define LIBSSH2_CALLBACK_DEBUG 1
+#define LIBSSH2_CALLBACK_DISCONNECT 2
+#define LIBSSH2_CALLBACK_MACERROR 3
+#define LIBSSH2_CALLBACK_X11 4
+#define LIBSSH2_CALLBACK_SEND 5
+#define LIBSSH2_CALLBACK_RECV 6
+
+/* libssh2_session_method_pref() constants */
+#define LIBSSH2_METHOD_KEX 0
+#define LIBSSH2_METHOD_HOSTKEY 1
+#define LIBSSH2_METHOD_CRYPT_CS 2
+#define LIBSSH2_METHOD_CRYPT_SC 3
+#define LIBSSH2_METHOD_MAC_CS 4
+#define LIBSSH2_METHOD_MAC_SC 5
+#define LIBSSH2_METHOD_COMP_CS 6
+#define LIBSSH2_METHOD_COMP_SC 7
+#define LIBSSH2_METHOD_LANG_CS 8
+#define LIBSSH2_METHOD_LANG_SC 9
+
+/* flags */
+#define LIBSSH2_FLAG_SIGPIPE 1
+#define LIBSSH2_FLAG_COMPRESS 2
+
+typedef struct _LIBSSH2_SESSION LIBSSH2_SESSION;
+typedef struct _LIBSSH2_CHANNEL LIBSSH2_CHANNEL;
+typedef struct _LIBSSH2_LISTENER LIBSSH2_LISTENER;
+typedef struct _LIBSSH2_KNOWNHOSTS LIBSSH2_KNOWNHOSTS;
+typedef struct _LIBSSH2_AGENT LIBSSH2_AGENT;
+
+typedef struct _LIBSSH2_POLLFD {
+ unsigned char type; /* LIBSSH2_POLLFD_* below */
+
+ union {
+ libssh2_socket_t socket; /* File descriptors -- examined with
+ system select() call */
+ LIBSSH2_CHANNEL *channel; /* Examined by checking internal state */
+ LIBSSH2_LISTENER *listener; /* Read polls only -- are inbound
+ connections waiting to be accepted? */
+ } fd;
+
+ unsigned long events; /* Requested Events */
+ unsigned long revents; /* Returned Events */
+} LIBSSH2_POLLFD;
+
+/* Poll FD Descriptor Types */
+#define LIBSSH2_POLLFD_SOCKET 1
+#define LIBSSH2_POLLFD_CHANNEL 2
+#define LIBSSH2_POLLFD_LISTENER 3
+
+/* Note: Win32 Doesn't actually have a poll() implementation, so some of these
+ values are faked with select() data */
+/* Poll FD events/revents -- Match sys/poll.h where possible */
+#define LIBSSH2_POLLFD_POLLIN 0x0001 /* Data available to be read or
+ connection available --
+ All */
+#define LIBSSH2_POLLFD_POLLPRI 0x0002 /* Priority data available to
+ be read -- Socket only */
+#define LIBSSH2_POLLFD_POLLEXT 0x0002 /* Extended data available to
+ be read -- Channel only */
+#define LIBSSH2_POLLFD_POLLOUT 0x0004 /* Can may be written --
+ Socket/Channel */
+/* revents only */
+#define LIBSSH2_POLLFD_POLLERR 0x0008 /* Error Condition -- Socket */
+#define LIBSSH2_POLLFD_POLLHUP 0x0010 /* HangUp/EOF -- Socket */
+#define LIBSSH2_POLLFD_SESSION_CLOSED 0x0010 /* Session Disconnect */
+#define LIBSSH2_POLLFD_POLLNVAL 0x0020 /* Invalid request -- Socket
+ Only */
+#define LIBSSH2_POLLFD_POLLEX 0x0040 /* Exception Condition --
+ Socket/Win32 */
+#define LIBSSH2_POLLFD_CHANNEL_CLOSED 0x0080 /* Channel Disconnect */
+#define LIBSSH2_POLLFD_LISTENER_CLOSED 0x0080 /* Listener Disconnect */
+
+#define HAVE_LIBSSH2_SESSION_BLOCK_DIRECTION
+/* Block Direction Types */
+#define LIBSSH2_SESSION_BLOCK_INBOUND 0x0001
+#define LIBSSH2_SESSION_BLOCK_OUTBOUND 0x0002
+
+/* Hash Types */
+#define LIBSSH2_HOSTKEY_HASH_MD5 1
+#define LIBSSH2_HOSTKEY_HASH_SHA1 2
+
+/* Hostkey Types */
+#define LIBSSH2_HOSTKEY_TYPE_UNKNOWN 0
+#define LIBSSH2_HOSTKEY_TYPE_RSA 1
+#define LIBSSH2_HOSTKEY_TYPE_DSS 2
+
+/* Disconnect Codes (defined by SSH protocol) */
+#define SSH_DISCONNECT_HOST_NOT_ALLOWED_TO_CONNECT 1
+#define SSH_DISCONNECT_PROTOCOL_ERROR 2
+#define SSH_DISCONNECT_KEY_EXCHANGE_FAILED 3
+#define SSH_DISCONNECT_RESERVED 4
+#define SSH_DISCONNECT_MAC_ERROR 5
+#define SSH_DISCONNECT_COMPRESSION_ERROR 6
+#define SSH_DISCONNECT_SERVICE_NOT_AVAILABLE 7
+#define SSH_DISCONNECT_PROTOCOL_VERSION_NOT_SUPPORTED 8
+#define SSH_DISCONNECT_HOST_KEY_NOT_VERIFIABLE 9
+#define SSH_DISCONNECT_CONNECTION_LOST 10
+#define SSH_DISCONNECT_BY_APPLICATION 11
+#define SSH_DISCONNECT_TOO_MANY_CONNECTIONS 12
+#define SSH_DISCONNECT_AUTH_CANCELLED_BY_USER 13
+#define SSH_DISCONNECT_NO_MORE_AUTH_METHODS_AVAILABLE 14
+#define SSH_DISCONNECT_ILLEGAL_USER_NAME 15
+
+/* Error Codes (defined by libssh2) */
+#define LIBSSH2_ERROR_NONE 0
+
+/* The library once used -1 as a generic error return value on numerous places
+ through the code, which subsequently was converted to
+ LIBSSH2_ERROR_SOCKET_NONE uses over time. As this is a generic error code,
+ the goal is to never ever return this code but instead make sure that a
+ more accurate and descriptive error code is used. */
+#define LIBSSH2_ERROR_SOCKET_NONE -1
+
+#define LIBSSH2_ERROR_BANNER_RECV -2
+#define LIBSSH2_ERROR_BANNER_SEND -3
+#define LIBSSH2_ERROR_INVALID_MAC -4
+#define LIBSSH2_ERROR_KEX_FAILURE -5
+#define LIBSSH2_ERROR_ALLOC -6
+#define LIBSSH2_ERROR_SOCKET_SEND -7
+#define LIBSSH2_ERROR_KEY_EXCHANGE_FAILURE -8
+#define LIBSSH2_ERROR_TIMEOUT -9
+#define LIBSSH2_ERROR_HOSTKEY_INIT -10
+#define LIBSSH2_ERROR_HOSTKEY_SIGN -11
+#define LIBSSH2_ERROR_DECRYPT -12
+#define LIBSSH2_ERROR_SOCKET_DISCONNECT -13
+#define LIBSSH2_ERROR_PROTO -14
+#define LIBSSH2_ERROR_PASSWORD_EXPIRED -15
+#define LIBSSH2_ERROR_FILE -16
+#define LIBSSH2_ERROR_METHOD_NONE -17
+#define LIBSSH2_ERROR_AUTHENTICATION_FAILED -18
+#define LIBSSH2_ERROR_PUBLICKEY_UNRECOGNIZED LIBSSH2_ERROR_AUTHENTICATION_FAILED
+#define LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED -19
+#define LIBSSH2_ERROR_CHANNEL_OUTOFORDER -20
+#define LIBSSH2_ERROR_CHANNEL_FAILURE -21
+#define LIBSSH2_ERROR_CHANNEL_REQUEST_DENIED -22
+#define LIBSSH2_ERROR_CHANNEL_UNKNOWN -23
+#define LIBSSH2_ERROR_CHANNEL_WINDOW_EXCEEDED -24
+#define LIBSSH2_ERROR_CHANNEL_PACKET_EXCEEDED -25
+#define LIBSSH2_ERROR_CHANNEL_CLOSED -26
+#define LIBSSH2_ERROR_CHANNEL_EOF_SENT -27
+#define LIBSSH2_ERROR_SCP_PROTOCOL -28
+#define LIBSSH2_ERROR_ZLIB -29
+#define LIBSSH2_ERROR_SOCKET_TIMEOUT -30
+#define LIBSSH2_ERROR_SFTP_PROTOCOL -31
+#define LIBSSH2_ERROR_REQUEST_DENIED -32
+#define LIBSSH2_ERROR_METHOD_NOT_SUPPORTED -33
+#define LIBSSH2_ERROR_INVAL -34
+#define LIBSSH2_ERROR_INVALID_POLL_TYPE -35
+#define LIBSSH2_ERROR_PUBLICKEY_PROTOCOL -36
+#define LIBSSH2_ERROR_EAGAIN -37
+#define LIBSSH2_ERROR_BUFFER_TOO_SMALL -38
+#define LIBSSH2_ERROR_BAD_USE -39
+#define LIBSSH2_ERROR_COMPRESS -40
+#define LIBSSH2_ERROR_OUT_OF_BOUNDARY -41
+#define LIBSSH2_ERROR_AGENT_PROTOCOL -42
+#define LIBSSH2_ERROR_SOCKET_RECV -43
+#define LIBSSH2_ERROR_ENCRYPT -44
+#define LIBSSH2_ERROR_BAD_SOCKET -45
+#define LIBSSH2_ERROR_KNOWN_HOSTS -46
+
+/* this is a define to provide the old (<= 1.2.7) name */
+#define LIBSSH2_ERROR_BANNER_NONE LIBSSH2_ERROR_BANNER_RECV
+
+/* Global API */
+#define LIBSSH2_INIT_NO_CRYPTO 0x0001
+
+/*
+ * libssh2_init()
+ *
+ * Initialize the libssh2 functions. This typically initialize the
+ * crypto library. It uses a global state, and is not thread safe --
+ * you must make sure this function is not called concurrently.
+ *
+ * Flags can be:
+ * 0: Normal initialize
+ * LIBSSH2_INIT_NO_CRYPTO: Do not initialize the crypto library (ie.
+ * OPENSSL_add_cipher_algoritms() for OpenSSL
+ *
+ * Returns 0 if succeeded, or a negative value for error.
+ */
+LIBSSH2_API int libssh2_init(int flags);
+
+/*
+ * libssh2_exit()
+ *
+ * Exit the libssh2 functions and free's all memory used internal.
+ */
+LIBSSH2_API void libssh2_exit(void);
+
+/*
+ * libssh2_free()
+ *
+ * Deallocate memory allocated by earlier call to libssh2 functions.
+ */
+LIBSSH2_API void libssh2_free(LIBSSH2_SESSION *session, void *ptr);
+
+/*
+ * libssh2_session_supported_algs()
+ *
+ * Fills algs with a list of supported acryptographic algorithms. Returns a
+ * non-negative number (number of supported algorithms) on success or a
+ * negative number (an eror code) on failure.
+ *
+ * NOTE: on success, algs must be deallocated (by calling libssh2_free) when
+ * not needed anymore
+ */
+LIBSSH2_API int libssh2_session_supported_algs(LIBSSH2_SESSION* session,
+ int method_type,
+ const char*** algs);
+
+/* Session API */
+LIBSSH2_API LIBSSH2_SESSION *
+libssh2_session_init_ex(LIBSSH2_ALLOC_FUNC((*my_alloc)),
+ LIBSSH2_FREE_FUNC((*my_free)),
+ LIBSSH2_REALLOC_FUNC((*my_realloc)), void *abstract);
+#define libssh2_session_init() libssh2_session_init_ex(NULL, NULL, NULL, NULL)
+
+LIBSSH2_API void **libssh2_session_abstract(LIBSSH2_SESSION *session);
+
+LIBSSH2_API void *libssh2_session_callback_set(LIBSSH2_SESSION *session,
+ int cbtype, void *callback);
+LIBSSH2_API int libssh2_session_banner_set(LIBSSH2_SESSION *session,
+ const char *banner);
+LIBSSH2_API int libssh2_banner_set(LIBSSH2_SESSION *session,
+ const char *banner);
+
+LIBSSH2_API int libssh2_session_startup(LIBSSH2_SESSION *session, int sock);
+LIBSSH2_API int libssh2_session_handshake(LIBSSH2_SESSION *session,
+ libssh2_socket_t sock);
+LIBSSH2_API int libssh2_session_disconnect_ex(LIBSSH2_SESSION *session,
+ int reason,
+ const char *description,
+ const char *lang);
+#define libssh2_session_disconnect(session, description) \
+ libssh2_session_disconnect_ex((session), SSH_DISCONNECT_BY_APPLICATION, \
+ (description), "")
+
+LIBSSH2_API int libssh2_session_free(LIBSSH2_SESSION *session);
+
+LIBSSH2_API const char *libssh2_hostkey_hash(LIBSSH2_SESSION *session,
+ int hash_type);
+
+LIBSSH2_API const char *libssh2_session_hostkey(LIBSSH2_SESSION *session,
+ size_t *len, int *type);
+
+LIBSSH2_API int libssh2_session_method_pref(LIBSSH2_SESSION *session,
+ int method_type,
+ const char *prefs);
+LIBSSH2_API const char *libssh2_session_methods(LIBSSH2_SESSION *session,
+ int method_type);
+LIBSSH2_API int libssh2_session_last_error(LIBSSH2_SESSION *session,
+ char **errmsg,
+ int *errmsg_len, int want_buf);
+LIBSSH2_API int libssh2_session_last_errno(LIBSSH2_SESSION *session);
+LIBSSH2_API int libssh2_session_set_last_error(LIBSSH2_SESSION* session,
+ int errcode,
+ const char* errmsg);
+LIBSSH2_API int libssh2_session_block_directions(LIBSSH2_SESSION *session);
+
+LIBSSH2_API int libssh2_session_flag(LIBSSH2_SESSION *session, int flag,
+ int value);
+LIBSSH2_API const char *libssh2_session_banner_get(LIBSSH2_SESSION *session);
+
+/* Userauth API */
+LIBSSH2_API char *libssh2_userauth_list(LIBSSH2_SESSION *session,
+ const char *username,
+ unsigned int username_len);
+LIBSSH2_API int libssh2_userauth_authenticated(LIBSSH2_SESSION *session);
+
+LIBSSH2_API int libssh2_userauth_password_ex(LIBSSH2_SESSION *session,
+ const char *username,
+ unsigned int username_len,
+ const char *password,
+ unsigned int password_len,
+ LIBSSH2_PASSWD_CHANGEREQ_FUNC((*passwd_change_cb)));
+
+#define libssh2_userauth_password(session, username, password) \
+ libssh2_userauth_password_ex((session), (username), \
+ (unsigned int)strlen(username), \
+ (password), (unsigned int)strlen(password), NULL)
+
+LIBSSH2_API int
+libssh2_userauth_publickey_fromfile_ex(LIBSSH2_SESSION *session,
+ const char *username,
+ unsigned int username_len,
+ const char *publickey,
+ const char *privatekey,
+ const char *passphrase);
+
+#define libssh2_userauth_publickey_fromfile(session, username, publickey, \
+ privatekey, passphrase) \
+ libssh2_userauth_publickey_fromfile_ex((session), (username), \
+ (unsigned int)strlen(username), \
+ (publickey), \
+ (privatekey), (passphrase))
+
+LIBSSH2_API int
+libssh2_userauth_publickey(LIBSSH2_SESSION *session,
+ const char *username,
+ const unsigned char *pubkeydata,
+ size_t pubkeydata_len,
+ LIBSSH2_USERAUTH_PUBLICKEY_SIGN_FUNC((*sign_callback)),
+ void **abstract);
+
+LIBSSH2_API int
+libssh2_userauth_hostbased_fromfile_ex(LIBSSH2_SESSION *session,
+ const char *username,
+ unsigned int username_len,
+ const char *publickey,
+ const char *privatekey,
+ const char *passphrase,
+ const char *hostname,
+ unsigned int hostname_len,
+ const char *local_username,
+ unsigned int local_username_len);
+
+#define libssh2_userauth_hostbased_fromfile(session, username, publickey, \
+ privatekey, passphrase, hostname) \
+ libssh2_userauth_hostbased_fromfile_ex((session), (username), \
+ (unsigned int)strlen(username), \
+ (publickey), \
+ (privatekey), (passphrase), \
+ (hostname), \
+ (unsigned int)strlen(hostname), \
+ (username), \
+ (unsigned int)strlen(username))
+
+LIBSSH2_API int
+libssh2_userauth_publickey_frommemory(LIBSSH2_SESSION *session,
+ const char *username,
+ size_t username_len,
+ const char *publickeyfiledata,
+ size_t publickeyfiledata_len,
+ const char *privatekeyfiledata,
+ size_t privatekeyfiledata_len,
+ const char *passphrase);
+
+/*
+ * response_callback is provided with filled by library prompts array,
+ * but client must allocate and fill individual responses. Responses
+ * array is already allocated. Responses data will be freed by libssh2
+ * after callback return, but before subsequent callback invokation.
+ */
+LIBSSH2_API int
+libssh2_userauth_keyboard_interactive_ex(LIBSSH2_SESSION* session,
+ const char *username,
+ unsigned int username_len,
+ LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC(
+ (*response_callback)));
+
+#define libssh2_userauth_keyboard_interactive(session, username, \
+ response_callback) \
+ libssh2_userauth_keyboard_interactive_ex((session), (username), \
+ (unsigned int)strlen(username), \
+ (response_callback))
+
+LIBSSH2_API int libssh2_poll(LIBSSH2_POLLFD *fds, unsigned int nfds,
+ long timeout);
+
+/* Channel API */
+#define LIBSSH2_CHANNEL_WINDOW_DEFAULT (2*1024*1024)
+#define LIBSSH2_CHANNEL_PACKET_DEFAULT 32768
+#define LIBSSH2_CHANNEL_MINADJUST 1024
+
+/* Extended Data Handling */
+#define LIBSSH2_CHANNEL_EXTENDED_DATA_NORMAL 0
+#define LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE 1
+#define LIBSSH2_CHANNEL_EXTENDED_DATA_MERGE 2
+
+#define SSH_EXTENDED_DATA_STDERR 1
+
+/* Returned by any function that would block during a read/write opperation */
+#define LIBSSH2CHANNEL_EAGAIN LIBSSH2_ERROR_EAGAIN
+
+LIBSSH2_API LIBSSH2_CHANNEL *
+libssh2_channel_open_ex(LIBSSH2_SESSION *session, const char *channel_type,
+ unsigned int channel_type_len,
+ unsigned int window_size, unsigned int packet_size,
+ const char *message, unsigned int message_len);
+
+#define libssh2_channel_open_session(session) \
+ libssh2_channel_open_ex((session), "session", sizeof("session") - 1, \
+ LIBSSH2_CHANNEL_WINDOW_DEFAULT, \
+ LIBSSH2_CHANNEL_PACKET_DEFAULT, NULL, 0)
+
+LIBSSH2_API LIBSSH2_CHANNEL *
+libssh2_channel_direct_tcpip_ex(LIBSSH2_SESSION *session, const char *host,
+ int port, const char *shost, int sport);
+#define libssh2_channel_direct_tcpip(session, host, port) \
+ libssh2_channel_direct_tcpip_ex((session), (host), (port), "127.0.0.1", 22)
+
+LIBSSH2_API LIBSSH2_LISTENER *
+libssh2_channel_forward_listen_ex(LIBSSH2_SESSION *session, const char *host,
+ int port, int *bound_port, int queue_maxsize);
+#define libssh2_channel_forward_listen(session, port) \
+ libssh2_channel_forward_listen_ex((session), NULL, (port), NULL, 16)
+
+LIBSSH2_API int libssh2_channel_forward_cancel(LIBSSH2_LISTENER *listener);
+
+LIBSSH2_API LIBSSH2_CHANNEL *
+libssh2_channel_forward_accept(LIBSSH2_LISTENER *listener);
+
+LIBSSH2_API int libssh2_channel_setenv_ex(LIBSSH2_CHANNEL *channel,
+ const char *varname,
+ unsigned int varname_len,
+ const char *value,
+ unsigned int value_len);
+
+#define libssh2_channel_setenv(channel, varname, value) \
+ libssh2_channel_setenv_ex((channel), (varname), \
+ (unsigned int)strlen(varname), (value), \
+ (unsigned int)strlen(value))
+
+LIBSSH2_API int libssh2_channel_request_pty_ex(LIBSSH2_CHANNEL *channel,
+ const char *term,
+ unsigned int term_len,
+ const char *modes,
+ unsigned int modes_len,
+ int width, int height,
+ int width_px, int height_px);
+#define libssh2_channel_request_pty(channel, term) \
+ libssh2_channel_request_pty_ex((channel), (term), \
+ (unsigned int)strlen(term), \
+ NULL, 0, \
+ LIBSSH2_TERM_WIDTH, LIBSSH2_TERM_HEIGHT, \
+ LIBSSH2_TERM_WIDTH_PX, LIBSSH2_TERM_HEIGHT_PX)
+
+LIBSSH2_API int libssh2_channel_request_pty_size_ex(LIBSSH2_CHANNEL *channel,
+ int width, int height,
+ int width_px,
+ int height_px);
+#define libssh2_channel_request_pty_size(channel, width, height) \
+ libssh2_channel_request_pty_size_ex( (channel), (width), (height), 0, 0)
+
+LIBSSH2_API int libssh2_channel_x11_req_ex(LIBSSH2_CHANNEL *channel,
+ int single_connection,
+ const char *auth_proto,
+ const char *auth_cookie,
+ int screen_number);
+#define libssh2_channel_x11_req(channel, screen_number) \
+ libssh2_channel_x11_req_ex((channel), 0, NULL, NULL, (screen_number))
+
+LIBSSH2_API int libssh2_channel_process_startup(LIBSSH2_CHANNEL *channel,
+ const char *request,
+ unsigned int request_len,
+ const char *message,
+ unsigned int message_len);
+#define libssh2_channel_shell(channel) \
+ libssh2_channel_process_startup((channel), "shell", sizeof("shell") - 1, \
+ NULL, 0)
+#define libssh2_channel_exec(channel, command) \
+ libssh2_channel_process_startup((channel), "exec", sizeof("exec") - 1, \
+ (command), (unsigned int)strlen(command))
+#define libssh2_channel_subsystem(channel, subsystem) \
+ libssh2_channel_process_startup((channel), "subsystem", \
+ sizeof("subsystem") - 1, (subsystem), \
+ (unsigned int)strlen(subsystem))
+
+LIBSSH2_API ssize_t libssh2_channel_read_ex(LIBSSH2_CHANNEL *channel,
+ int stream_id, char *buf,
+ size_t buflen);
+#define libssh2_channel_read(channel, buf, buflen) \
+ libssh2_channel_read_ex((channel), 0, (buf), (buflen))
+#define libssh2_channel_read_stderr(channel, buf, buflen) \
+ libssh2_channel_read_ex((channel), SSH_EXTENDED_DATA_STDERR, (buf), (buflen))
+
+LIBSSH2_API int libssh2_poll_channel_read(LIBSSH2_CHANNEL *channel,
+ int extended);
+
+LIBSSH2_API unsigned long
+libssh2_channel_window_read_ex(LIBSSH2_CHANNEL *channel,
+ unsigned long *read_avail,
+ unsigned long *window_size_initial);
+#define libssh2_channel_window_read(channel) \
+ libssh2_channel_window_read_ex((channel), NULL, NULL)
+
+/* libssh2_channel_receive_window_adjust is DEPRECATED, do not use! */
+LIBSSH2_API unsigned long
+libssh2_channel_receive_window_adjust(LIBSSH2_CHANNEL *channel,
+ unsigned long adjustment,
+ unsigned char force);
+
+LIBSSH2_API int
+libssh2_channel_receive_window_adjust2(LIBSSH2_CHANNEL *channel,
+ unsigned long adjustment,
+ unsigned char force,
+ unsigned int *storewindow);
+
+LIBSSH2_API ssize_t libssh2_channel_write_ex(LIBSSH2_CHANNEL *channel,
+ int stream_id, const char *buf,
+ size_t buflen);
+
+#define libssh2_channel_write(channel, buf, buflen) \
+ libssh2_channel_write_ex((channel), 0, (buf), (buflen))
+#define libssh2_channel_write_stderr(channel, buf, buflen) \
+ libssh2_channel_write_ex((channel), SSH_EXTENDED_DATA_STDERR, (buf), (buflen))
+
+LIBSSH2_API unsigned long
+libssh2_channel_window_write_ex(LIBSSH2_CHANNEL *channel,
+ unsigned long *window_size_initial);
+#define libssh2_channel_window_write(channel) \
+ libssh2_channel_window_write_ex((channel), NULL)
+
+LIBSSH2_API void libssh2_session_set_blocking(LIBSSH2_SESSION* session,
+ int blocking);
+LIBSSH2_API int libssh2_session_get_blocking(LIBSSH2_SESSION* session);
+
+LIBSSH2_API void libssh2_channel_set_blocking(LIBSSH2_CHANNEL *channel,
+ int blocking);
+
+LIBSSH2_API void libssh2_session_set_timeout(LIBSSH2_SESSION* session,
+ long timeout);
+LIBSSH2_API long libssh2_session_get_timeout(LIBSSH2_SESSION* session);
+
+/* libssh2_channel_handle_extended_data is DEPRECATED, do not use! */
+LIBSSH2_API void libssh2_channel_handle_extended_data(LIBSSH2_CHANNEL *channel,
+ int ignore_mode);
+LIBSSH2_API int libssh2_channel_handle_extended_data2(LIBSSH2_CHANNEL *channel,
+ int ignore_mode);
+
+/* libssh2_channel_ignore_extended_data() is defined below for BC with version
+ * 0.1
+ *
+ * Future uses should use libssh2_channel_handle_extended_data() directly if
+ * LIBSSH2_CHANNEL_EXTENDED_DATA_MERGE is passed, extended data will be read
+ * (FIFO) from the standard data channel
+ */
+/* DEPRECATED */
+#define libssh2_channel_ignore_extended_data(channel, ignore) \
+ libssh2_channel_handle_extended_data((channel), \
+ (ignore) ? \
+ LIBSSH2_CHANNEL_EXTENDED_DATA_IGNORE : \
+ LIBSSH2_CHANNEL_EXTENDED_DATA_NORMAL )
+
+#define LIBSSH2_CHANNEL_FLUSH_EXTENDED_DATA -1
+#define LIBSSH2_CHANNEL_FLUSH_ALL -2
+LIBSSH2_API int libssh2_channel_flush_ex(LIBSSH2_CHANNEL *channel,
+ int streamid);
+#define libssh2_channel_flush(channel) libssh2_channel_flush_ex((channel), 0)
+#define libssh2_channel_flush_stderr(channel) \
+ libssh2_channel_flush_ex((channel), SSH_EXTENDED_DATA_STDERR)
+
+LIBSSH2_API int libssh2_channel_get_exit_status(LIBSSH2_CHANNEL* channel);
+LIBSSH2_API int libssh2_channel_get_exit_signal(LIBSSH2_CHANNEL* channel,
+ char **exitsignal,
+ size_t *exitsignal_len,
+ char **errmsg,
+ size_t *errmsg_len,
+ char **langtag,
+ size_t *langtag_len);
+LIBSSH2_API int libssh2_channel_send_eof(LIBSSH2_CHANNEL *channel);
+LIBSSH2_API int libssh2_channel_eof(LIBSSH2_CHANNEL *channel);
+LIBSSH2_API int libssh2_channel_wait_eof(LIBSSH2_CHANNEL *channel);
+LIBSSH2_API int libssh2_channel_close(LIBSSH2_CHANNEL *channel);
+LIBSSH2_API int libssh2_channel_wait_closed(LIBSSH2_CHANNEL *channel);
+LIBSSH2_API int libssh2_channel_free(LIBSSH2_CHANNEL *channel);
+
+/* libssh2_scp_recv is DEPRECATED, do not use! */
+LIBSSH2_API LIBSSH2_CHANNEL *libssh2_scp_recv(LIBSSH2_SESSION *session,
+ const char *path,
+ struct stat *sb);
+/* Use libssh2_scp_recv2 for large (> 2GB) file support on windows */
+LIBSSH2_API LIBSSH2_CHANNEL *libssh2_scp_recv2(LIBSSH2_SESSION *session,
+ const char *path,
+ libssh2_struct_stat *sb);
+LIBSSH2_API LIBSSH2_CHANNEL *libssh2_scp_send_ex(LIBSSH2_SESSION *session,
+ const char *path, int mode,
+ size_t size, long mtime,
+ long atime);
+LIBSSH2_API LIBSSH2_CHANNEL *
+libssh2_scp_send64(LIBSSH2_SESSION *session, const char *path, int mode,
+ libssh2_int64_t size, time_t mtime, time_t atime);
+
+#define libssh2_scp_send(session, path, mode, size) \
+ libssh2_scp_send_ex((session), (path), (mode), (size), 0, 0)
+
+LIBSSH2_API int libssh2_base64_decode(LIBSSH2_SESSION *session, char **dest,
+ unsigned int *dest_len,
+ const char *src, unsigned int src_len);
+
+LIBSSH2_API
+const char *libssh2_version(int req_version_num);
+
+#define HAVE_LIBSSH2_KNOWNHOST_API 0x010101 /* since 1.1.1 */
+#define HAVE_LIBSSH2_VERSION_API 0x010100 /* libssh2_version since 1.1 */
+
+struct libssh2_knownhost {
+ unsigned int magic; /* magic stored by the library */
+ void *node; /* handle to the internal representation of this host */
+ char *name; /* this is NULL if no plain text host name exists */
+ char *key; /* key in base64/printable format */
+ int typemask;
+};
+
+/*
+ * libssh2_knownhost_init
+ *
+ * Init a collection of known hosts. Returns the pointer to a collection.
+ *
+ */
+LIBSSH2_API LIBSSH2_KNOWNHOSTS *
+libssh2_knownhost_init(LIBSSH2_SESSION *session);
+
+/*
+ * libssh2_knownhost_add
+ *
+ * Add a host and its associated key to the collection of known hosts.
+ *
+ * The 'type' argument specifies on what format the given host and keys are:
+ *
+ * plain - ascii "hostname.domain.tld"
+ * sha1 - SHA1(<salt> <host>) base64-encoded!
+ * custom - another hash
+ *
+ * If 'sha1' is selected as type, the salt must be provided to the salt
+ * argument. This too base64 encoded.
+ *
+ * The SHA-1 hash is what OpenSSH can be told to use in known_hosts files. If
+ * a custom type is used, salt is ignored and you must provide the host
+ * pre-hashed when checking for it in the libssh2_knownhost_check() function.
+ *
+ * The keylen parameter may be omitted (zero) if the key is provided as a
+ * NULL-terminated base64-encoded string.
+ */
+
+/* host format (2 bits) */
+#define LIBSSH2_KNOWNHOST_TYPE_MASK 0xffff
+#define LIBSSH2_KNOWNHOST_TYPE_PLAIN 1
+#define LIBSSH2_KNOWNHOST_TYPE_SHA1 2 /* always base64 encoded */
+#define LIBSSH2_KNOWNHOST_TYPE_CUSTOM 3
+
+/* key format (2 bits) */
+#define LIBSSH2_KNOWNHOST_KEYENC_MASK (3<<16)
+#define LIBSSH2_KNOWNHOST_KEYENC_RAW (1<<16)
+#define LIBSSH2_KNOWNHOST_KEYENC_BASE64 (2<<16)
+
+/* type of key (2 bits) */
+#define LIBSSH2_KNOWNHOST_KEY_MASK (7<<18)
+#define LIBSSH2_KNOWNHOST_KEY_SHIFT 18
+#define LIBSSH2_KNOWNHOST_KEY_RSA1 (1<<18)
+#define LIBSSH2_KNOWNHOST_KEY_SSHRSA (2<<18)
+#define LIBSSH2_KNOWNHOST_KEY_SSHDSS (3<<18)
+#define LIBSSH2_KNOWNHOST_KEY_UNKNOWN (7<<18)
+
+LIBSSH2_API int
+libssh2_knownhost_add(LIBSSH2_KNOWNHOSTS *hosts,
+ const char *host,
+ const char *salt,
+ const char *key, size_t keylen, int typemask,
+ struct libssh2_knownhost **store);
+
+/*
+ * libssh2_knownhost_addc
+ *
+ * Add a host and its associated key to the collection of known hosts.
+ *
+ * Takes a comment argument that may be NULL. A NULL comment indicates
+ * there is no comment and the entry will end directly after the key
+ * when written out to a file. An empty string "" comment will indicate an
+ * empty comment which will cause a single space to be written after the key.
+ *
+ * The 'type' argument specifies on what format the given host and keys are:
+ *
+ * plain - ascii "hostname.domain.tld"
+ * sha1 - SHA1(<salt> <host>) base64-encoded!
+ * custom - another hash
+ *
+ * If 'sha1' is selected as type, the salt must be provided to the salt
+ * argument. This too base64 encoded.
+ *
+ * The SHA-1 hash is what OpenSSH can be told to use in known_hosts files. If
+ * a custom type is used, salt is ignored and you must provide the host
+ * pre-hashed when checking for it in the libssh2_knownhost_check() function.
+ *
+ * The keylen parameter may be omitted (zero) if the key is provided as a
+ * NULL-terminated base64-encoded string.
+ */
+
+LIBSSH2_API int
+libssh2_knownhost_addc(LIBSSH2_KNOWNHOSTS *hosts,
+ const char *host,
+ const char *salt,
+ const char *key, size_t keylen,
+ const char *comment, size_t commentlen, int typemask,
+ struct libssh2_knownhost **store);
+
+/*
+ * libssh2_knownhost_check
+ *
+ * Check a host and its associated key against the collection of known hosts.
+ *
+ * The type is the type/format of the given host name.
+ *
+ * plain - ascii "hostname.domain.tld"
+ * custom - prehashed base64 encoded. Note that this cannot use any salts.
+ *
+ *
+ * 'knownhost' may be set to NULL if you don't care about that info.
+ *
+ * Returns:
+ *
+ * LIBSSH2_KNOWNHOST_CHECK_* values, see below
+ *
+ */
+
+#define LIBSSH2_KNOWNHOST_CHECK_MATCH 0
+#define LIBSSH2_KNOWNHOST_CHECK_MISMATCH 1
+#define LIBSSH2_KNOWNHOST_CHECK_NOTFOUND 2
+#define LIBSSH2_KNOWNHOST_CHECK_FAILURE 3
+
+LIBSSH2_API int
+libssh2_knownhost_check(LIBSSH2_KNOWNHOSTS *hosts,
+ const char *host, const char *key, size_t keylen,
+ int typemask,
+ struct libssh2_knownhost **knownhost);
+
+/* this function is identital to the above one, but also takes a port
+ argument that allows libssh2 to do a better check */
+LIBSSH2_API int
+libssh2_knownhost_checkp(LIBSSH2_KNOWNHOSTS *hosts,
+ const char *host, int port,
+ const char *key, size_t keylen,
+ int typemask,
+ struct libssh2_knownhost **knownhost);
+
+/*
+ * libssh2_knownhost_del
+ *
+ * Remove a host from the collection of known hosts. The 'entry' struct is
+ * retrieved by a call to libssh2_knownhost_check().
+ *
+ */
+LIBSSH2_API int
+libssh2_knownhost_del(LIBSSH2_KNOWNHOSTS *hosts,
+ struct libssh2_knownhost *entry);
+
+/*
+ * libssh2_knownhost_free
+ *
+ * Free an entire collection of known hosts.
+ *
+ */
+LIBSSH2_API void
+libssh2_knownhost_free(LIBSSH2_KNOWNHOSTS *hosts);
+
+/*
+ * libssh2_knownhost_readline()
+ *
+ * Pass in a line of a file of 'type'. It makes libssh2 read this line.
+ *
+ * LIBSSH2_KNOWNHOST_FILE_OPENSSH is the only supported type.
+ *
+ */
+LIBSSH2_API int
+libssh2_knownhost_readline(LIBSSH2_KNOWNHOSTS *hosts,
+ const char *line, size_t len, int type);
+
+/*
+ * libssh2_knownhost_readfile
+ *
+ * Add hosts+key pairs from a given file.
+ *
+ * Returns a negative value for error or number of successfully added hosts.
+ *
+ * This implementation currently only knows one 'type' (openssh), all others
+ * are reserved for future use.
+ */
+
+#define LIBSSH2_KNOWNHOST_FILE_OPENSSH 1
+
+LIBSSH2_API int
+libssh2_knownhost_readfile(LIBSSH2_KNOWNHOSTS *hosts,
+ const char *filename, int type);
+
+/*
+ * libssh2_knownhost_writeline()
+ *
+ * Ask libssh2 to convert a known host to an output line for storage.
+ *
+ * Note that this function returns LIBSSH2_ERROR_BUFFER_TOO_SMALL if the given
+ * output buffer is too small to hold the desired output.
+ *
+ * This implementation currently only knows one 'type' (openssh), all others
+ * are reserved for future use.
+ *
+ */
+LIBSSH2_API int
+libssh2_knownhost_writeline(LIBSSH2_KNOWNHOSTS *hosts,
+ struct libssh2_knownhost *known,
+ char *buffer, size_t buflen,
+ size_t *outlen, /* the amount of written data */
+ int type);
+
+/*
+ * libssh2_knownhost_writefile
+ *
+ * Write hosts+key pairs to a given file.
+ *
+ * This implementation currently only knows one 'type' (openssh), all others
+ * are reserved for future use.
+ */
+
+LIBSSH2_API int
+libssh2_knownhost_writefile(LIBSSH2_KNOWNHOSTS *hosts,
+ const char *filename, int type);
+
+/*
+ * libssh2_knownhost_get()
+ *
+ * Traverse the internal list of known hosts. Pass NULL to 'prev' to get
+ * the first one. Or pass a poiner to the previously returned one to get the
+ * next.
+ *
+ * Returns:
+ * 0 if a fine host was stored in 'store'
+ * 1 if end of hosts
+ * [negative] on errors
+ */
+LIBSSH2_API int
+libssh2_knownhost_get(LIBSSH2_KNOWNHOSTS *hosts,
+ struct libssh2_knownhost **store,
+ struct libssh2_knownhost *prev);
+
+#define HAVE_LIBSSH2_AGENT_API 0x010202 /* since 1.2.2 */
+
+struct libssh2_agent_publickey {
+ unsigned int magic; /* magic stored by the library */
+ void *node; /* handle to the internal representation of key */
+ unsigned char *blob; /* public key blob */
+ size_t blob_len; /* length of the public key blob */
+ char *comment; /* comment in printable format */
+};
+
+/*
+ * libssh2_agent_init
+ *
+ * Init an ssh-agent handle. Returns the pointer to the handle.
+ *
+ */
+LIBSSH2_API LIBSSH2_AGENT *
+libssh2_agent_init(LIBSSH2_SESSION *session);
+
+/*
+ * libssh2_agent_connect()
+ *
+ * Connect to an ssh-agent.
+ *
+ * Returns 0 if succeeded, or a negative value for error.
+ */
+LIBSSH2_API int
+libssh2_agent_connect(LIBSSH2_AGENT *agent);
+
+/*
+ * libssh2_agent_list_identities()
+ *
+ * Request an ssh-agent to list identities.
+ *
+ * Returns 0 if succeeded, or a negative value for error.
+ */
+LIBSSH2_API int
+libssh2_agent_list_identities(LIBSSH2_AGENT *agent);
+
+/*
+ * libssh2_agent_get_identity()
+ *
+ * Traverse the internal list of public keys. Pass NULL to 'prev' to get
+ * the first one. Or pass a poiner to the previously returned one to get the
+ * next.
+ *
+ * Returns:
+ * 0 if a fine public key was stored in 'store'
+ * 1 if end of public keys
+ * [negative] on errors
+ */
+LIBSSH2_API int
+libssh2_agent_get_identity(LIBSSH2_AGENT *agent,
+ struct libssh2_agent_publickey **store,
+ struct libssh2_agent_publickey *prev);
+
+/*
+ * libssh2_agent_userauth()
+ *
+ * Do publickey user authentication with the help of ssh-agent.
+ *
+ * Returns 0 if succeeded, or a negative value for error.
+ */
+LIBSSH2_API int
+libssh2_agent_userauth(LIBSSH2_AGENT *agent,
+ const char *username,
+ struct libssh2_agent_publickey *identity);
+
+/*
+ * libssh2_agent_disconnect()
+ *
+ * Close a connection to an ssh-agent.
+ *
+ * Returns 0 if succeeded, or a negative value for error.
+ */
+LIBSSH2_API int
+libssh2_agent_disconnect(LIBSSH2_AGENT *agent);
+
+/*
+ * libssh2_agent_free()
+ *
+ * Free an ssh-agent handle. This function also frees the internal
+ * collection of public keys.
+ */
+LIBSSH2_API void
+libssh2_agent_free(LIBSSH2_AGENT *agent);
+
+
+/*
+ * libssh2_keepalive_config()
+ *
+ * Set how often keepalive messages should be sent. WANT_REPLY
+ * indicates whether the keepalive messages should request a response
+ * from the server. INTERVAL is number of seconds that can pass
+ * without any I/O, use 0 (the default) to disable keepalives. To
+ * avoid some busy-loop corner-cases, if you specify an interval of 1
+ * it will be treated as 2.
+ *
+ * Note that non-blocking applications are responsible for sending the
+ * keepalive messages using libssh2_keepalive_send().
+ */
+LIBSSH2_API void libssh2_keepalive_config (LIBSSH2_SESSION *session,
+ int want_reply,
+ unsigned interval);
+
+/*
+ * libssh2_keepalive_send()
+ *
+ * Send a keepalive message if needed. SECONDS_TO_NEXT indicates how
+ * many seconds you can sleep after this call before you need to call
+ * it again. Returns 0 on success, or LIBSSH2_ERROR_SOCKET_SEND on
+ * I/O errors.
+ */
+LIBSSH2_API int libssh2_keepalive_send (LIBSSH2_SESSION *session,
+ int *seconds_to_next);
+
+/* NOTE NOTE NOTE
+ libssh2_trace() has no function in builds that aren't built with debug
+ enabled
+ */
+LIBSSH2_API int libssh2_trace(LIBSSH2_SESSION *session, int bitmask);
+#define LIBSSH2_TRACE_TRANS (1<<1)
+#define LIBSSH2_TRACE_KEX (1<<2)
+#define LIBSSH2_TRACE_AUTH (1<<3)
+#define LIBSSH2_TRACE_CONN (1<<4)
+#define LIBSSH2_TRACE_SCP (1<<5)
+#define LIBSSH2_TRACE_SFTP (1<<6)
+#define LIBSSH2_TRACE_ERROR (1<<7)
+#define LIBSSH2_TRACE_PUBLICKEY (1<<8)
+#define LIBSSH2_TRACE_SOCKET (1<<9)
+
+typedef void (*libssh2_trace_handler_func)(LIBSSH2_SESSION*,
+ void*,
+ const char *,
+ size_t);
+LIBSSH2_API int libssh2_trace_sethandler(LIBSSH2_SESSION *session,
+ void* context,
+ libssh2_trace_handler_func callback);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* !RC_INVOKED */
+
+#endif /* LIBSSH2_H */
diff --git a/src/transports/ssh.c b/src/transports/ssh.c
index 4b4ac493c..22c2fa71d 100644
--- a/src/transports/ssh.c
+++ b/src/transports/ssh.c
@@ -5,9 +5,6 @@
* a Linking Exception. For full terms see the included COPYING file.
*/
-#ifdef GIT_SSH
-#include <libssh2.h>
-#endif
#ifndef GIT_WIN32
#include <dlfcn.h>
#endif
@@ -23,6 +20,8 @@
#ifdef GIT_SSH
+#include "libssh2.h"
+
/* These macros allow us to refer to libssh2 symbols while
* supporting dynamic linking.
*/
@@ -75,9 +74,7 @@ DECLARE_LIBSSH2_SYMBOL(libssh2_userauth_list);
DECLARE_LIBSSH2_SYMBOL(libssh2_userauth_password_ex);
DECLARE_LIBSSH2_SYMBOL(libssh2_userauth_publickey);
DECLARE_LIBSSH2_SYMBOL(libssh2_userauth_publickey_fromfile_ex);
-#ifdef GIT_SSH_MEMORY_CREDENTIALS
DECLARE_LIBSSH2_SYMBOL(libssh2_userauth_publickey_frommemory);
-#endif
/* Redefine functions that underlies macros so they use our namespaced versions */
@@ -464,10 +461,14 @@ static int _git_ssh_authenticate_session(
session, c->username, c->prompt_callback);
break;
}
-#ifdef GIT_SSH_MEMORY_CREDENTIALS
case GIT_CREDTYPE_SSH_MEMORY: {
git_cred_ssh_key *c = (git_cred_ssh_key *)cred;
+ if (!git_libssh2_userauth_publickey_frommemory) {
+ rc = LIBSSH2_ERROR_AUTHENTICATION_FAILED;
+ break;
+ }
+
assert(c->username);
assert(c->privatekey);
@@ -482,7 +483,6 @@ static int _git_ssh_authenticate_session(
c->passphrase);
break;
}
-#endif
default:
rc = LIBSSH2_ERROR_AUTHENTICATION_FAILED;
}
@@ -861,9 +861,10 @@ static int list_auth_methods(int *out, LIBSSH2_SESSION *session, const char *use
if (!git__prefixcmp(ptr, SSH_AUTH_PUBLICKEY)) {
*out |= GIT_CREDTYPE_SSH_KEY;
*out |= GIT_CREDTYPE_SSH_CUSTOM;
-#ifdef GIT_SSH_MEMORY_CREDENTIALS
- *out |= GIT_CREDTYPE_SSH_MEMORY;
-#endif
+
+ if (git_libssh2_userauth_publickey_frommemory)
+ *out |= GIT_CREDTYPE_SSH_MEMORY;
+
ptr += strlen(SSH_AUTH_PUBLICKEY);
continue;
}
@@ -980,19 +981,55 @@ int git_transport_ssh_with_paths(git_transport **out, git_remote *owner, void *p
#endif
}
+static const char *supported_filenames[] = {
+#ifdef __APPLE__
+ "libssh2.1.dylib",
+#else
+ "libssh2.so.2.1.0",
+#endif
+ NULL,
+};
+
+/**
+ * Try to load a supported version of libssh2
+ */
+static void load_libssh2(void)
+{
+#ifdef GIT_WIN32
+ /* Windows doesn't do SOVERSIONs but you ship your own library so we're probably OK */
+ git_libssh2_handle = LoadLibrary("libssh2.dll");
+#else
+ int i;
+ for (i = 0; !git_libssh2_handle; i++){
+ const char *filename = supported_filenames[i];
+ if (!filename)
+ break;
+
+ git_libssh2_handle = dlopen(filename, RTLD_LAZY);
+ }
+
+#endif
+}
+
+static void unload_libssh2(void)
+{
+#ifdef GIT_WIN32
+ FreeLibrary(git_libssh2_handle);
+#else
+ dlclose(git_libssh2_handle);
+#endif
+}
+
void git_transport_ssh_global_shutdown(void);
int git_transport_ssh_global_init(void)
{
#ifdef GIT_SSH
-#ifdef GIT_WIN32
- git_libssh2_handle = LoadLibrary(TEXT(GIT_LIBSSH2_SOVERSION));
-#else
- git_libssh2_handle = dlopen(GIT_LIBSSH2_SOVERSION, RTLD_LAZY);
+ load_libssh2();
+
if (git_libssh2_handle == NULL) {
return 0;
}
-#endif
DEFINE_LIBSSH2_SYMBOL(libssh2_agent_connect);
DEFINE_LIBSSH2_SYMBOL(libssh2_agent_disconnect);
@@ -1022,9 +1059,7 @@ int git_transport_ssh_global_init(void)
DEFINE_LIBSSH2_SYMBOL(libssh2_userauth_password_ex);
DEFINE_LIBSSH2_SYMBOL(libssh2_userauth_publickey);
DEFINE_LIBSSH2_SYMBOL(libssh2_userauth_publickey_fromfile_ex);
-#ifdef GIT_SSH_MEMORY_CREDENTIALS
DEFINE_LIBSSH2_SYMBOL(libssh2_userauth_publickey_frommemory);
-#endif
git__on_shutdown(git_transport_ssh_global_shutdown);
@@ -1040,9 +1075,6 @@ int git_transport_ssh_global_init(void)
void git_transport_ssh_global_shutdown(void)
{
-#ifdef GIT_WIN32
- FreeLibrary(git_libssh2_handle);
-#else
- dlclose(git_libssh2_handle);
-#endif
+ unload_libssh2();
+ git_libssh2_handle = NULL;
}