git.c 7.28 KB
Newer Older
1
/*
Edward Thomson committed
2
 * Copyright (C) the libgit2 contributors. All rights reserved.
3
 *
Vicent Marti committed
4 5
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
6 7
 */

8 9
#include "git2.h"
#include "buffer.h"
10
#include "netops.h"
11
#include "git2/sys/transport.h"
12 13
#include "stream.h"
#include "socket_stream.h"
14 15 16 17 18

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

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

typedef struct {
22
	git_smart_subtransport_stream parent;
23
	git_stream *io;
24 25 26
	const char *cmd;
	char *url;
	unsigned sent_command : 1;
27
} git_proto_stream;
28 29 30 31

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

35
/*
36
 * Create a git protocol request.
37 38 39
 *
 * For example: 0035git-upload-pack /libgit2/libgit2\0host=github.com\0
 */
40
static int gen_proto(git_buf *request, const char *cmd, const char *url)
41
{
42
	char *delim, *repo;
43
	char host[] = "host=";
44
	size_t len;
45 46

	delim = strchr(url, '/');
47 48 49 50
	if (delim == NULL) {
		giterr_set(GITERR_NET, "Malformed URL");
		return -1;
	}
51 52 53 54 55 56 57

	repo = delim;

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

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

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

66
	if (git_buf_oom(request))
67
		return -1;
68 69

	return 0;
70 71
}

72
static int send_command(git_proto_stream *s)
73
{
74 75
	int error;
	git_buf request = GIT_BUF_INIT;
76

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

81
	error = git_stream_write(s->io, request.ptr, request.size, 0);
82 83
	if (error >= 0)
		s->sent_command = 1;
84 85

cleanup:
86
	git_buf_free(&request);
87 88
	return error;
}
89

90
static int git_proto_stream_read(
91 92 93 94
	git_smart_subtransport_stream *stream,
	char *buffer,
	size_t buf_size,
	size_t *bytes_read)
95
{
96
	int error;
97
	git_proto_stream *s = (git_proto_stream *)stream;
98
	gitno_buffer buf;
99

100
	*bytes_read = 0;
101

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

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

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

110
	*bytes_read = buf.offset;
111

112
	return 0;
113 114
}

115
static int git_proto_stream_write(
116 117 118
	git_smart_subtransport_stream *stream,
	const char *buffer,
	size_t len)
119
{
120
	int error;
121
	git_proto_stream *s = (git_proto_stream *)stream;
122

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

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

129
static void git_proto_stream_free(git_smart_subtransport_stream *stream)
130
{
131
	git_proto_stream *s = (git_proto_stream *)stream;
132 133 134 135 136 137 138
	git_subtransport *t = OWNING_SUBTRANSPORT(s);
	int ret;

	GIT_UNUSED(ret);

	t->current_stream = NULL;

139
	git_stream_close(s->io);
140
	git_stream_free(s->io);
141
	git__free(s->url);
142
	git__free(s);
143
}
144

145
static int git_proto_stream_alloc(
146 147 148
	git_subtransport *t,
	const char *url,
	const char *cmd,
149 150
	const char *host,
	const char *port,
151 152
	git_smart_subtransport_stream **stream)
{
153
	git_proto_stream *s;
154 155

	if (!stream)
156
		return -1;
157

158
	s = git__calloc(1, sizeof(git_proto_stream));
159
	GITERR_CHECK_ALLOC(s);
160

161
	s->parent.subtransport = &t->parent;
162 163 164
	s->parent.read = git_proto_stream_read;
	s->parent.write = git_proto_stream_write;
	s->parent.free = git_proto_stream_free;
165

166 167 168 169 170
	s->cmd = cmd;
	s->url = git__strdup(url);

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

174 175 176 177 178
	if ((git_socket_stream_new(&s->io, host, port)) < 0)
		return -1;

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

179
	*stream = &s->parent;
180 181 182
	return 0;
}

183
static int _git_uploadpack_ls(
184 185 186
	git_subtransport *t,
	const char *url,
	git_smart_subtransport_stream **stream)
187
{
188 189
	char *host=NULL, *port=NULL, *path=NULL, *user=NULL, *pass=NULL;
	const char *stream_url = url;
190
	git_proto_stream *s;
191
	int error;
Carlos Martín Nieto committed
192

193
	*stream = NULL;
194

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

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

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

203 204 205 206 207
	git__free(host);
	git__free(port);
	git__free(path);
	git__free(user);
	git__free(pass);
208

209

210 211 212 213
	if (error < 0) {
		git_proto_stream_free(*stream);
		return error;
	}
214

215 216 217 218 219 220 221 222 223
	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;
224 225
}

226
static int _git_uploadpack(
227 228 229
	git_subtransport *t,
	const char *url,
	git_smart_subtransport_stream **stream)
230
{
231
	GIT_UNUSED(url);
232

233 234 235
	if (t->current_stream) {
		*stream = &t->current_stream->parent;
		return 0;
236 237
	}

238 239 240 241
	giterr_set(GITERR_NET, "Must call UPLOADPACK_LS before UPLOADPACK");
	return -1;
}

242 243 244 245 246
static int _git_receivepack_ls(
	git_subtransport *t,
	const char *url,
	git_smart_subtransport_stream **stream)
{
247 248
	char *host=NULL, *port=NULL, *path=NULL, *user=NULL, *pass=NULL;
	const char *stream_url = url;
249
	git_proto_stream *s;
250
	int error;
251 252 253

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

256 257 258 259 260 261 262 263 264 265
	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);
266

267 268 269 270 271 272
	if (error < 0) {
		git_proto_stream_free(*stream);
		return error;
	}

	s = (git_proto_stream *) *stream;
273

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

277
	t->current_stream = s;
278

279
	return 0;
280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
}

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;
}

298 299
static int _git_action(
	git_smart_subtransport_stream **stream,
300
	git_smart_subtransport *subtransport,
301 302 303
	const char *url,
	git_smart_service_t action)
{
304
	git_subtransport *t = (git_subtransport *) subtransport;
305 306 307

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

		case GIT_SERVICE_UPLOADPACK:
311 312 313 314 315 316 317
			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);
318 319
	}

320 321
	*stream = NULL;
	return -1;
322 323
}

324 325 326 327 328 329 330 331 332 333 334 335
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)
336
{
337
	git_subtransport *t = (git_subtransport *) subtransport;
338

339
	assert(!t->current_stream);
340

341 342
	git__free(t);
}
343

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

348 349
	GIT_UNUSED(param);

350 351
	if (!out)
		return -1;
352

353
	t = git__calloc(1, sizeof(git_subtransport));
354
	GITERR_CHECK_ALLOC(t);
355

356 357
	t->owner = owner;
	t->parent.action = _git_action;
358
	t->parent.close = _git_close;
359
	t->parent.free = _git_free;
360

361
	*out = (git_smart_subtransport *) t;
362
	return 0;
363
}