commit.c 23.1 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 "commit.h"

10 11 12
#include "git2/common.h"
#include "git2/object.h"
#include "git2/repository.h"
13
#include "git2/signature.h"
14
#include "git2/mailmap.h"
15
#include "git2/sys/commit.h"
16

Vicent Marti committed
17
#include "odb.h"
18
#include "commit.h"
19
#include "signature.h"
20
#include "message.h"
21
#include "refs.h"
22
#include "object.h"
23
#include "array.h"
24
#include "oidarray.h"
25

26
void git_commit__free(void *_commit)
27
{
28 29
	git_commit *commit = _commit;

30
	git_array_clear(commit->parent_ids);
31

32 33
	git_signature_free(commit->author);
	git_signature_free(commit->committer);
34

35
	git__free(commit->raw_header);
36
	git__free(commit->raw_message);
37
	git__free(commit->message_encoding);
38
	git__free(commit->summary);
39
	git__free(commit->body);
40

41
	git__free(commit);
42 43
}

44 45
static int git_commit__create_buffer_internal(
	git_buf *out,
46 47 48 49 50
	const git_signature *author,
	const git_signature *committer,
	const char *message_encoding,
	const char *message,
	const git_oid *tree,
51
	git_array_oid_t *parents)
Vicent Marti committed
52
{
53 54
	size_t i = 0;
	const git_oid *parent;
Vicent Marti committed
55

56 57
	GIT_ASSERT_ARG(out);
	GIT_ASSERT_ARG(tree);
58

59
	git_oid__writebuf(out, "tree ", tree);
60

61 62 63
	for (i = 0; i < git_array_size(*parents); i++) {
		parent = git_array_get(*parents, i);
		git_oid__writebuf(out, "parent ", parent);
64 65
	}

66 67 68 69 70 71 72
	git_signature__writebuf(out, "author ", author);
	git_signature__writebuf(out, "committer ", committer);

	if (message_encoding != NULL)
		git_buf_printf(out, "encoding %s\n", message_encoding);

	git_buf_putc(out, '\n');
73

74 75 76 77 78 79
	if (git_buf_puts(out, message) < 0)
		goto on_error;

	return 0;

on_error:
80
	git_buf_dispose(out);
81 82
	return -1;
}
83

84
static int validate_tree_and_parents(git_array_oid_t *parents, git_repository *repo, const git_oid *tree,
85 86
	git_commit_parent_callback parent_cb, void *parent_payload,
	const git_oid *current_id, bool validate)
87 88 89 90 91 92
{
	size_t i;
	int error;
	git_oid *parent_cpy;
	const git_oid *parent;

93
	if (validate && !git_object__is_valid(repo, tree, GIT_OBJECT_TREE))
94 95 96
		return -1;

	i = 0;
97
	while ((parent = parent_cb(i, parent_payload)) != NULL) {
98
		if (validate && !git_object__is_valid(repo, parent, GIT_OBJECT_COMMIT)) {
99 100 101 102
			error = -1;
			goto on_error;
		}

103
		parent_cpy = git_array_alloc(*parents);
104
		GIT_ERROR_CHECK_ALLOC(parent_cpy);
105 106

		git_oid_cpy(parent_cpy, parent);
107 108 109
		i++;
	}

110
	if (current_id && (parents->size == 0 || git_oid_cmp(current_id, git_array_get(*parents, 0)))) {
111
		git_error_set(GIT_ERROR_OBJECT, "failed to create commit: current tip is not the first parent");
112 113
		error = GIT_EMODIFIED;
		goto on_error;
114
	}
115

116
	return 0;
117

118 119 120 121
on_error:
	git_array_clear(*parents);
	return error;
}
122

