commit.c 24.7 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

17
#include "buf.h"
Vicent Marti committed
18
#include "odb.h"
19
#include "commit.h"
20
#include "signature.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
static int git_commit__create_buffer_internal(
45
	git_str *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
	git_signature__writebuf(out, "author ", author);
	git_signature__writebuf(out, "committer ", committer);

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

72
	git_str_putc(out, '\n');
73

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

	return 0;

on_error:
80
	git_str_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
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;
139
	git_str buf = GIT_STR_INIT;
140 141
	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_str_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
	int error;
399

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

403
	buffer = buffer_start;
404

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

409
	/* The tree is always the first field */
410 411 412 413 414 415 416 417 418
	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;
	}
419

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

493 494 495
	return 0;

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

500 501 502 503 504 505 506 507 508 509
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);
}

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

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

522 523 524 525 526 527 528 529 530
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)
531

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

536
	GIT_ASSERT_ARG_WITH_RETVAL(commit, NULL);
537

538 539
	message = commit->raw_message;

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

	return message;
}

547 548
const char *git_commit_summary(git_commit *commit)
{
549
	git_str summary = GIT_STR_INIT;
550
	const char *msg, *space, *next;
551
	bool space_contains_newline = false;
552

553
	GIT_ASSERT_ARG_WITH_RETVAL(commit, NULL);
554 555 556

	if (!commit->summary) {
		for (msg = git_commit_message(commit), space = NULL; *msg; ++msg) {
557 558
			char next_character = msg[0];
			/* stop processing at the end of the first paragraph */
559 560 561 562 563 564 565 566 567 568 569 570 571
			if (next_character == '\n') {
				if (!msg[1])
					break;
				if (msg[1] == '\n')
					break;
				/* stop processing if next line contains only whitespace */
				next = msg + 1;
				while (*next && git__isspace_nonlf(*next)) {
					++next;
				}
				if (!*next || *next == '\n') 
					break;
			}
572
			/* record the beginning of contiguous whitespace runs */
573
			if (git__isspace(next_character)) {
574 575 576 577 578 579 580 581 582 583 584
				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)
585
						git_str_putc(&summary, ' '); /* if the space contains a newline, collapse to ' ' */
586
					else
587
						git_str_put(&summary, space, (msg - space)); /* otherwise copy it */
588 589 590
					space = NULL;
				}
				/* copy the next character */
591
				git_str_putc(&summary, next_character);
592
			}
593 594
		}

595
		commit->summary = git_str_detach(&summary);
596
		if (!commit->summary)
597
			commit->summary = git__strdup("");
598 599 600 601 602
	}

	return commit->summary;
}

603 604 605 606
const char *git_commit_body(git_commit *commit)
{
	const char *msg, *end;

607
	GIT_ASSERT_ARG_WITH_RETVAL(commit, NULL);
608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623

	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)
624
			commit->body = git__strndup(msg, end - msg + 1);
625 626 627 628 629
	}

	return commit->body;
}

Vicent Marti committed
630
int git_commit_tree(git_tree **tree_out, const git_commit *commit)
631
{
632
	GIT_ASSERT_ARG(commit);
Vicent Marti committed
633
	return git_tree_lookup(tree_out, commit->object.repo, &commit->tree_id);
634
}
635

636 637
const git_oid *git_commit_parent_id(
	const git_commit *commit, unsigned int n)
638
{
639
	GIT_ASSERT_ARG_WITH_RETVAL(commit, NULL);
640

641
	return git_array_get(commit->parent_ids, n);
642 643
}

644 645
int git_commit_parent(
	git_commit **parent, const git_commit *commit, unsigned int n)
646
{
Vicent Marti committed
647
	const git_oid *parent_id;
648
	GIT_ASSERT_ARG(commit);
649

Vicent Marti committed
650 651
	parent_id = git_commit_parent_id(commit, n);
	if (parent_id == NULL) {
652
		git_error_set(GIT_ERROR_INVALID, "parent %u does not exist", n);
653 654
		return GIT_ENOTFOUND;
	}
655

Vicent Marti committed
656
	return git_commit_lookup(parent, commit->object.repo, parent_id);
657
}
658 659 660 661 662 663

