thodg/libgit2/src/transports/ssh.c

• Show log

  Commit

• Hash : 70a8c78f
  Author :
  Date : 2013-10-23T12:08:54
  

  Rename the ssh credentials The names from libssh2 are somewhat obtuse for us. We can simplify the usual key/passphrase credential's name, as well as make clearer what the custom signature function is.

Download

• src/transports/ssh.c

• /*
   * Copyright (C) the libgit2 contributors. All rights reserved.
   *
   * This file is part of libgit2, distributed under the GNU GPL v2 with
   * a Linking Exception. For full terms see the included COPYING file.
   */
  
  #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)
  
  static const char prefix_ssh[] = "ssh://";
  static const char cmd_uploadpack[] = "git-upload-pack";
  static const char cmd_receivepack[] = "git-receive-pack";
  
  typedef struct {
  	git_smart_subtransport_stream parent;
  	gitno_socket socket;
  	LIBSSH2_SESSION *session;
  	LIBSSH2_CHANNEL *channel;
  	const char *cmd;
  	char *url;
  	unsigned sent_command : 1;
  } ssh_stream;
  
  typedef struct {
  	git_smart_subtransport parent;
  	transport_smart *owner;
  	ssh_stream *current_stream;
  	git_cred *cred;
  } ssh_subtransport;
  
  static void ssh_error(LIBSSH2_SESSION *session, const char *errmsg)
  {
  	char *ssherr;
  	libssh2_session_last_error(session, &ssherr, NULL, 0);
  
  	giterr_set(GITERR_SSH, "%s: %s", errmsg, ssherr);
  }
  
  /*
   * Create a git protocol request.
   *
   * For example: git-upload-pack '/libgit2/libgit2'
   */
  static int gen_proto(git_buf *request, const char *cmd, const char *url)
  {
  	char *repo;
  
  	if (!git__prefixcmp(url, prefix_ssh)) {
  		url = url + strlen(prefix_ssh);
  		repo = strchr(url, '/');
  	} else {
  		repo = strchr(url, ':');
  		if (repo) repo++;
  	}
  
  	if (!repo) {
  		giterr_set(GITERR_NET, "Malformed git protocol URL");
  		return -1;
  	}
  
  	int len = strlen(cmd) + 1 /* Space */ + 1 /* Quote */ + strlen(repo) + 1 /* Quote */ + 1;
  
  	git_buf_grow(request, len);
  	git_buf_printf(request, "%s '%s'", cmd, repo);
  	git_buf_putc(request, '\0');
  
  	if (git_buf_oom(request))
  		return -1;
  
  	return 0;
  }
  
  static int send_command(ssh_stream *s)
  {
  	int error;
  	git_buf request = GIT_BUF_INIT;
  
  	error = gen_proto(&request, s->cmd, s->url);
  	if (error < 0)
  		goto cleanup;
  
  	error = libssh2_channel_exec(s->channel, request.ptr);
  	if (error < LIBSSH2_ERROR_NONE) {
  		ssh_error(s->session, "SSH could not execute request");
  		goto cleanup;
  	}
  
  	s->sent_command = 1;
  
  cleanup:
  	git_buf_free(&request);
  	return error;
  }
  
  static int ssh_stream_read(
  	git_smart_subtransport_stream *stream,
  	char *buffer,
  	size_t buf_size,
  	size_t *bytes_read)
  {
  	int rc;
  	ssh_stream *s = (ssh_stream *)stream;
  
  	*bytes_read = 0;
  
  	if (!s->sent_command && send_command(s) < 0)
  		return -1;
  
  	if ((rc = libssh2_channel_read(s->channel, buffer, buf_size)) < LIBSSH2_ERROR_NONE) {
  		ssh_error(s->session, "SSH could not read data");;
  		return -1;
  	}
  
  	*bytes_read = rc;
  
  	return 0;
  }
  
  static int ssh_stream_write(
  	git_smart_subtransport_stream *stream,
  	const char *buffer,
  	size_t len)
  {
  	ssh_stream *s = (ssh_stream *)stream;
  
  	if (!s->sent_command && send_command(s) < 0)
  		return -1;
  
  	if (libssh2_channel_write(s->channel, buffer, len) < LIBSSH2_ERROR_NONE) {
  		ssh_error(s->session, "SSH could not write data");
  		return -1;
  	}
  
  	return 0;
  }
  
  static void ssh_stream_free(git_smart_subtransport_stream *stream)
  {
  	ssh_stream *s = (ssh_stream *)stream;
  	ssh_subtransport *t = OWNING_SUBTRANSPORT(s);
  	int ret;
  
  	GIT_UNUSED(ret);
  
  	t->current_stream = NULL;
  
  	if (s->channel) {
  		libssh2_channel_close(s->channel);
  		libssh2_channel_free(s->channel);
  		s->channel = NULL;
  	}
  
  	if (s->session) {
  		libssh2_session_free(s->session);
  		s->session = NULL;
  	}
  
  	if (s->socket.socket) {
  		(void)gitno_close(&s->socket);
  		/* can't do anything here with error return value */
  	}
  
  	git__free(s->url);
  	git__free(s);
  }
  
  static int ssh_stream_alloc(
  	ssh_subtransport *t,
  	const char *url,
  	const char *cmd,
  	git_smart_subtransport_stream **stream)
  {
  	ssh_stream *s;
  
  	assert(stream);
  
  	s = git__calloc(sizeof(ssh_stream), 1);
  	GITERR_CHECK_ALLOC(s);
  
  	s->parent.subtransport = &t->parent;
  	s->parent.read = ssh_stream_read;
  	s->parent.write = ssh_stream_write;
  	s->parent.free = ssh_stream_free;
  
  	s->cmd = cmd;
  
  	s->url = git__strdup(url);
  	if (!s->url) {
  		git__free(s);
  		return -1;
  	}
  
  	*stream = &s->parent;
  	return 0;
  }
  
  static int git_ssh_extract_url_parts(
  	char **host,
  	char **username,
  	const char *url)
  {
  	char *colon, *at;
  	const char *start;
  
  	colon = strchr(url, ':');
  
  	if (colon == NULL) {
  		giterr_set(GITERR_NET, "Malformed URL: missing :");
  		return -1;
  	}
  
  	at = strchr(url, '@');
  	if (at) {
  		start = at + 1;
  		*username = git__substrdup(url, at - url);
  		GITERR_CHECK_ALLOC(*username);
  	} else {
  		start = url;
  		*username = NULL;
  	}
  
  	*host = git__substrdup(start, colon - start);
  	GITERR_CHECK_ALLOC(*host);
  
  	return 0;
  }
  
  static int _git_ssh_authenticate_session(
  	LIBSSH2_SESSION* session,
  	const char *user,
  	git_cred* cred)
  {
  	int rc;
  
  	do {
  		switch (cred->credtype) {
  		case GIT_CREDTYPE_USERPASS_PLAINTEXT: {
  			git_cred_userpass_plaintext *c = (git_cred_userpass_plaintext *)cred;
  			user = c->username ? c->username : user;
  			rc = libssh2_userauth_password(session, user, c->password);
  			break;
  		}
  		case GIT_CREDTYPE_SSH_KEY: {
  			git_cred_ssh_key *c = (git_cred_ssh_key *)cred;
  			user = c->username ? c->username : user;
  			rc = libssh2_userauth_publickey_fromfile(
  				session, c->username, c->publickey, c->privatekey, c->passphrase);
  			break;
  		}
  		case GIT_CREDTYPE_SSH_CUSTOM: {
  			git_cred_ssh_custom *c = (git_cred_ssh_custom *)cred;
  
  			user = c->username ? c->username : user;
  			rc = libssh2_userauth_publickey(
  				session, c->username, (const unsigned char *)c->publickey,
  				c->publickey_len, c->sign_callback, &c->sign_data);
  			break;
  		}
  		default:
  			rc = LIBSSH2_ERROR_AUTHENTICATION_FAILED;
  		}
  	} while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc);
  
  	if (rc != LIBSSH2_ERROR_NONE) {
  		ssh_error(session, "Failed to authenticate SSH session");
  		return -1;
  	}
  
  	return 0;
  }
  
  static int _git_ssh_session_create(
  	LIBSSH2_SESSION** session,
  	gitno_socket socket)
  {
  	int rc = 0;
  	LIBSSH2_SESSION* s;
  
  	assert(session);
  
  	s = libssh2_session_init();
  	if (!s) {
  		giterr_set(GITERR_NET, "Failed to initialize SSH session");
  		return -1;
  	}
  
  	do {
  		rc = libssh2_session_startup(s, socket.socket);
  	} while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc);
  
  	if (rc != LIBSSH2_ERROR_NONE) {
  		ssh_error(s, "Failed to start SSH session");
  		libssh2_session_free(s);
  		return -1;
  	}
  
  	libssh2_session_set_blocking(s, 1);
  
  	*session = s;
  
  	return 0;
  }
  
  static int _git_ssh_setup_conn(
  	ssh_subtransport *t,
  	const char *url,
  	const char *cmd,
  	git_smart_subtransport_stream **stream)
  {
  	char *host, *port=NULL, *user=NULL, *pass=NULL;
  	const char *default_port="22";
  	ssh_stream *s;
  	LIBSSH2_SESSION* session=NULL;
  	LIBSSH2_CHANNEL* channel=NULL;
  
  	*stream = NULL;
  	if (ssh_stream_alloc(t, url, cmd, stream) < 0)
  		return -1;
  
  	s = (ssh_stream *)*stream;
  
  	if (!git__prefixcmp(url, prefix_ssh)) {
  		url = url + strlen(prefix_ssh);
  		if (gitno_extract_url_parts(&host, &port, &user, &pass, url, default_port) < 0)
  			goto on_error;
  	} else {
  		if (git_ssh_extract_url_parts(&host, &user, url) < 0)
  			goto on_error;
  		port = git__strdup(default_port);
  		GITERR_CHECK_ALLOC(port);
  	}
  
  	if (gitno_connect(&s->socket, host, port, 0) < 0)
  		goto on_error;
  
  	if (user && pass) {
  		if (git_cred_userpass_plaintext_new(&t->cred, user, pass) < 0)
  			goto on_error;
  	} else if (t->owner->cred_acquire_cb) {
  		if (t->owner->cred_acquire_cb(
  				&t->cred, t->owner->url, user,
  				GIT_CREDTYPE_USERPASS_PLAINTEXT |
  				GIT_CREDTYPE_SSH_KEY |
  				GIT_CREDTYPE_SSH_CUSTOM,
  				t->owner->cred_acquire_payload) < 0)
  			goto on_error;
  
  		if (!t->cred) {
  			giterr_set(GITERR_SSH, "Callback failed to initialize SSH credentials");
  			goto on_error;
  		}
  	} else {
  		giterr_set(GITERR_SSH, "Cannot set up SSH connection without credentials");
  		goto on_error;
  	}
  	assert(t->cred);
  
  	if (!user && !git_cred_has_username(t->cred)) {
  		giterr_set_str(GITERR_NET, "Cannot authenticate without a username");
  		goto on_error;
  	}
  
  	if (_git_ssh_session_create(&session, s->socket) < 0)
  		goto on_error;
  
  	if (_git_ssh_authenticate_session(session, user, t->cred) < 0)
  		goto on_error;
  
  	channel = libssh2_channel_open_session(session);
  	if (!channel) {
  		ssh_error(session, "Failed to open SSH channel");
  		goto on_error;
  	}
  
  	libssh2_channel_set_blocking(channel, 1);
  
  	s->session = session;
  	s->channel = channel;
  
  	t->current_stream = s;
  	git__free(host);
  	git__free(port);
  	git__free(user);
  	git__free(pass);
  
  	return 0;
  
  on_error:
  	s->session = NULL;
  	s->channel = NULL;
  	t->current_stream = NULL;
  
  	if (*stream)
  		ssh_stream_free(*stream);
  
  	git__free(host);
  	git__free(port);
  	git__free(user);
  	git__free(pass);
  
  	if (session)
  		libssh2_session_free(session);
  
  	return -1;
  }
  
  static int ssh_uploadpack_ls(
  	ssh_subtransport *t,
  	const char *url,
  	git_smart_subtransport_stream **stream)
  {
  	if (_git_ssh_setup_conn(t, url, cmd_uploadpack, stream) < 0)
  		return -1;
  
  	return 0;
  }
  
  static int ssh_uploadpack(
  	ssh_subtransport *t,
  	const char *url,
  	git_smart_subtransport_stream **stream)
  {
  	GIT_UNUSED(url);
  
  	if (t->current_stream) {
  		*stream = &t->current_stream->parent;
  		return 0;
  	}
  
  	giterr_set(GITERR_NET, "Must call UPLOADPACK_LS before UPLOADPACK");
  	return -1;
  }
  
  static int ssh_receivepack_ls(
  	ssh_subtransport *t,
  	const char *url,
  	git_smart_subtransport_stream **stream)
  {
  	if (_git_ssh_setup_conn(t, url, cmd_receivepack, stream) < 0)
  		return -1;
  
  	return 0;
  }
  
  static int ssh_receivepack(
  	ssh_subtransport *t,
  	const char *url,
  	git_smart_subtransport_stream **stream)
  {
  	GIT_UNUSED(url);
  
  	if (t->current_stream) {
  		*stream = &t->current_stream->parent;
  		return 0;
  	}
  
  	giterr_set(GITERR_NET, "Must call RECEIVEPACK_LS before RECEIVEPACK");
  	return -1;
  }
  
  static int _ssh_action(
  	git_smart_subtransport_stream **stream,
  	git_smart_subtransport *subtransport,
  	const char *url,
  	git_smart_service_t action)
  {
  	ssh_subtransport *t = (ssh_subtransport *) subtransport;
  
  	switch (action) {
  		case GIT_SERVICE_UPLOADPACK_LS:
  			return ssh_uploadpack_ls(t, url, stream);
  
  		case GIT_SERVICE_UPLOADPACK:
  			return ssh_uploadpack(t, url, stream);
  
  		case GIT_SERVICE_RECEIVEPACK_LS:
  			return ssh_receivepack_ls(t, url, stream);
  
  		case GIT_SERVICE_RECEIVEPACK:
  			return ssh_receivepack(t, url, stream);
  	}
  
  	*stream = NULL;
  	return -1;
  }
  
  static int _ssh_close(git_smart_subtransport *subtransport)
  {
  	ssh_subtransport *t = (ssh_subtransport *) subtransport;
  
  	assert(!t->current_stream);
  
  	GIT_UNUSED(t);
  
  	return 0;
  }
  
  static void _ssh_free(git_smart_subtransport *subtransport)
  {
  	ssh_subtransport *t = (ssh_subtransport *) subtransport;
  
  	assert(!t->current_stream);
  
  	git__free(t);
  }
  #endif
  
  int git_smart_subtransport_ssh(
  	git_smart_subtransport **out, git_transport *owner)
  {
  #ifdef GIT_SSH
  	ssh_subtransport *t;
  
  	assert(out);
  
  	t = git__calloc(sizeof(ssh_subtransport), 1);
  	GITERR_CHECK_ALLOC(t);
  
  	t->owner = (transport_smart *)owner;
  	t->parent.action = _ssh_action;
  	t->parent.close = _ssh_close;
  	t->parent.free = _ssh_free;
  
  	*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
  }
  

Download