123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
static int git_commit__create_internal(
	git_oid *id,
	git_repository *repo,
	const char *update_ref,
	const git_signature *author,
	const git_signature *committer,
	const char *message_encoding,
	const char *message,
	const git_oid *tree,
	git_commit_parent_callback parent_cb,
	void *parent_payload,
	bool validate)
{
	int error;
	git_odb *odb;
	git_reference *ref = NULL;
	git_buf buf = GIT_BUF_INIT;
	const git_oid *current_id = NULL;
	git_array_oid_t parents = GIT_ARRAY_INIT;
142

143 144 145 146 147
	if (update_ref) {
		error = git_reference_lookup_resolved(&ref, repo, update_ref, 10);
		if (error < 0 && error != GIT_ENOTFOUND)
			return error;
	}
148
	git_error_clear();
149 150 151 152 153 154 155

	if (ref)
		current_id = git_reference_target(ref);

	if ((error = validate_tree_and_parents(&parents, repo, tree, parent_cb, parent_payload, current_id, validate)) < 0)
		goto cleanup;

156
	error = git_commit__create_buffer_internal(&buf, author, committer,
157 158
		message_encoding, message, tree,
		&parents);
159 160 161

	if (error < 0)
		goto cleanup;
162

163
	if (git_repository_odb__weakptr(&odb, repo) < 0)
164
		goto cleanup;
165 166 167

	if (git_odb__freshen(odb, tree) < 0)
		goto cleanup;
168

169
	if (git_odb_write(id, odb, buf.ptr, buf.size, GIT_OBJECT_COMMIT) < 0)
170
		goto cleanup;
Vicent Marti committed
171

172

173
	if (update_ref != NULL) {
174
		error = git_reference__update_for_commit(
175
			repo, ref, update_ref, id, "commit");
176
		goto cleanup;
177
	}
Vicent Marti committed
178

179 180 181
cleanup:
	git_array_clear(parents);
	git_reference_free(ref);
182
	git_buf_dispose(&buf);
183
	return error;
184 185
}

186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202
int git_commit_create_from_callback(
	git_oid *id,
	git_repository *repo,
	const char *update_ref,
	const git_signature *author,
	const git_signature *committer,
	const char *message_encoding,
	const char *message,
	const git_oid *tree,
	git_commit_parent_callback parent_cb,
	void *parent_payload)
{
	return git_commit__create_internal(
		id, repo, update_ref, author, committer, message_encoding, message,
		tree, parent_cb, parent_payload, true);
}

203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
typedef struct {
	size_t total;
	va_list args;
} commit_parent_varargs;

static const git_oid *commit_parent_from_varargs(size_t curr, void *payload)
{
	commit_parent_varargs *data = payload;
	const git_commit *commit;
	if (curr >= data->total)
		return NULL;
	commit = va_arg(data->args, const git_commit *);
	return commit ? git_commit_id(commit) : NULL;
}

int git_commit_create_v(
	git_oid *id,
	git_repository *repo,
	const char *update_ref,
	const git_signature *author,
	const git_signature *committer,
	const char *message_encoding,
	const char *message,
	const git_tree *tree,
	size_t parent_count,
	...)
{
	int error = 0;
	commit_parent_varargs data;

233 234
	GIT_ASSERT_ARG(tree);
	GIT_ASSERT_ARG(git_tree_owner(tree) == repo);
235 236 237 238

	data.total = parent_count;
	va_start(data.args, parent_count);

239
	error = git_commit__create_internal(
240 241
		id, repo, update_ref, author, committer,
		message_encoding, message, git_tree_id(tree),
242
		commit_parent_from_varargs, &data, false);
243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272

	va_end(data.args);
	return error;
}

typedef struct {
	size_t total;
	const git_oid **parents;
} commit_parent_oids;

static const git_oid *commit_parent_from_ids(size_t curr, void *payload)
{
	commit_parent_oids *data = payload;
	return (curr < data->total) ? data->parents[curr] : NULL;
}

int git_commit_create_from_ids(
	git_oid *id,
	git_repository *repo,
	const char *update_ref,
	const git_signature *author,
	const git_signature *committer,
	const char *message_encoding,
	const char *message,
	const git_oid *tree,
	size_t parent_count,
	const git_oid *parents[])
{
	commit_parent_oids data = { parent_count, parents };

273
	return git_commit__create_internal(
274 275
		id, repo, update_ref, author, committer,
		message_encoding, message, tree,
276
		commit_parent_from_ids, &data, true);
277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
}