int git_commit_nth_gen_ancestor(
	git_commit **ancestor,
	const git_commit *commit,
	unsigned int n)
{
664
	git_commit *current, *parent = NULL;
665 666
	int error;

667 668
	GIT_ASSERT_ARG(ancestor);
	GIT_ASSERT_ARG(commit);
669

670
	if (git_commit_dup(&current, (git_commit *)commit) < 0)
671
		return -1;
672

673 674 675 676
	if (n == 0) {
		*ancestor = current;
		return 0;
	}
677 678

	while (n--) {
679
		error = git_commit_parent(&parent, current, 0);
680

681
		git_commit_free(current);
682 683 684 685 686 687 688 689 690 691

		if (error < 0)
			return error;

		current = parent;
	}

	*ancestor = parent;
	return 0;
}
692

693 694 695 696 697 698 699 700 701 702 703 704
int git_commit_header_field(
	git_buf *out,
	const git_commit *commit,
	const char *field)
{
	GIT_BUF_WRAP_PRIVATE(out, git_commit__header_field, commit, field);
}

int git_commit__header_field(
	git_str *out,
	const git_commit *commit,
	const char *field)
705
{
706
	const char *eol, *buf = commit->raw_header;
707

708
	git_str_clear(out);
709

710
	while ((eol = strchr(buf, '\n'))) {
711 712 713 714 715 716 717 718 719
		/* 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;
720 721 722
			continue;
		}

723 724 725 726
		buf += strlen(field);
		/* Check that we're not matching a prefix but the field itself */
		if (buf[0] != ' ') {
			buf = eol + 1;
727 728 729
			continue;
		}

730
		buf++; /* skip the SP */
731

732 733
		git_str_put(out, buf, eol - buf);
		if (git_str_oom(out))
734 735 736 737
			goto oom;

		/* If the next line starts with SP, it's multi-line, we must continue */
		while (eol[1] == ' ') {
738
			git_str_putc(out, '\n');
739 740
			buf = eol + 2;
			eol = strchr(buf, '\n');
741 742 743
			if (!eol)
				goto malformed;

744
			git_str_put(out, buf, eol - buf);
745 746
		}

747
		if (git_str_oom(out))
748 749 750 751 752
			goto oom;

		return 0;
	}

753
	git_error_set(GIT_ERROR_OBJECT, "no such field '%s'", field);
754 755 756
	return GIT_ENOTFOUND;

malformed:
757
	git_error_set(GIT_ERROR_OBJECT, "malformed header");
758 759
	return -1;
oom:
760
	git_error_set_oom();
761 762
	return -1;
}
763

764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792
int git_commit_extract_signature(
	git_buf *signature_out,
	git_buf *signed_data_out,
	git_repository *repo,
	git_oid *commit_id,
	const char *field)
{
	git_str signature = GIT_STR_INIT, signed_data = GIT_STR_INIT;
	int error;

	if ((error = git_buf_tostr(&signature, signature_out)) < 0 ||
	    (error = git_buf_tostr(&signed_data, signed_data_out)) < 0 ||
	    (error = git_commit__extract_signature(&signature, &signed_data, repo, commit_id, field)) < 0 ||
	    (error = git_buf_fromstr(signature_out, &signature)) < 0 ||
	    (error = git_buf_fromstr(signed_data_out, &signed_data)) < 0)
		goto done;

done:
	git_str_dispose(&signature);
	git_str_dispose(&signed_data);
	return error;
}

int git_commit__extract_signature(
	git_str *signature,
	git_str *signed_data,
	git_repository *repo,
	git_oid *commit_id,
	const char *field)
