commit.c 21.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 "oidarray.h"
24

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

29
	git_array_clear(commit->parent_ids);
30

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

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

40
	git__free(commit);
41 42
}

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

55
	assert(out && tree);
56

57
	git_oid__writebuf(out, "tree ", tree);
58

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

64 65 66 67 68 69 70
	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');
71

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

	return 0;

on_error:
78
	git_buf_dispose(out);
79 80
	return -1;
}
81

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

	if (validate && !git_object__is_valid(repo, tree, GIT_OBJ_TREE))
		return -1;

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

101 102 103 104
		parent_cpy = git_array_alloc(*parents);
		GITERR_CHECK_ALLOC(parent_cpy);

		git_oid_cpy(parent_cpy, parent);
105 106 107
		i++;
	}

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

114
	return 0;
115

116 117 118 119
on_error:
	git_array_clear(*parents);
	return error;
}
120

121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
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;
140

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

	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;

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

	if (error < 0)
		goto cleanup;
160

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

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

167 168
	if (git_odb_write(id, odb, buf.ptr, buf.size, GIT_OBJ_COMMIT) < 0)
		goto cleanup;
Vicent Marti committed
169

170

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

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

184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200
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);
}

201 202 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 233 234 235
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;

	assert(tree && git_tree_owner(tree) == repo);

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

236
	error = git_commit__create_internal(
237 238
		id, repo, update_ref, author, committer,
		message_encoding, message, git_tree_id(tree),
239
		commit_parent_from_varargs, &data, false);
240 241 242 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

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

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

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

294
int git_commit_create(
295
	git_oid *id,
296 297 298 299 300 301 302
	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,
303
	size_t parent_count,
304
	const git_commit *parents[])
305
{
306
	commit_parent_data data = { parent_count, parents, repo };
307

308
	assert(tree && git_tree_owner(tree) == repo);
309

310
	return git_commit__create_internal(
311 312
		id, repo, update_ref, author, committer,
		message_encoding, message, git_tree_id(tree),
313
		commit_parent_from_array, &data, false);
314
}
315

316 317 318 319 320 321 322
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);
}
323

324 325 326 327 328 329 330 331 332 333 334 335
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;
336 337
	git_reference *ref;
	int error;
338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360

	assert(id && commit_to_amend);

	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;
		GITERR_CHECK_ERROR( git_commit_tree(&old_tree, commit_to_amend) );
		git_oid_cpy(&tree_id, git_tree_id(old_tree));
		git_tree_free(old_tree);
	} else {
		assert(git_tree_owner(tree) == repo);
		git_oid_cpy(&tree_id, git_tree_id(tree));
	}
361

362 363 364 365 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);
			giterr_set(GITERR_REFERENCE, "commit to amend is not the tip of the given branch");
			return -1;
		}
	}

373
	error = git_commit__create_internal(
374
		id, repo, NULL, author, committer, message_encoding, message,
375
		&tree_id, commit_parent_for_amend, (void *)commit_to_amend, false);
376 377

	if (!error && update_ref) {
378
		error = git_reference__update_for_commit(
379
			repo, ref, NULL, id, "commit");
380 381 382 383
		git_reference_free(ref);
	}

	return error;
384 385
}