typedef struct {
	size_t total;
	const git_commit **parents;
	git_repository *repo;
} commit_parent_data;

static const git_oid *commit_parent_from_array(size_t curr, void *payload)
{
	commit_parent_data *data = payload;
	const git_commit *commit;
	if (curr >= data->total)
		return NULL;
	commit = data->parents[curr];
	if (git_commit_owner(commit) != data->repo)
		return NULL;
	return git_commit_id(commit);
}

297
int git_commit_create(
298
	git_oid *id,
299 300 301 302 303 304 305
	git_repository *repo,
	const char *update_ref,
	const git_signature *author,
	const git_signature *committer,
	const char *message_encoding,
	const char *message,
	const git_tree *tree,
306
	size_t parent_count,
307
	const git_commit *parents[])
308
{
309
	commit_parent_data data = { parent_count, parents, repo };
310

311 312
	GIT_ASSERT_ARG(tree);
	GIT_ASSERT_ARG(git_tree_owner(tree) == repo);
313

314
	return git_commit__create_internal(
315 316
		id, repo, update_ref, author, committer,
		message_encoding, message, git_tree_id(tree),
317
		commit_parent_from_array, &data, false);
318
}
319

320 321 322 323 324 325 326
static const git_oid *commit_parent_for_amend(size_t curr, void *payload)
{
	const git_commit *commit_to_amend = payload;
	if (curr >= git_array_size(commit_to_amend->parent_ids))
		return NULL;
	return git_array_get(commit_to_amend->parent_ids, curr);
}
327

328 329 330 331 332 333 334 335 336 337 338 339
int git_commit_amend(
	git_oid *id,
	const git_commit *commit_to_amend,
	const char *update_ref,
	const git_signature *author,
	const git_signature *committer,
	const char *message_encoding,
	const char *message,
	const git_tree *tree)
{
	git_repository *repo;
	git_oid tree_id;
340 341
	git_reference *ref;
	int error;
342

343 344
	GIT_ASSERT_ARG(id);
	GIT_ASSERT_ARG(commit_to_amend);
345 346 347 348 349 350 351 352 353 354 355 356 357 358

	repo = git_commit_owner(commit_to_amend);

	if (!author)
		author = git_commit_author(commit_to_amend);
	if (!committer)
		committer = git_commit_committer(commit_to_amend);
	if (!message_encoding)
		message_encoding = git_commit_message_encoding(commit_to_amend);
	if (!message)
		message = git_commit_message(commit_to_amend);

	if (!tree) {
		git_tree *old_tree;
359
		GIT_ERROR_CHECK_ERROR( git_commit_tree(&old_tree, commit_to_amend) );
360 361 362
		git_oid_cpy(&tree_id, git_tree_id(old_tree));
		git_tree_free(old_tree);
	} else {
363
		GIT_ASSERT_ARG(git_tree_owner(tree) == repo);
364 365
		git_oid_cpy(&tree_id, git_tree_id(tree));
	}
366

367 368 369 370 371 372
	if (update_ref) {
		if ((error = git_reference_lookup_resolved(&ref, repo, update_ref, 5)) < 0)
			return error;

		if (git_oid_cmp(git_commit_id(commit_to_amend), git_reference_target(ref))) {
			git_reference_free(ref);
373
			git_error_set(GIT_ERROR_REFERENCE, "commit to amend is not the tip of the given branch");
374 375 376 377
			return -1;
		}
	}

378
	error = git_commit__create_internal(
379
		id, repo, NULL, author, committer, message_encoding, message,
380
		&tree_id, commit_parent_for_amend, (void *)commit_to_amend, false);
381 382

	if (!error && update_ref) {
383
		error = git_reference__update_for_commit(
384
			repo, ref, NULL, id, "commit");
385 386 387 388
		git_reference_free(ref);
	}

	return error;
389 390
}