793 794 795 796 797 798 799
{
	git_odb_object *obj;
	git_odb *odb;
	const char *buf;
	const char *h, *eol;
	int error;

800 801
	git_str_clear(signature);
	git_str_clear(signed_data);
802 803 804 805 806 807 808 809 810 811

	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;

812
	if (obj->cached.type != GIT_OBJECT_COMMIT) {
813
		git_error_set(GIT_ERROR_INVALID, "the requested type does not match the type in the ODB");
814 815 816 817
		error = GIT_ENOTFOUND;
		goto cleanup;
	}

818 819
	buf = git_odb_object_data(obj);

820
	while ((h = strchr(buf, '\n')) && h[1] != '\0') {
821 822
		h++;
		if (git__prefixcmp(buf, field)) {
823
			if (git_str_put(signed_data, buf, h - buf) < 0)
824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841
				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 */

842 843
		git_str_put(signature, h, eol - h);
		if (git_str_oom(signature))
844 845 846 847
			goto oom;

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

854
			git_str_put(signature, h, eol - h);
855 856
		}

857
		if (git_str_oom(signature))
858 859
			goto oom;

860
		error = git_str_puts(signed_data, eol+1);
861
		git_odb_object_free(obj);
862
		return error;
863 864
	}

865
	git_error_set(GIT_ERROR_OBJECT, "this commit is not signed");
866 867 868 869
	error = GIT_ENOTFOUND;
	goto cleanup;

malformed:
870
	git_error_set(GIT_ERROR_OBJECT, "malformed header");
871 872 873
	error = -1;
	goto cleanup;
oom:
874
	git_error_set_oom();
875 876 877 878 879
	error = -1;
	goto cleanup;

cleanup:
	git_odb_object_free(obj);
880 881
	git_str_clear(signature);
	git_str_clear(signed_data);
882 883
	return error;
}
884

885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902
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[])
{
	GIT_BUF_WRAP_PRIVATE(out, git_commit__create_buffer, repo,
	                     author, committer, message_encoding, message,
	                     tree, parent_count, parents);
}

int git_commit__create_buffer(
	git_str *out,
903 904 905 906 907 908 909 910 911 912 913 914 915 916
	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;

917 918
	GIT_ASSERT_ARG(tree);
	GIT_ASSERT_ARG(git_tree_owner(tree) == repo);
919 920 921 922 923 924 925

	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(
926
		out, author, committer,
927 928 929 930 931 932
		message_encoding, message, tree_id,
		&parents_arr);

	git_array_clear(parents_arr);
	return error;
}
933 934 935 936

/**
 * Append to 'out' properly marking continuations when there's a newline in 'content'
 */
937
static int format_header_field(git_str *out, const char *field, const char *content)
938 939 940
{
	const char *lf;

941 942 943
	GIT_ASSERT_ARG(out);
	GIT_ASSERT_ARG(field);
	GIT_ASSERT_ARG(content);
944

945 946
	git_str_puts(out, field);
	git_str_putc(out, ' ');
947 948

	while ((lf = strchr(content, '\n')) != NULL) {
949 950
		git_str_put(out, content, lf - content);
		git_str_puts(out, "\n ");
951 952 953
		content = lf + 1;
	}

954 955
	git_str_puts(out, content);
	git_str_putc(out, '\n');
956

957
	return git_str_oom(out) ? -1 : 0;
958 959
}

960 961 962 963 964 965 966 967
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);

}

968 969 970 971 972 973 974 975 976 977 978
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;
979
	git_str commit = GIT_STR_INIT;
980 981
	git_commit *parsed;
	git_array_oid_t parents = GIT_ARRAY_INIT;
982

983 984 985
	/* 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);
986 987
	if (commit_parse(parsed, commit_content, strlen(commit_content), 0) < 0) {
		error = -1;
988
		goto cleanup;
989
	}
990 991 992 993 994 995 996

	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 */
997 998
	header_end = strstr(commit_content, "\n\n");
	if (!header_end) {
999
		git_error_set(GIT_ERROR_INVALID, "malformed commit contents");
1000 1001
		error = -1;
		goto cleanup;
1002 1003 1004 1005
	}

	/* The header ends after the first LF */
	header_end++;
1006
	git_str_put(&commit, commit_content, header_end - commit_content);
1007 1008 1009

	if (signature != NULL) {
		field = signature_field ? signature_field : "gpgsig";
1010 1011 1012

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

1015
	git_str_puts(&commit, header_end);
1016

1017
	if (git_str_oom(&commit))
1018 1019 1020 1021 1022
		return -1;

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

1023
	if ((error = git_odb_write(out, odb, commit.ptr, commit.size, GIT_OBJECT_COMMIT)) < 0)
1024 1025 1026
		goto cleanup;

cleanup:
1027
	git_commit__free(parsed);
1028
	git_str_dispose(&commit);
1029 1030
	return error;
}
1031 1032 1033 1034

int git_commit_committer_with_mailmap(
	git_signature **out, const git_commit *commit, const git_mailmap *mailmap)
{
1035
	return git_mailmap_resolve_signature(out, mailmap, commit->committer);
1036 1037 1038 1039 1040
}

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