386
int git_commit__parse(void *_commit, git_odb_object *odb_obj)
387
{
388
	git_commit *commit = _commit;
389 390
	const char *buffer_start = git_odb_object_data(odb_obj), *buffer;
	const char *buffer_end = buffer_start + git_odb_object_size(odb_obj);
Vicent Marti committed
391
	git_oid parent_id;
Russell Belfer committed
392
	size_t header_len;
393
	git_signature dummy_sig;
394

395
	buffer = buffer_start;
396

397 398
	/* Allocate for one, which will allow not to realloc 90% of the time  */
	git_array_init_to_size(commit->parent_ids, 1);
399
	GITERR_CHECK_ARRAY(commit->parent_ids);
400

401
	/* The tree is always the first field */
Vicent Marti committed
402
	if (git_oid__parse(&commit->tree_id, &buffer, buffer_end, "tree ") < 0)
403
		goto bad_buffer;
404

405 406 407
	/*
	 * TODO: commit grafts!
	 */
408

Vicent Marti committed
409
	while (git_oid__parse(&parent_id, &buffer, buffer_end, "parent ") == 0) {
410
		git_oid *new_id = git_array_alloc(commit->parent_ids);
Vicent Marti committed
411
		GITERR_CHECK_ALLOC(new_id);
412

Vicent Marti committed
413
		git_oid_cpy(new_id, &parent_id);
414
	}
415

416
	commit->author = git__malloc(sizeof(git_signature));
417 418 419 420
	GITERR_CHECK_ALLOC(commit->author);

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

422 423 424 425 426 427 428 429 430
	/* Some tools create multiple author fields, ignore the extra ones */
	while ((size_t)(buffer_end - buffer) >= strlen("author ") && !git__prefixcmp(buffer, "author ")) {
		if (git_signature__parse(&dummy_sig, &buffer, buffer_end, "author ", '\n') < 0)
			return -1;

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

431
	/* Always parse the committer; we need the commit time */
432
	commit->committer = git__malloc(sizeof(git_signature));
433 434 435 436
	GITERR_CHECK_ALLOC(commit->committer);

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

438 439
	/* Parse add'l header entries */
	while (buffer < buffer_end) {
440
		const char *eoln = buffer;
441 442 443
		if (buffer[-1] == '\n' && buffer[0] == '\n')
			break;

444 445
		while (eoln < buffer_end && *eoln != '\n')
			++eoln;
446

447 448
		if (git__prefixcmp(buffer, "encoding ") == 0) {
			buffer += strlen("encoding ");
449

450 451 452
			commit->message_encoding = git__strndup(buffer, eoln - buffer);
			GITERR_CHECK_ALLOC(commit->message_encoding);
		}
453

454 455
		if (eoln < buffer_end && *eoln == '\n')
			++eoln;
456
		buffer = eoln;
457
	}
458

459 460 461
	header_len = buffer - buffer_start;
	commit->raw_header = git__strndup(buffer_start, header_len);
	GITERR_CHECK_ALLOC(commit->raw_header);
462

463 464
	/* point "buffer" to data after header, +1 for the final LF */
	buffer = buffer_start + header_len + 1;
465

466
	/* extract commit message */
467
	if (buffer <= buffer_end)
468
		commit->raw_message = git__strndup(buffer, buffer_end - buffer);
469 470 471
	else
		commit->raw_message = git__strdup("");
	GITERR_CHECK_ALLOC(commit->raw_message);
472

473 474 475
	return 0;

bad_buffer:
476
	giterr_set(GITERR_OBJECT, "failed to parse bad commit object");
477
	return -1;
478
}
479

480
#define GIT_COMMIT_GETTER(_rvalue, _name, _return) \
Vicent Marti committed
481
	_rvalue git_commit_##_name(const git_commit *commit) \
482
	{\
483
		assert(commit); \
484
		return _return; \
485 486
	}

487 488
GIT_COMMIT_GETTER(const git_signature *, author, commit->author)
GIT_COMMIT_GETTER(const git_signature *, committer, commit->committer)
489
GIT_COMMIT_GETTER(const char *, message_raw, commit->raw_message)
490
GIT_COMMIT_GETTER(const char *, message_encoding, commit->message_encoding)
491
GIT_COMMIT_GETTER(const char *, raw_header, commit->raw_header)
492
GIT_COMMIT_GETTER(git_time_t, time, commit->committer->when.time)
493
GIT_COMMIT_GETTER(int, time_offset, commit->committer->when.offset)
494
GIT_COMMIT_GETTER(unsigned int, parentcount, (unsigned int)git_array_size(commit->parent_ids))
495
GIT_COMMIT_GETTER(const git_oid *, tree_id, &commit->tree_id)
496

497 498
const char *git_commit_message(const git_commit *commit)
{
499
	const char *message;
500 501 502

	assert(commit);

503 504
	message = commit->raw_message;

505 506 507 508 509 510 511
	/* trim leading newlines from raw message */
	while (*message && *message == '\n')
		++message;

	return message;
}

512 513 514 515
const char *git_commit_summary(git_commit *commit)
{
	git_buf summary = GIT_BUF_INIT;
	const char *msg, *space;
516
	bool space_contains_newline = false;
517 518 519 520 521

	assert(commit);

	if (!commit->summary) {
		for (msg = git_commit_message(commit), space = NULL; *msg; ++msg) {
522 523 524
			char next_character = msg[0];
			/* stop processing at the end of the first paragraph */
			if (next_character == '\n' && (!msg[1] || msg[1] == '\n'))
525
				break;
526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546
			/* 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);
			}
547 548
		}

549 550
		commit->summary = git_buf_detach(&summary);
		if (!commit->summary)
551
			commit->summary = git__strdup("");
552 553 554 555 556
	}

	return commit->summary;
}

557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583
const char *git_commit_body(git_commit *commit)
{
	const char *msg, *end;

	assert(commit);

	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)
			    commit->body = git__strndup(msg, end - msg + 1);
	}

	return commit->body;
}

Vicent Marti committed
584
int git_commit_tree(git_tree **tree_out, const git_commit *commit)
585 586
{
	assert(commit);
Vicent Marti committed
587
	return git_tree_lookup(tree_out, commit->object.repo, &commit->tree_id);
588
}
589

590 591
const git_oid *git_commit_parent_id(
	const git_commit *commit, unsigned int n)
592 593 594
{
	assert(commit);

595
	return git_array_get(commit->parent_ids, n);
596 597
}

598 599
int git_commit_parent(
	git_commit **parent, const git_commit *commit, unsigned int n)
600
{
Vicent Marti committed
601
	const git_oid *parent_id;
602 603
	assert(commit);

Vicent Marti committed
604 605
	parent_id = git_commit_parent_id(commit, n);
	if (parent_id == NULL) {
606
		giterr_set(GITERR_INVALID, "parent %u does not exist", n);
607 608
		return GIT_ENOTFOUND;
	}
609

Vicent Marti committed
610
	return git_commit_lookup(parent, commit->object.repo, parent_id);
611
}
612 613 614 615 616 617

int git_commit_nth_gen_ancestor(
	git_commit **ancestor,
	const git_commit *commit,
	unsigned int n)
{
618
	git_commit *current, *parent = NULL;
619 620 621 622
	int error;

	assert(ancestor && commit);

623
	if (git_commit_dup(&current, (git_commit *)commit) < 0)
624
		return -1;
625

626 627 628 629
	if (n == 0) {
		*ancestor = current;
		return 0;
	}
630 631

	while (n--) {
632
		error = git_commit_parent(&parent, current, 0);
633

634
		git_commit_free(current);
635 636 637 638 639 640 641 642 643 644

		if (error < 0)
			return error;

		current = parent;
	}

	*ancestor = parent;
	return 0;
}
645 646 647

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

650
	git_buf_clear(out);
651

652
	while ((eol = strchr(buf, '\n'))) {
653 654 655 656 657 658 659 660 661
		/* 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;
662 663 664
			continue;
		}

665 666 667 668
		buf += strlen(field);
		/* Check that we're not matching a prefix but the field itself */
		if (buf[0] != ' ') {
			buf = eol + 1;
669 670 671
			continue;
		}

672
		buf++; /* skip the SP */
673

674
		git_buf_put(out, buf, eol - buf);
675 676 677 678 679 680
		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');
681 682
			buf = eol + 2;
			eol = strchr(buf, '\n');
683 684 685
			if (!eol)
				goto malformed;

686
			git_buf_put(out, buf, eol - buf);
687 688 689 690 691 692 693 694
		}

		if (git_buf_oom(out))
			goto oom;

		return 0;
	}

695
	giterr_set(GITERR_OBJECT, "no such field '%s'", field);
696 697 698 699 700 701 702 703 704
	return GIT_ENOTFOUND;

malformed:
	giterr_set(GITERR_OBJECT, "malformed header");
	return -1;
oom:
	giterr_set_oom();
	return -1;
}
705 706 707 708 709 710 711 712 713

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;

714 715
	git_buf_clear(signature);
	git_buf_clear(signed_data);
716 717 718 719 720 721 722 723 724 725

	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;

726 727 728 729 730 731
	if (obj->cached.type != GIT_OBJ_COMMIT) {
		giterr_set(GITERR_INVALID, "the requested type does not match the type in ODB");
		error = GIT_ENOTFOUND;
		goto cleanup;
	}

732 733
	buf = git_odb_object_data(obj);

734
	while ((h = strchr(buf, '\n')) && h[1] != '\0') {
735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773
		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;

774
		error = git_buf_puts(signed_data, eol+1);
775
		git_odb_object_free(obj);
776
		return error;
777 778
	}

779
	giterr_set(GITERR_OBJECT, "this commit is not signed");
780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797
	error = GIT_ENOTFOUND;
	goto cleanup;

malformed:
	giterr_set(GITERR_OBJECT, "malformed header");
	error = -1;
	goto cleanup;
oom:
	giterr_set_oom();
	error = -1;
	goto cleanup;

cleanup:
	git_odb_object_free(obj);
	git_buf_clear(signature);
	git_buf_clear(signed_data);
	return error;
}
798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821

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;

	assert(tree && git_tree_owner(tree) == repo);

	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(
822
		out, author, committer,
823 824 825 826 827 828
		message_encoding, message, tree_id,
		&parents_arr);

	git_array_clear(parents_arr);
	return error;
}
829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889

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

	assert(out && field && content);

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

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;

	/* We start by identifying the end of the commit header */
	header_end = strstr(commit_content, "\n\n");
	if (!header_end) {
		giterr_set(GITERR_INVALID, "malformed commit contents");
		return -1;
	}

	field = signature_field ? signature_field : "gpgsig";

	/* The header ends after the first LF */
	header_end++;
	git_buf_put(&commit, commit_content, header_end - commit_content);
	format_header_field(&commit, field, signature);
	git_buf_puts(&commit, header_end);

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

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

	if ((error = git_odb_write(out, odb, commit.ptr, commit.size, GIT_OBJ_COMMIT)) < 0)
		goto cleanup;

cleanup:
890
	git_buf_dispose(&commit);
891 892
	return error;
}
893 894 895 896

int git_commit_committer_with_mailmap(
	git_signature **out, const git_commit *commit, const git_mailmap *mailmap)
{
897
	return git_mailmap_resolve_signature(out, mailmap, commit->committer);
898 899 900 901 902
}

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