391
static int commit_parse(git_commit *commit, const char *data, size_t size, unsigned int flags)
392
{
393 394
	const char *buffer_start = data, *buffer;
	const char *buffer_end = buffer_start + size;
Vicent Marti committed
395
	git_oid parent_id;
Russell Belfer committed
396
	size_t header_len;
397
	git_signature dummy_sig;
398

399 400
	GIT_ASSERT_ARG(commit);
	GIT_ASSERT_ARG(data);
401

402
	buffer = buffer_start;
403

404 405
	/* Allocate for one, which will allow not to realloc 90% of the time  */
	git_array_init_to_size(commit->parent_ids, 1);
406
	GIT_ERROR_CHECK_ARRAY(commit->parent_ids);
407

408
	/* The tree is always the first field */
409 410 411 412 413 414 415 416 417
	if (!(flags & GIT_COMMIT_PARSE_QUICK)) {
	    if (git_oid__parse(&commit->tree_id, &buffer, buffer_end, "tree ") < 0)
			goto bad_buffer;
	} else {
		size_t tree_len = strlen("tree ") + GIT_OID_HEXSZ + 1;
		if (buffer + tree_len > buffer_end)
			goto bad_buffer;
		buffer += tree_len;
	}
418

419 420 421
	/*
	 * TODO: commit grafts!
	 */
422

Vicent Marti committed
423
	while (git_oid__parse(&parent_id, &buffer, buffer_end, "parent ") == 0) {
424
		git_oid *new_id = git_array_alloc(commit->parent_ids);
425
		GIT_ERROR_CHECK_ALLOC(new_id);
426

Vicent Marti committed
427
		git_oid_cpy(new_id, &parent_id);
428
	}
429

430 431 432
	if (!(flags & GIT_COMMIT_PARSE_QUICK)) {
		commit->author = git__malloc(sizeof(git_signature));
		GIT_ERROR_CHECK_ALLOC(commit->author);
433

434 435 436
		if (git_signature__parse(commit->author, &buffer, buffer_end, "author ", '\n') < 0)
			return -1;
	}
437

438
	/* Some tools create multiple author fields, ignore the extra ones */
439
	while (!git__prefixncmp(buffer, buffer_end - buffer, "author ")) {
440 441 442 443 444 445 446
		if (git_signature__parse(&dummy_sig, &buffer, buffer_end, "author ", '\n') < 0)
			return -1;

		git__free(dummy_sig.name);
		git__free(dummy_sig.email);
	}

447
	/* Always parse the committer; we need the commit time */
448
	commit->committer = git__malloc(sizeof(git_signature));
449
	GIT_ERROR_CHECK_ALLOC(commit->committer);
450 451 452

	if (git_signature__parse(commit->committer, &buffer, buffer_end, "committer ", '\n') < 0)
		return -1;
453

454 455 456
	if (flags & GIT_COMMIT_PARSE_QUICK)
		return 0;

457 458
	/* Parse add'l header entries */
	while (buffer < buffer_end) {
459
		const char *eoln = buffer;
460 461 462
		if (buffer[-1] == '\n' && buffer[0] == '\n')
			break;

463 464
		while (eoln < buffer_end && *eoln != '\n')
			++eoln;
465

466
		if (git__prefixncmp(buffer, buffer_end - buffer, "encoding ") == 0) {
467
			buffer += strlen("encoding ");
468

469
			commit->message_encoding = git__strndup(buffer, eoln - buffer);
470
			GIT_ERROR_CHECK_ALLOC(commit->message_encoding);
471
		}
472

473 474
		if (eoln < buffer_end && *eoln == '\n')
			++eoln;
475
		buffer = eoln;
476
	}
477

478 479
	header_len = buffer - buffer_start;
	commit->raw_header = git__strndup(buffer_start, header_len);
480
	GIT_ERROR_CHECK_ALLOC(commit->raw_header);
481

482 483
	/* point "buffer" to data after header, +1 for the final LF */
	buffer = buffer_start + header_len + 1;
484

485
	/* extract commit message */
486
	if (buffer <= buffer_end)
487
		commit->raw_message = git__strndup(buffer, buffer_end - buffer);
488 489
	else
		commit->raw_message = git__strdup("");
490
	GIT_ERROR_CHECK_ALLOC(commit->raw_message);
491

492 493 494
	return 0;

bad_buffer:
495
	git_error_set(GIT_ERROR_OBJECT, "failed to parse bad commit object");
496
	return -1;
497
}
498

