Merge pull request #1695 from arrbee/fix-1695

API should not be ifdeffed

include/git2/common.h

@@ -105,7 +105,8 @@ GIT_EXTERN(void) git_libgit2_version(int *major, int *minor, int *rev);
  */
 typedef enum {
 	GIT_CAP_THREADS			= ( 1 << 0 ),
-	GIT_CAP_HTTPS			= ( 1 << 1 )
+	GIT_CAP_HTTPS			= ( 1 << 1 ),
+	GIT_CAP_SSH				= ( 1 << 2 ),
 } git_cap_t;
 
 /**

include/git2/transport.h

@@ -36,14 +36,15 @@ typedef enum {
 } git_credtype_t;
 
 /* The base structure for all credential types */
-typedef struct git_cred {
+typedef struct git_cred git_cred;
+
+struct git_cred {
 	git_credtype_t credtype;
-	void (*free)(
+	void (*free)(git_cred *cred);
-		struct git_cred *cred);
+};
-} git_cred;
 
 /* A plaintext username and password */
-typedef struct git_cred_userpass_plaintext {
+typedef struct {
 	git_cred parent;
 	char *username;
 	char *password;
@@ -51,6 +52,9 @@ typedef struct git_cred_userpass_plaintext {
 
 #ifdef GIT_SSH
 typedef LIBSSH2_USERAUTH_PUBLICKEY_SIGN_FUNC((*git_cred_sign_callback));
+#else
+typedef int (*git_cred_sign_callback)(void *, ...);
+#endif
 
 /* A ssh key file and passphrase */
 typedef struct git_cred_ssh_keyfile_passphrase {
@@ -68,7 +72,6 @@ typedef struct git_cred_ssh_publickey {
 	void *sign_callback;
 	void *sign_data;
 } git_cred_ssh_publickey;
-#endif
 
 /**
  * Creates a new plain-text username and password credential object.
@@ -84,7 +87,6 @@ GIT_EXTERN(int) git_cred_userpass_plaintext_new(
 	const char *username,
 	const char *password);
 
-#ifdef GIT_SSH
 /**
  * Creates a new ssh key file and passphrase credential object.
  * The supplied credential parameter will be internally duplicated.
@@ -116,9 +118,8 @@ GIT_EXTERN(int) git_cred_ssh_publickey_new(
 	git_cred **out,
 	const char *publickey,
     size_t publickey_len,
-    git_cred_sign_callback,
+    git_cred_sign_callback sign_fn,
     void *sign_data);
-#endif
 
 /**
  * Signature of a function which acquires a credential object.
@@ -152,17 +153,21 @@ typedef enum {
 
 typedef void (*git_transport_message_cb)(const char *str, int len, void *data);
 
-typedef struct git_transport {
+typedef struct git_transport git_transport;
+
+struct git_transport {
 	unsigned int version;
 	/* Set progress and error callbacks */
-	int (*set_callbacks)(struct git_transport *transport,
+	int (*set_callbacks)(
+		git_transport *transport,
 		git_transport_message_cb progress_cb,
 		git_transport_message_cb error_cb,
 		void *payload);
 
 	/* Connect the transport to the remote repository, using the given
 	 * direction. */
-	int (*connect)(struct git_transport *transport,
+	int (*connect)(
+		git_transport *transport,
 		const char *url,
 		git_cred_acquire_cb cred_acquire_cb,
 		void *cred_acquire_payload,
@@ -172,17 +177,19 @@ typedef struct git_transport {
 	/* This function may be called after a successful call to connect(). The
 	 * provided callback is invoked for each ref discovered on the remote
 	 * end. */
-	int (*ls)(struct git_transport *transport,
+	int (*ls)(
+		git_transport *transport,
 		git_headlist_cb list_cb,
 		void *payload);
 
 	/* Executes the push whose context is in the git_push object. */
-	int (*push)(struct git_transport *transport, git_push *push);
+	int (*push)(git_transport *transport, git_push *push);
 
 	/* This function may be called after a successful call to connect(), when
 	 * the direction is FETCH. The function performs a negotiation to calculate
 	 * the wants list for the fetch. */
-	int (*negotiate_fetch)(struct git_transport *transport,
+	int (*negotiate_fetch)(
+		git_transport *transport,
 		git_repository *repo,
 		const git_remote_head * const *refs,
 		size_t count);
@@ -190,28 +197,29 @@ typedef struct git_transport {
 	/* This function may be called after a successful call to negotiate_fetch(),
 	 * when the direction is FETCH. This function retrieves the pack file for
 	 * the fetch from the remote end. */
-	int (*download_pack)(struct git_transport *transport,
+	int (*download_pack)(
+		git_transport *transport,
 		git_repository *repo,
 		git_transfer_progress *stats,
 		git_transfer_progress_callback progress_cb,
 		void *progress_payload);
 
 	/* Checks to see if the transport is connected */
-	int (*is_connected)(struct git_transport *transport);
+	int (*is_connected)(git_transport *transport);
 
 	/* Reads the flags value previously passed into connect() */
-	int (*read_flags)(struct git_transport *transport, int *flags);
+	int (*read_flags)(git_transport *transport, int *flags);
 
 	/* Cancels any outstanding transport operation */
-	void (*cancel)(struct git_transport *transport);
+	void (*cancel)(git_transport *transport);
 
 	/* This function is the reverse of connect() -- it terminates the
 	 * connection to the remote end. */
-	int (*close)(struct git_transport *transport);
+	int (*close)(git_transport *transport);
 
 	/* Frees/destructs the git_transport object. */
-	void (*free)(struct git_transport *transport);
+	void (*free)(git_transport *transport);
-} git_transport;
+};
 
 #define GIT_TRANSPORT_VERSION 1
 #define GIT_TRANSPORT_INIT {GIT_TRANSPORT_VERSION}
@@ -299,35 +307,36 @@ typedef enum {
 	GIT_SERVICE_RECEIVEPACK = 4,
 } git_smart_service_t;
 
-struct git_smart_subtransport;
+typedef struct git_smart_subtransport git_smart_subtransport;
+typedef struct git_smart_subtransport_stream git_smart_subtransport_stream;
 
 /* A stream used by the smart transport to read and write data
  * from a subtransport */
-typedef struct git_smart_subtransport_stream {
+struct git_smart_subtransport_stream {
 	/* The owning subtransport */
-	struct git_smart_subtransport *subtransport;
+	git_smart_subtransport *subtransport;
 
 	int (*read)(
-			struct git_smart_subtransport_stream *stream,
+		git_smart_subtransport_stream *stream,
-			char *buffer,
+		char *buffer,
-			size_t buf_size,
+		size_t buf_size,
-			size_t *bytes_read);
+		size_t *bytes_read);
 
 	int (*write)(
-			struct git_smart_subtransport_stream *stream,
+		git_smart_subtransport_stream *stream,
-			const char *buffer,
+		const char *buffer,
-			size_t len);
+		size_t len);
 
 	void (*free)(
-			struct git_smart_subtransport_stream *stream);
+		git_smart_subtransport_stream *stream);
-} git_smart_subtransport_stream;
+};
 
 /* An implementation of a subtransport which carries data for the
  * smart transport */
-typedef struct git_smart_subtransport {
+struct git_smart_subtransport {
 	int (* action)(
 			git_smart_subtransport_stream **out,
-			struct git_smart_subtransport *transport,
+			git_smart_subtransport *transport,
 			const char *url,
 			git_smart_service_t action);
 
@@ -337,10 +346,10 @@ typedef struct git_smart_subtransport {
 	 *
 	 * 1. UPLOADPACK_LS -> UPLOADPACK
 	 * 2. RECEIVEPACK_LS -> RECEIVEPACK */
-	int (* close)(struct git_smart_subtransport *transport);
+	int (*close)(git_smart_subtransport *transport);
 
-	void (* free)(struct git_smart_subtransport *transport);
+	void (*free)(git_smart_subtransport *transport);
-} git_smart_subtransport;
+};
 
 /* A function which creates a new subtransport for the smart transport */
 typedef int (*git_smart_subtransport_cb)(

src/transports/cred.c

@@ -12,16 +12,17 @@
 static void plaintext_free(struct git_cred *cred)
 {
 	git_cred_userpass_plaintext *c = (git_cred_userpass_plaintext *)cred;
-	size_t pass_len = strlen(c->password);
 
 	git__free(c->username);
 
 	/* Zero the memory which previously held the password */
-	git__memzero(c->password, pass_len);
+	if (c->password) {
-	git__free(c->password);
+		size_t pass_len = strlen(c->password);
-
+		git__memzero(c->password, pass_len);
-	memset(c, 0, sizeof(*c));
+		git__free(c->password);
+	}
 
+	git__memzero(c, sizeof(*c));
 	git__free(c);
 }
 
@@ -59,26 +60,32 @@ int git_cred_userpass_plaintext_new(
 	return 0;
 }
 
-#ifdef GIT_SSH
 static void ssh_keyfile_passphrase_free(struct git_cred *cred)
 {
-	git_cred_ssh_keyfile_passphrase *c = (git_cred_ssh_keyfile_passphrase *)cred;
+	git_cred_ssh_keyfile_passphrase *c =
-	size_t pass_len = strlen(c->passphrase);
+		(git_cred_ssh_keyfile_passphrase *)cred;
-
-    if (c->publickey) {
-        git__free(c->publickey);
-    }
 
+	git__free(c->publickey);
 	git__free(c->privatekey);
 
-    if (c->passphrase) {
+	if (c->passphrase) {
-        /* Zero the memory which previously held the passphrase */
+		/* Zero the memory which previously held the passphrase */
-        git__memzero(c->passphrase, pass_len);
+		size_t pass_len = strlen(c->passphrase);
-        git__free(c->passphrase);
+		git__memzero(c->passphrase, pass_len);
-    }
+		git__free(c->passphrase);
+	}
 
-	memset(c, 0, sizeof(*c));
+	git__memzero(c, sizeof(*c));
+	git__free(c);
+}
 
+static void ssh_publickey_free(struct git_cred *cred)
+{
+	git_cred_ssh_publickey *c = (git_cred_ssh_publickey *)cred;
+
+	git__free(c->publickey);
+
+	git__memzero(c, sizeof(*c));
 	git__free(c);
 }
 
@@ -98,10 +105,10 @@ int git_cred_ssh_keyfile_passphrase_new(
 	c->parent.credtype = GIT_CREDTYPE_SSH_KEYFILE_PASSPHRASE;
 	c->parent.free = ssh_keyfile_passphrase_free;
 
-    c->privatekey = git__strdup(privatekey);
+	c->privatekey = git__strdup(privatekey);
 	GITERR_CHECK_ALLOC(c->privatekey);
 
-    if (publickey) {
+	if (publickey) {
 		c->publickey = git__strdup(publickey);
 		GITERR_CHECK_ALLOC(c->publickey);
 	}
@@ -115,48 +122,34 @@ int git_cred_ssh_keyfile_passphrase_new(
 	return 0;
 }
 
-static void ssh_publickey_free(struct git_cred *cred)
-{
-	git_cred_ssh_publickey *c = (git_cred_ssh_publickey *)cred;
-
-    git__free(c->publickey);
-
-    c->sign_callback = NULL;
-    c->sign_data = NULL;
-    
-	memset(c, 0, sizeof(*c));
-
-	git__free(c);
-}
-
 int git_cred_ssh_publickey_new(
 	git_cred **cred,
 	const char *publickey,
-    size_t publickey_len,
+	size_t publickey_len,
-	LIBSSH2_USERAUTH_PUBLICKEY_SIGN_FUNC((*sign_callback)),
+	git_cred_sign_callback sign_callback,
-    void *sign_data)
+	void *sign_data)
 {
 	git_cred_ssh_publickey *c;
 
-	if (!cred)
+	assert(cred);
-		return -1;
 
-	c = git__malloc(sizeof(git_cred_ssh_publickey));
+	c = git__calloc(1, sizeof(git_cred_ssh_publickey));
 	GITERR_CHECK_ALLOC(c);
 
 	c->parent.credtype = GIT_CREDTYPE_SSH_PUBLICKEY;
 	c->parent.free = ssh_publickey_free;
 
-    c->publickey = git__malloc(publickey_len);
+	if (publickey_len > 0) {
-	GITERR_CHECK_ALLOC(c->publickey);
+		c->publickey = git__malloc(publickey_len);
+		GITERR_CHECK_ALLOC(c->publickey);
 
-    memcpy(c->publickey, publickey, publickey_len);
+		memcpy(c->publickey, publickey, publickey_len);
+	}
 
-    c->publickey_len = publickey_len;
+	c->publickey_len = publickey_len;
-    c->sign_callback = sign_callback;
+	c->sign_callback = sign_callback;
-    c->sign_data = sign_data;
+	c->sign_data = sign_data;
 
 	*cred = &c->parent;
 	return 0;
 }
-#endif

src/transports/ssh.c

@@ -5,13 +5,13 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#ifdef GIT_SSH
-
 #include "git2.h"
 #include "buffer.h"
 #include "netops.h"
 #include "smart.h"
 
+#ifdef GIT_SSH
+
 #include <libssh2.h>
 
 #define OWNING_SUBTRANSPORT(s) ((ssh_subtransport *)(s)->parent.subtransport)
@@ -496,13 +496,15 @@ static void _ssh_free(git_smart_subtransport *subtransport)
 
 	git__free(t);
 }
+#endif
 
-int git_smart_subtransport_ssh(git_smart_subtransport **out, git_transport *owner)
+int git_smart_subtransport_ssh(
+	git_smart_subtransport **out, git_transport *owner)
 {
+#ifdef GIT_SSH
 	ssh_subtransport *t;
 
-	if (!out)
+	assert(out);
-		return -1;
 
 	t = git__calloc(sizeof(ssh_subtransport), 1);
 	GITERR_CHECK_ALLOC(t);
@@ -514,6 +516,13 @@ int git_smart_subtransport_ssh(git_smart_subtransport **out, git_transport *owne
 
 	*out = (git_smart_subtransport *) t;
 	return 0;
-}
+#else
+	GIT_UNUSED(owner);
 
+	assert(out);
+	*out = NULL;
+
+	giterr_set(GITERR_INVALID, "Cannot create SSH transport. Library was built without SSH support");
+	return -1;
 #endif
+}

src/util.c

@@ -32,6 +32,9 @@ int git_libgit2_capabilities()
 #endif
 #if defined(GIT_SSL) || defined(GIT_WINHTTP)
 		| GIT_CAP_HTTPS
+#endif
+#if defined(GIT_SSH)
+		| GIT_CAP_SSH
 #endif
 	;
 }

tests-clar/core/caps.c

@@ -0,0 +1,31 @@
+#include "clar_libgit2.h"
+
+void test_core_caps__0(void)
+{
+	int major, minor, rev, caps;
+
+	git_libgit2_version(&major, &minor, &rev);
+	cl_assert_equal_i(LIBGIT2_VER_MAJOR, major);
+	cl_assert_equal_i(LIBGIT2_VER_MINOR, minor);
+	cl_assert_equal_i(LIBGIT2_VER_REVISION, rev);
+
+	caps = git_libgit2_capabilities();
+
+#ifdef GIT_THREADS
+	cl_assert((caps & GIT_CAP_THREADS) != 0);
+#else
+	cl_assert((caps & GIT_CAP_THREADS) == 0);
+#endif
+
+#if defined(GIT_SSL) || defined(GIT_WINHTTP)
+	cl_assert((caps & GIT_CAP_HTTPS) != 0);
+#else
+	cl_assert((caps & GIT_CAP_HTTPS) == 0);
+#endif
+
+#if defined(GIT_SSH)
+	cl_assert((caps & GIT_CAP_SSH) != 0);
+#else
+	cl_assert((caps & GIT_CAP_SSH) == 0);
+#endif
+}