src/transports/git.c - third_party/libgit2 - Git at Google

 /*
  * 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 "git2/sys/transport.h"
 #include "stream.h"
 #include "socket_stream.h"

 #define OWNING_SUBTRANSPORT(s) ((git_subtransport *)(s)->parent.subtransport)

 static const char prefix_git[] = "git://";
 static const char cmd_uploadpack[] = "git-upload-pack";
 static const char cmd_receivepack[] = "git-receive-pack";

 typedef struct {
 	git_smart_subtransport_stream parent;
 	git_stream *io;
 	const char *cmd;
 	char *url;
 	unsigned sent_command : 1;
 } git_proto_stream;

 typedef struct {
 	git_smart_subtransport parent;
 	git_transport *owner;
 	git_proto_stream *current_stream;
 } git_subtransport;

 /*
  * Create a git protocol request.
  *
  * For example: 0035git-upload-pack /libgit2/libgit2\0host=github.com\0
  */
 static int gen_proto(git_buf *request, const char *cmd, const char *url)
 {
 	char *delim, *repo;
 	char host[] = "host=";
 	size_t len;

 	delim = strchr(url, '/');
 	if (delim == NULL) {
 		giterr_set(GITERR_NET, "malformed URL");
 		return -1;
 	}

 	repo = delim;
 	if (repo[1] == '~')
 		++repo;

 	delim = strchr(url, ':');
 	if (delim == NULL)
 		delim = strchr(url, '/');

 	len = 4 + strlen(cmd) + 1 + strlen(repo) + 1 + strlen(host) + (delim - url) + 1;

 	git_buf_grow(request, len);
 	git_buf_printf(request, "%04x%s %s%c%s",
 		(unsigned int)(len & 0x0FFFF), cmd, repo, 0, host);
 	git_buf_put(request, url, delim - url);
 	git_buf_putc(request, '\0');

 	if (git_buf_oom(request))
 		return -1;

 	return 0;
 }

 static int send_command(git_proto_stream *s)
 {
 	int error;
 	git_buf request = GIT_BUF_INIT;

 	error = gen_proto(&request, s->cmd, s->url);
 	if (error < 0)
 		goto cleanup;

 	error = git_stream_write(s->io, request.ptr, request.size, 0);
 	if (error >= 0)
 		s->sent_command = 1;

 cleanup:
 	git_buf_free(&request);
 	return error;
 }

 static int git_proto_stream_read(
 	git_smart_subtransport_stream *stream,
 	char *buffer,
 	size_t buf_size,
 	size_t *bytes_read)
 {
 	int error;
 	git_proto_stream *s = (git_proto_stream *)stream;
 	gitno_buffer buf;

 	*bytes_read = 0;

 	if (!s->sent_command && (error = send_command(s)) < 0)
 		return error;

 	gitno_buffer_setup_fromstream(s->io, &buf, buffer, buf_size);

 	if ((error = gitno_recv(&buf)) < 0)
 		return error;

 	*bytes_read = buf.offset;

 	return 0;
 }

 static int git_proto_stream_write(
 	git_smart_subtransport_stream *stream,
 	const char *buffer,
 	size_t len)
 {
 	int error;
 	git_proto_stream *s = (git_proto_stream *)stream;

 	if (!s->sent_command && (error = send_command(s)) < 0)
 		return error;

 	return git_stream_write(s->io, buffer, len, 0);
 }

 static void git_proto_stream_free(git_smart_subtransport_stream *stream)
 {
 	git_proto_stream *s;
 	git_subtransport *t;

 	if (!stream)
 		return;

 	s = (git_proto_stream *)stream;
 	t = OWNING_SUBTRANSPORT(s);

 	t->current_stream = NULL;

 	git_stream_close(s->io);
 	git_stream_free(s->io);
 	git__free(s->url);
 	git__free(s);
 }

 static int git_proto_stream_alloc(
 	git_subtransport *t,
 	const char *url,
 	const char *cmd,
 	const char *host,
 	const char *port,
 	git_smart_subtransport_stream **stream)
 {
 	git_proto_stream *s;

 	if (!stream)
 		return -1;

 	s = git__calloc(1, sizeof(git_proto_stream));
 	GITERR_CHECK_ALLOC(s);

 	s->parent.subtransport = &t->parent;
 	s->parent.read = git_proto_stream_read;
 	s->parent.write = git_proto_stream_write;
 	s->parent.free = git_proto_stream_free;

 	s->cmd = cmd;
 	s->url = git__strdup(url);

 	if (!s->url) {
 		git__free(s);
 		return -1;
 	}

 	if ((git_socket_stream_new(&s->io, host, port)) < 0)
 		return -1;

 	GITERR_CHECK_VERSION(s->io, GIT_STREAM_VERSION, "git_stream");

 	*stream = &s->parent;
 	return 0;
 }

 static int _git_uploadpack_ls(
 	git_subtransport *t,
 	const char *url,
 	git_smart_subtransport_stream **stream)
 {
 	char *host=NULL, *port=NULL, *path=NULL, *user=NULL, *pass=NULL;
 	const char *stream_url = url;
 	git_proto_stream *s;
 	int error;

 	*stream = NULL;

 	if (!git__prefixcmp(url, prefix_git))
 		stream_url += strlen(prefix_git);

 	if ((error = gitno_extract_url_parts(&host, &port, &path, &user, &pass, url, GIT_DEFAULT_PORT)) < 0)
 		return error;

 	error = git_proto_stream_alloc(t, stream_url, cmd_uploadpack, host, port, stream);

 	git__free(host);
 	git__free(port);
 	git__free(path);
 	git__free(user);
 	git__free(pass);


 	if (error < 0) {
 		git_proto_stream_free(*stream);
 		return error;
 	}

 	s = (git_proto_stream *) *stream;
 	if ((error = git_stream_connect(s->io)) < 0) {
 		git_proto_stream_free(*stream);
 		return error;
 	}

 	t->current_stream = s;

 	return 0;
 }

 static int _git_uploadpack(
 	git_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 _git_receivepack_ls(
 	git_subtransport *t,
 	const char *url,
 	git_smart_subtransport_stream **stream)
 {
 	char *host=NULL, *port=NULL, *path=NULL, *user=NULL, *pass=NULL;
 	const char *stream_url = url;
 	git_proto_stream *s;
 	int error;

 	*stream = NULL;
 	if (!git__prefixcmp(url, prefix_git))
 		stream_url += strlen(prefix_git);

 	if ((error = gitno_extract_url_parts(&host, &port, &path, &user, &pass, url, GIT_DEFAULT_PORT)) < 0)
 		return error;

 	error = git_proto_stream_alloc(t, stream_url, cmd_receivepack, host, port, stream);

 	git__free(host);
 	git__free(port);
 	git__free(path);
 	git__free(user);
 	git__free(pass);

 	if (error < 0) {
 		git_proto_stream_free(*stream);
 		return error;
 	}

 	s = (git_proto_stream *) *stream;

 	if ((error = git_stream_connect(s->io)) < 0)
 		return error;

 	t->current_stream = s;

 	return 0;
 }

 static int _git_receivepack(
 	git_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 _git_action(
 	git_smart_subtransport_stream **stream,
 	git_smart_subtransport *subtransport,
 	const char *url,
 	git_smart_service_t action)
 {
 	git_subtransport *t = (git_subtransport *) subtransport;

 	switch (action) {
 		case GIT_SERVICE_UPLOADPACK_LS:
 			return _git_uploadpack_ls(t, url, stream);

 		case GIT_SERVICE_UPLOADPACK:
 			return _git_uploadpack(t, url, stream);

 		case GIT_SERVICE_RECEIVEPACK_LS:
 			return _git_receivepack_ls(t, url, stream);

 		case GIT_SERVICE_RECEIVEPACK:
 			return _git_receivepack(t, url, stream);
 	}

 	*stream = NULL;
 	return -1;
 }

 static int _git_close(git_smart_subtransport *subtransport)
 {
 	git_subtransport *t = (git_subtransport *) subtransport;

 	assert(!t->current_stream);

 	GIT_UNUSED(t);

 	return 0;
 }

 static void _git_free(git_smart_subtransport *subtransport)
 {
 	git_subtransport *t = (git_subtransport *) subtransport;

 	assert(!t->current_stream);

 	git__free(t);
 }

 int git_smart_subtransport_git(git_smart_subtransport **out, git_transport *owner, void *param)
 {
 	git_subtransport *t;

 	GIT_UNUSED(param);

 	if (!out)
 		return -1;

 	t = git__calloc(1, sizeof(git_subtransport));
 	GITERR_CHECK_ALLOC(t);

 	t->owner = owner;
 	t->parent.action = _git_action;
 	t->parent.close = _git_close;
 	t->parent.free = _git_free;

 	*out = (git_smart_subtransport *) t;
 	return 0;
 }
	/*
	* 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 "git2/sys/transport.h"
	#include "stream.h"
	#include "socket_stream.h"

	#define OWNING_SUBTRANSPORT(s) ((git_subtransport *)(s)->parent.subtransport)

	static const char prefix_git[] = "git://";
	static const char cmd_uploadpack[] = "git-upload-pack";
	static const char cmd_receivepack[] = "git-receive-pack";

	typedef struct {
	git_smart_subtransport_stream parent;
	git_stream *io;
	const char *cmd;
	char *url;
	unsigned sent_command : 1;
	} git_proto_stream;

	typedef struct {
	git_smart_subtransport parent;
	git_transport *owner;
	git_proto_stream *current_stream;
	} git_subtransport;

	/*
	* Create a git protocol request.
	*
	* For example: 0035git-upload-pack /libgit2/libgit2\0host=github.com\0
	*/
	static int gen_proto(git_buf request, const char cmd, const char *url)
	{
	char delim, repo;
	char host[] = "host=";
	size_t len;

	delim = strchr(url, '/');
	if (delim == NULL) {
	giterr_set(GITERR_NET, "malformed URL");
	return -1;
	}

	repo = delim;
	if (repo[1] == '~')
	++repo;

	delim = strchr(url, ':');
	if (delim == NULL)
	delim = strchr(url, '/');

	len = 4 + strlen(cmd) + 1 + strlen(repo) + 1 + strlen(host) + (delim - url) + 1;

	git_buf_grow(request, len);
	git_buf_printf(request, "%04x%s %s%c%s",
	(unsigned int)(len & 0x0FFFF), cmd, repo, 0, host);
	git_buf_put(request, url, delim - url);
	git_buf_putc(request, '\0');

	if (git_buf_oom(request))
	return -1;

	return 0;
	}

	static int send_command(git_proto_stream *s)
	{
	int error;
	git_buf request = GIT_BUF_INIT;

	error = gen_proto(&request, s->cmd, s->url);
	if (error < 0)
	goto cleanup;

	error = git_stream_write(s->io, request.ptr, request.size, 0);
	if (error >= 0)
	s->sent_command = 1;

	cleanup:
	git_buf_free(&request);
	return error;
	}

	static int git_proto_stream_read(
	git_smart_subtransport_stream *stream,
	char *buffer,
	size_t buf_size,
	size_t *bytes_read)
	{
	int error;
	git_proto_stream s = (git_proto_stream )stream;
	gitno_buffer buf;

	*bytes_read = 0;

	if (!s->sent_command && (error = send_command(s)) < 0)
	return error;

	gitno_buffer_setup_fromstream(s->io, &buf, buffer, buf_size);

	if ((error = gitno_recv(&buf)) < 0)
	return error;

	*bytes_read = buf.offset;

	return 0;
	}

	static int git_proto_stream_write(
	git_smart_subtransport_stream *stream,
	const char *buffer,
	size_t len)
	{
	int error;
	git_proto_stream s = (git_proto_stream )stream;

	if (!s->sent_command && (error = send_command(s)) < 0)
	return error;

	return git_stream_write(s->io, buffer, len, 0);
	}

	static void git_proto_stream_free(git_smart_subtransport_stream *stream)
	{
	git_proto_stream *s;
	git_subtransport *t;

	if (!stream)
	return;

	s = (git_proto_stream *)stream;
	t = OWNING_SUBTRANSPORT(s);

	t->current_stream = NULL;

	git_stream_close(s->io);
	git_stream_free(s->io);
	git__free(s->url);
	git__free(s);
	}

	static int git_proto_stream_alloc(
	git_subtransport *t,
	const char *url,
	const char *cmd,
	const char *host,
	const char *port,
	git_smart_subtransport_stream **stream)
	{
	git_proto_stream *s;

	if (!stream)
	return -1;

	s = git__calloc(1, sizeof(git_proto_stream));
	GITERR_CHECK_ALLOC(s);

	s->parent.subtransport = &t->parent;
	s->parent.read = git_proto_stream_read;
	s->parent.write = git_proto_stream_write;
	s->parent.free = git_proto_stream_free;

	s->cmd = cmd;
	s->url = git__strdup(url);

	if (!s->url) {
	git__free(s);
	return -1;
	}

	if ((git_socket_stream_new(&s->io, host, port)) < 0)
	return -1;

	GITERR_CHECK_VERSION(s->io, GIT_STREAM_VERSION, "git_stream");

	*stream = &s->parent;
	return 0;
	}

	static int _git_uploadpack_ls(
	git_subtransport *t,
	const char *url,
	git_smart_subtransport_stream **stream)
	{
	char host=NULL, port=NULL, path=NULL, user=NULL, *pass=NULL;
	const char *stream_url = url;
	git_proto_stream *s;
	int error;

	*stream = NULL;

	if (!git__prefixcmp(url, prefix_git))
	stream_url += strlen(prefix_git);

	if ((error = gitno_extract_url_parts(&host, &port, &path, &user, &pass, url, GIT_DEFAULT_PORT)) < 0)
	return error;

	error = git_proto_stream_alloc(t, stream_url, cmd_uploadpack, host, port, stream);

	git__free(host);
	git__free(port);
	git__free(path);
	git__free(user);
	git__free(pass);


	if (error < 0) {
	git_proto_stream_free(*stream);
	return error;
	}

	s = (git_proto_stream ) stream;
	if ((error = git_stream_connect(s->io)) < 0) {
	git_proto_stream_free(*stream);
	return error;
	}

	t->current_stream = s;

	return 0;
	}

	static int _git_uploadpack(
	git_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 _git_receivepack_ls(
	git_subtransport *t,
	const char *url,
	git_smart_subtransport_stream **stream)
	{
	char host=NULL, port=NULL, path=NULL, user=NULL, *pass=NULL;
	const char *stream_url = url;
	git_proto_stream *s;
	int error;

	*stream = NULL;
	if (!git__prefixcmp(url, prefix_git))
	stream_url += strlen(prefix_git);

	if ((error = gitno_extract_url_parts(&host, &port, &path, &user, &pass, url, GIT_DEFAULT_PORT)) < 0)
	return error;

	error = git_proto_stream_alloc(t, stream_url, cmd_receivepack, host, port, stream);

	git__free(host);
	git__free(port);
	git__free(path);
	git__free(user);
	git__free(pass);

	if (error < 0) {
	git_proto_stream_free(*stream);
	return error;
	}

	s = (git_proto_stream ) stream;

	if ((error = git_stream_connect(s->io)) < 0)
	return error;

	t->current_stream = s;

	return 0;
	}

	static int _git_receivepack(
	git_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 _git_action(
	git_smart_subtransport_stream **stream,
	git_smart_subtransport *subtransport,
	const char *url,
	git_smart_service_t action)
	{
	git_subtransport t = (git_subtransport ) subtransport;

	switch (action) {
	case GIT_SERVICE_UPLOADPACK_LS:
	return _git_uploadpack_ls(t, url, stream);

	case GIT_SERVICE_UPLOADPACK:
	return _git_uploadpack(t, url, stream);

	case GIT_SERVICE_RECEIVEPACK_LS:
	return _git_receivepack_ls(t, url, stream);

	case GIT_SERVICE_RECEIVEPACK:
	return _git_receivepack(t, url, stream);
	}

	*stream = NULL;
	return -1;
	}

	static int _git_close(git_smart_subtransport *subtransport)
	{
	git_subtransport t = (git_subtransport ) subtransport;

	assert(!t->current_stream);

	GIT_UNUSED(t);

	return 0;
	}

	static void _git_free(git_smart_subtransport *subtransport)
	{
	git_subtransport t = (git_subtransport ) subtransport;

	assert(!t->current_stream);

	git__free(t);
	}

	int git_smart_subtransport_git(git_smart_subtransport *out, git_transport owner, void *param)
	{
	git_subtransport *t;

	GIT_UNUSED(param);

	if (!out)
	return -1;

	t = git__calloc(1, sizeof(git_subtransport));
	GITERR_CHECK_ALLOC(t);

	t->owner = owner;
	t->parent.action = _git_action;
	t->parent.close = _git_close;
	t->parent.free = _git_free;

	out = (git_smart_subtransport ) t;
	return 0;
	}