499 500 501 502 503 504 505 506 507 508
int git_commit__parse_raw(void *commit, const char *data, size_t size)
{
	return commit_parse(commit, data, size, 0);
}

int git_commit__parse_ext(git_commit *commit, git_odb_object *odb_obj, unsigned int flags)
{
	return commit_parse(commit, git_odb_object_data(odb_obj), git_odb_object_size(odb_obj), flags);
}

509 510
int git_commit__parse(void *_commit, git_odb_object *odb_obj)
{
511
	return git_commit__parse_ext(_commit, odb_obj, 0);
512 513
}

514
#define GIT_COMMIT_GETTER(_rvalue, _name, _return, _invalid) \
Vicent Marti committed
515
	_rvalue git_commit_##_name(const git_commit *commit) \
516
	{\
517
		GIT_ASSERT_ARG_WITH_RETVAL(commit, _invalid); \
518
		return _return; \
519 520
	}

521 522 523 524 525 526 527 528 529
GIT_COMMIT_GETTER(const git_signature *, author, commit->author, NULL)
GIT_COMMIT_GETTER(const git_signature *, committer, commit->committer, NULL)
GIT_COMMIT_GETTER(const char *, message_raw, commit->raw_message, NULL)
GIT_COMMIT_GETTER(const char *, message_encoding, commit->message_encoding, NULL)
GIT_COMMIT_GETTER(const char *, raw_header, commit->raw_header, NULL)
GIT_COMMIT_GETTER(git_time_t, time, commit->committer->when.time, INT64_MIN)
GIT_COMMIT_GETTER(int, time_offset, commit->committer->when.offset, -1)
GIT_COMMIT_GETTER(unsigned int, parentcount, (unsigned int)git_array_size(commit->parent_ids), 0)
GIT_COMMIT_GETTER(const git_oid *, tree_id, &commit->tree_id, NULL)
530

531 532
const char *git_commit_message(const git_commit *commit)
{
533
	const char *message;
534

535
	GIT_ASSERT_ARG_WITH_RETVAL(commit, NULL);
536

537 538
	message = commit->raw_message;

539 540 541 542 543 544 545
	/* trim leading newlines from raw message */
	while (*message && *message == '\n')
		++message;

	return message;
}

546 547 548 549
const char *git_commit_summary(git_commit *commit)
{
	git_buf summary = GIT_BUF_INIT;
	const char *msg, *space;
550
	bool space_contains_newline = false;
551

552
	GIT_ASSERT_ARG_WITH_RETVAL(commit, NULL);
553 554 555

	if (!commit->summary) {
		for (msg = git_commit_message(commit), space = NULL; *msg; ++msg) {
556 557 558
			char next_character = msg[0];
			/* stop processing at the end of the first paragraph */
			if (next_character == '\n' && (!msg[1] || msg[1] == '\n'))
559
				break;
560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580
			/* record the beginning of contiguous whitespace runs */
			else if (git__isspace(next_character)) {
				if(space == NULL) {
					space = msg;
					space_contains_newline = false;
				}
				space_contains_newline |= next_character == '\n';
			}
			/* the next character is non-space */
			else {
				/* process any recorded whitespace */
				if (space) {
					if(space_contains_newline)
						git_buf_putc(&summary, ' '); /* if the space contains a newline, collapse to ' ' */
					else
						git_buf_put(&summary, space, (msg - space)); /* otherwise copy it */
					space = NULL;
				}
				/* copy the next character */
				git_buf_putc(&summary, next_character);
			}
581 582
		}

583 584
		commit->summary = git_buf_detach(&summary);
		if (!commit->summary)
585
			commit->summary = git__strdup("");
586 587 588 589 590
	}

	return commit->summary;
}

591 592 593 594
const char *git_commit_body(git_commit *commit)
{
	const char *msg, *end;

595
	GIT_ASSERT_ARG_WITH_RETVAL(commit, NULL);
596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611

	if (!commit->body) {
		/* search for end of summary */
		for (msg = git_commit_message(commit); *msg; ++msg)
			if (msg[0] == '\n' && (!msg[1] || msg[1] == '\n'))
				break;

		/* trim leading and trailing whitespace */
		for (; *msg; ++msg)
			if (!git__isspace(*msg))
				break;
		for (end = msg + strlen(msg) - 1; msg <= end; --end)
			if (!git__isspace(*end))
				break;

		if (*msg)
612
			commit->body = git__strndup(msg, end - msg + 1);
613 614 615 616 617
	}

	return commit->body;
}

Vicent Marti committed
618
int git_commit_tree(git_tree **tree_out, const git_commit *commit)
619
{
620
	GIT_ASSERT_ARG(commit);
Vicent Marti committed
621
	return git_tree_lookup(tree_out, commit->object.repo, &commit->tree_id);
622
}
623

624 625
const git_oid *git_commit_parent_id(
	const git_commit *commit, unsigned int n)
626
{
627
	GIT_ASSERT_ARG_WITH_RETVAL(commit, NULL);
628

629
	return git_array_get(commit->parent_ids, n);
630 631
}

632 633
int git_commit_parent(
	git_commit **parent, const git_commit *commit, unsigned int n)
634
{
Vicent Marti committed
635
	const git_oid *parent_id;
636
	GIT_ASSERT_ARG(commit);
637

Vicent Marti committed
638 639
	parent_id = git_commit_parent_id(commit, n);
	if (parent_id == NULL) {
640
		git_error_set(GIT_ERROR_INVALID, "parent %u does not exist", n);
641 642
		return GIT_ENOTFOUND;
	}
643

Vicent Marti committed
644
	return git_commit_lookup(parent, commit->object.repo, parent_id);
645
}
646 647 648 649 650 651

int git_commit_nth_gen_ancestor(
	git_commit **ancestor,
	const git_commit *commit,
	unsigned int n)
{
652
	git_commit *current, *parent = NULL;
653 654
	int error;

655 656
	GIT_ASSERT_ARG(ancestor);
	GIT_ASSERT_ARG(commit);
657

658
	if (git_commit_dup(&current, (git_commit *)commit) < 0)
659
		return -1;
660

661 662 663 664
	if (n == 0) {
		*ancestor = current;
		return 0;
	}
665 666

	while (n--) {
667
		error = git_commit_parent(&parent, current, 0);
668

669
		git_commit_free(current);
670 671 672 673 674 675 676 677 678 679

		if (error < 0)
			return error;

		current = parent;
	}

	*ancestor = parent;
	return 0;
}
680 681 682

int git_commit_header_field(git_buf *out, const git_commit *commit, const char *field)
{
683
	const char *eol, *buf = commit->raw_header;
684

685
	git_buf_clear(out);
686

687
	while ((eol = strchr(buf, '\n'))) {
688 689 690 691 692 693 694 695 696
		/* We can skip continuations here */
		if (buf[0] == ' ') {
			buf = eol + 1;
			continue;
		}

		/* Skip until we find the field we're after */
		if (git__prefixcmp(buf, field)) {
			buf = eol + 1;
697 698 699
			continue;
		}

700 701 702 703
		buf += strlen(field);
		/* Check that we're not matching a prefix but the field itself */
		if (buf[0] != ' ') {
			buf = eol + 1;
704 705 706
			continue;
		}

707
		buf++; /* skip the SP */
708

709
		git_buf_put(out, buf, eol - buf);
710 711 712 713 714 715
		if (git_buf_oom(out))
			goto oom;

		/* If the next line starts with SP, it's multi-line, we must continue */
		while (eol[1] == ' ') {
			git_buf_putc(out, '\n');
716 717
			buf = eol + 2;
			eol = strchr(buf, '\n');
718 719 720
			if (!eol)
				goto malformed;

721
			git_buf_put(out, buf, eol - buf);
722 723 724 725 726 727 728 729
		}

		if (git_buf_oom(out))
			goto oom;

		return 0;
	}

730
	git_error_set(GIT_ERROR_OBJECT, "no such field '%s'", field);
731 732 733
	return GIT_ENOTFOUND;

malformed:
734
	git_error_set(GIT_ERROR_OBJECT, "malformed header");
735 736
	return -1;
oom:
737
	git_error_set_oom();
738 739
	return -1;
}
740 741 742 743 744 745 746 747 748

int git_commit_extract_signature(git_buf *signature, git_buf *signed_data, git_repository *repo, git_oid *commit_id, const char *field)
{
	git_odb_object *obj;
	git_odb *odb;
	const char *buf;
	const char *h, *eol;
	int error;

749 750
	git_buf_clear(signature);
	git_buf_clear(signed_data);
751 752 753 754 755 756 757 758 759 760

	if (!field)
		field = "gpgsig";

	if ((error = git_repository_odb__weakptr(&odb, repo)) < 0)
		return error;

	if ((error = git_odb_read(&obj, odb, commit_id)) < 0)
		return error;

761
	if (obj->cached.type != GIT_OBJECT_COMMIT) {
762
		git_error_set(GIT_ERROR_INVALID, "the requested type does not match the type in the ODB");
763 764 765 766
		error = GIT_ENOTFOUND;
		goto cleanup;
	}

767 768
	buf = git_odb_object_data(obj);

769
	while ((h = strchr(buf, '\n')) && h[1] != '\0') {
770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808
		h++;
		if (git__prefixcmp(buf, field)) {
			if (git_buf_put(signed_data, buf, h - buf) < 0)
				return -1;

			buf = h;
			continue;
		}

		h = buf;
		h += strlen(field);
		eol = strchr(h, '\n');
		if (h[0] != ' ') {
			buf = h;
			continue;
		}
		if (!eol)
			goto malformed;

		h++; /* skip the SP */

		git_buf_put(signature, h, eol - h);
		if (git_buf_oom(signature))
			goto oom;

		/* If the next line starts with SP, it's multi-line, we must continue */
		while (eol[1] == ' ') {
			git_buf_putc(signature, '\n');
			h = eol + 2;
			eol = strchr(h, '\n');
			if (!eol)
				goto malformed;

			git_buf_put(signature, h, eol - h);
		}

		if (git_buf_oom(signature))
			goto oom;

809
		error = git_buf_puts(signed_data, eol+1);
810
		git_odb_object_free(obj);
811
		return error;
812 813
	}

814
	git_error_set(GIT_ERROR_OBJECT, "this commit is not signed");
815 816 817 818
	error = GIT_ENOTFOUND;
	goto cleanup;

malformed:
819
	git_error_set(GIT_ERROR_OBJECT, "malformed header");
820 821 822
	error = -1;
	goto cleanup;
oom:
823
	git_error_set_oom();
824 825 826 827 828 829 830 831 832
	error = -1;
	goto cleanup;

cleanup:
	git_odb_object_free(obj);
	git_buf_clear(signature);
	git_buf_clear(signed_data);
	return error;
}
833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848

int git_commit_create_buffer(git_buf *out,
	git_repository *repo,
	const git_signature *author,
	const git_signature *committer,
	const char *message_encoding,
	const char *message,
	const git_tree *tree,
	size_t parent_count,
	const git_commit *parents[])
{
	int error;
	commit_parent_data data = { parent_count, parents, repo };
	git_array_oid_t parents_arr = GIT_ARRAY_INIT;
	const git_oid *tree_id;

849 850
	GIT_ASSERT_ARG(tree);
	GIT_ASSERT_ARG(git_tree_owner(tree) == repo);
851 852 853 854 855 856 857

	tree_id = git_tree_id(tree);

	if ((error = validate_tree_and_parents(&parents_arr, repo, tree_id, commit_parent_from_array, &data, NULL, true)) < 0)
		return error;

	error = git_commit__create_buffer_internal(
858
		out, author, committer,
859 860 861 862 863 864
		message_encoding, message, tree_id,
		&parents_arr);

	git_array_clear(parents_arr);
	return error;
}
865 866 867 868

/**
 * Append to 'out' properly marking continuations when there's a newline in 'content'
 */
869
static int format_header_field(git_buf *out, const char *field, const char *content)
870 871 872
{
	const char *lf;

873 874 875
	GIT_ASSERT_ARG(out);
	GIT_ASSERT_ARG(field);
	GIT_ASSERT_ARG(content);
876 877 878 879 880 881 882 883 884 885 886 887

	git_buf_puts(out, field);
	git_buf_putc(out, ' ');

	while ((lf = strchr(content, '\n')) != NULL) {
		git_buf_put(out, content, lf - content);
		git_buf_puts(out, "\n ");
		content = lf + 1;
	}

	git_buf_puts(out, content);
	git_buf_putc(out, '\n');
888 889

	return git_buf_oom(out) ? -1 : 0;
890 891
}

892 893 894 895 896 897 898 899
static const git_oid *commit_parent_from_commit(size_t n, void *payload)
{
	const git_commit *commit = (const git_commit *) payload;

	return git_array_get(commit->parent_ids, n);

}

900 901 902 903 904 905 906 907 908 909 910 911
int git_commit_create_with_signature(
	git_oid *out,
	git_repository *repo,
	const char *commit_content,
	const char *signature,
	const char *signature_field)
{
	git_odb *odb;
	int error = 0;
	const char *field;
	const char *header_end;
	git_buf commit = GIT_BUF_INIT;
912 913
	git_commit *parsed;
	git_array_oid_t parents = GIT_ARRAY_INIT;
914

915 916 917 918 919 920 921 922 923 924 925 926
	/* The first step is to verify that all the tree and parents exist */
	parsed = git__calloc(1, sizeof(git_commit));
	GIT_ERROR_CHECK_ALLOC(parsed);
	if ((error = commit_parse(parsed, commit_content, strlen(commit_content), 0)) < 0)
		goto cleanup;

	if ((error = validate_tree_and_parents(&parents, repo, &parsed->tree_id, commit_parent_from_commit, parsed, NULL, true)) < 0)
		goto cleanup;

	git_array_clear(parents);

	/* Then we start appending by identifying the end of the commit header */
927 928
	header_end = strstr(commit_content, "\n\n");
	if (!header_end) {
929
		git_error_set(GIT_ERROR_INVALID, "malformed commit contents");
930 931
		error = -1;
		goto cleanup;
932 933 934 935 936
	}

	/* The header ends after the first LF */
	header_end++;
	git_buf_put(&commit, commit_content, header_end - commit_content);
937 938 939

	if (signature != NULL) {
		field = signature_field ? signature_field : "gpgsig";
940 941 942

		if ((error = format_header_field(&commit, field, signature)) < 0)
			goto cleanup;
943 944
	}

945 946 947 948 949 950 951 952
	git_buf_puts(&commit, header_end);

	if (git_buf_oom(&commit))
		return -1;

	if ((error = git_repository_odb__weakptr(&odb, repo)) < 0)
		goto cleanup;

953
	if ((error = git_odb_write(out, odb, commit.ptr, commit.size, GIT_OBJECT_COMMIT)) < 0)
954 955 956
		goto cleanup;

cleanup:
957
	git_commit__free(parsed);
958
	git_buf_dispose(&commit);
959 960
	return error;
}
961 962 963 964

int git_commit_committer_with_mailmap(
	git_signature **out, const git_commit *commit, const git_mailmap *mailmap)
{
965
	return git_mailmap_resolve_signature(out, mailmap, commit->committer);
966 967 968 969 970
}

int git_commit_author_with_mailmap(
	git_signature **out, const git_commit *commit, const git_mailmap *mailmap)
{
971
	return git_mailmap_resolve_signature(out, mailmap, commit->author);
972
}