commit.c 25.3 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
#include "grafts.h"
26

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

31
	git_array_clear(commit->parent_ids);
32

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

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

42
	git__free(commit);
43 44
}

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

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

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

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

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

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

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

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

	return 0;

on_error:
81
	git_str_dispose(out);
82 83
	return -1;
}
84

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

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

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

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

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

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

117
	return 0;
118

119 120 121 122
on_error:
	git_array_clear(*parents);
	return error;
}
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;
140
	git_str buf = GIT_STR_INIT;
141 142
	const git_oid *current_id = NULL;
	git_array_oid_t parents = GIT_ARRAY_INIT;
143

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

	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;

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

	if (error < 0)
		goto cleanup;
163

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

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

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

173

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

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

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

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

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

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

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

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

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

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

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

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

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

321 322 323 324 325 326 327
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);
}
328

329 330 331 332 333 334 335 336 337 338 339 340
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;
341 342
	git_reference *ref;
	int error;
343

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

	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;
360
		GIT_ERROR_CHECK_ERROR( git_commit_tree(&old_tree, commit_to_amend) );
361 362 363
		git_oid_cpy(&tree_id, git_tree_id(old_tree));
		git_tree_free(old_tree);
	} else {
364
		GIT_ASSERT_ARG(git_tree_owner(tree) == repo);
365 366
		git_oid_cpy(&tree_id, git_tree_id(tree));
	}
367

368 369 370 371 372 373
	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);
374
			git_error_set(GIT_ERROR_REFERENCE, "commit to amend is not the tip of the given branch");
375 376 377 378
			return -1;
		}
	}

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

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

	return error;
390 391
}

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

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

404
	buffer = buffer_start;
405

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

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

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

Vicent Marti committed
425
		git_oid_cpy(new_id, &parent_id);
426
	}
427

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

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

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

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

445
	/* Always parse the committer; we need the commit time */
446
	commit->committer = git__malloc(sizeof(git_signature));
447
	GIT_ERROR_CHECK_ALLOC(commit->committer);
448

449 450
	if ((error = git_signature__parse(commit->committer, &buffer, buffer_end, "committer ", '\n')) < 0)
		return error;
451

452 453 454
	if (flags & GIT_COMMIT_PARSE_QUICK)
		return 0;

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

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

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

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

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

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

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

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

490 491 492
	return 0;

bad_buffer:
493
	git_error_set(GIT_ERROR_OBJECT, "failed to parse bad commit object");
494
	return GIT_EINVALID;
495
}
496

497 498 499 500 501 502 503
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)
{
yuangli committed
504 505
	git_repository *repo = git_object_owner((git_object *)commit);
	git_commit_graft *graft;
506
	int error;
yuangli committed
507
	
508 509 510 511
	if ((error = commit_parse(commit, git_odb_object_data(odb_obj),
				  git_odb_object_size(odb_obj), flags)) < 0)
		return error;

Yuang Li committed
512 513
	if (!git_shallow__enabled)
		return 0;
514

Yuang Li committed
515 516 517 518 519 520 521 522 523 524 525 526
	/* Perform necessary grafts */
	if (git_grafts_get(&graft, repo->grafts, git_odb_object_id(odb_obj)) == 0 ||
		git_grafts_get(&graft, repo->shallow_grafts, git_odb_object_id(odb_obj)) == 0) {
		size_t idx;
		git_oid *oid;
		git_array_clear(commit->parent_ids);
		git_array_init_to_size(commit->parent_ids, git_array_size(graft->parents));
		git_array_foreach(graft->parents, idx, oid) {
			git_oid *id = git_array_alloc(commit->parent_ids);
			GIT_ERROR_CHECK_ALLOC(id);

			git_oid_cpy(id, oid);
527
		}
528 529
	}
	
530
	return 0;
531 532
}

533 534
int git_commit__parse(void *_commit, git_odb_object *odb_obj)
{
535
	return git_commit__parse_ext(_commit, odb_obj, 0);
536 537
}

538
#define GIT_COMMIT_GETTER(_rvalue, _name, _return, _invalid) \
Vicent Marti committed
539
	_rvalue git_commit_##_name(const git_commit *commit) \
540
	{\
541
		GIT_ASSERT_ARG_WITH_RETVAL(commit, _invalid); \
542
		return _return; \
543 544
	}

545 546 547 548 549 550 551 552 553
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)
554

555 556
const char *git_commit_message(const git_commit *commit)
{
557
	const char *message;
558

559
	GIT_ASSERT_ARG_WITH_RETVAL(commit, NULL);
560

561 562
	message = commit->raw_message;

563 564 565 566 567 568 569
	/* trim leading newlines from raw message */
	while (*message && *message == '\n')
		++message;

	return message;
}

570 571
const char *git_commit_summary(git_commit *commit)
{
572
	git_str summary = GIT_STR_INIT;
573
	const char *msg, *space, *next;
574
	bool space_contains_newline = false;
575

576
	GIT_ASSERT_ARG_WITH_RETVAL(commit, NULL);
577 578 579

	if (!commit->summary) {
		for (msg = git_commit_message(commit), space = NULL; *msg; ++msg) {
580 581
			char next_character = msg[0];
			/* stop processing at the end of the first paragraph */
582 583 584 585 586 587 588 589 590 591 592 593 594
			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;
			}
595
			/* record the beginning of contiguous whitespace runs */
596
			if (git__isspace(next_character)) {
597 598 599 600 601 602 603 604 605 606 607
				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)
608
						git_str_putc(&summary, ' '); /* if the space contains a newline, collapse to ' ' */
609
					else
610
						git_str_put(&summary, space, (msg - space)); /* otherwise copy it */
611 612 613
					space = NULL;
				}
				/* copy the next character */
614
				git_str_putc(&summary, next_character);
615
			}
616 617
		}

618
		commit->summary = git_str_detach(&summary);
619
		if (!commit->summary)
620
			commit->summary = git__strdup("");
621 622 623 624 625
	}

	return commit->summary;
}

626 627 628 629
const char *git_commit_body(git_commit *commit)
{
	const char *msg, *end;

630
	GIT_ASSERT_ARG_WITH_RETVAL(commit, NULL);
631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646

	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)
647
			commit->body = git__strndup(msg, end - msg + 1);
648 649 650 651 652
	}

	return commit->body;
}

Vicent Marti committed
653
int git_commit_tree(git_tree **tree_out, const git_commit *commit)
654
{
655
	GIT_ASSERT_ARG(commit);
Vicent Marti committed
656
	return git_tree_lookup(tree_out, commit->object.repo, &commit->tree_id);
657
}
658

659 660
const git_oid *git_commit_parent_id(
	const git_commit *commit, unsigned int n)
661
{
662
	GIT_ASSERT_ARG_WITH_RETVAL(commit, NULL);
663

664
	return git_array_get(commit->parent_ids, n);
665 666
}

667 668
int git_commit_parent(
	git_commit **parent, const git_commit *commit, unsigned int n)
669
{
Vicent Marti committed
670
	const git_oid *parent_id;
671
	GIT_ASSERT_ARG(commit);
672

Vicent Marti committed
673 674
	parent_id = git_commit_parent_id(commit, n);
	if (parent_id == NULL) {
675
		git_error_set(GIT_ERROR_INVALID, "parent %u does not exist", n);
676 677
		return GIT_ENOTFOUND;
	}
678

Vicent Marti committed
679
	return git_commit_lookup(parent, commit->object.repo, parent_id);
680
}
681 682 683 684 685 686

int git_commit_nth_gen_ancestor(
	git_commit **ancestor,
	const git_commit *commit,
	unsigned int n)
{
687
	git_commit *current, *parent = NULL;
688 689
	int error;

690 691
	GIT_ASSERT_ARG(ancestor);
	GIT_ASSERT_ARG(commit);
692

693
	if (git_commit_dup(&current, (git_commit *)commit) < 0)
694
		return -1;
695

696 697 698 699
	if (n == 0) {
		*ancestor = current;
		return 0;
	}
700 701

	while (n--) {
702
		error = git_commit_parent(&parent, current, 0);
703

704
		git_commit_free(current);
705 706 707 708 709 710 711 712 713 714

		if (error < 0)
			return error;

		current = parent;
	}

	*ancestor = parent;
	return 0;
}
715

716 717 718 719 720 721 722 723 724 725 726 727
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)
728
{
729
	const char *eol, *buf = commit->raw_header;
730

731
	git_str_clear(out);
732

733
	while ((eol = strchr(buf, '\n'))) {
734 735 736 737 738 739 740 741 742
		/* 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;
743 744 745
			continue;
		}

746 747 748 749
		buf += strlen(field);
		/* Check that we're not matching a prefix but the field itself */
		if (buf[0] != ' ') {
			buf = eol + 1;
750 751 752
			continue;
		}

753
		buf++; /* skip the SP */
754

755 756
		git_str_put(out, buf, eol - buf);
		if (git_str_oom(out))
757 758 759 760
			goto oom;

		/* If the next line starts with SP, it's multi-line, we must continue */
		while (eol[1] == ' ') {
761
			git_str_putc(out, '\n');
762 763
			buf = eol + 2;
			eol = strchr(buf, '\n');
764 765 766
			if (!eol)
				goto malformed;

767
			git_str_put(out, buf, eol - buf);
768 769
		}

770
		if (git_str_oom(out))
771 772 773 774 775
			goto oom;

		return 0;
	}

776
	git_error_set(GIT_ERROR_OBJECT, "no such field '%s'", field);
777 778 779
	return GIT_ENOTFOUND;

malformed:
780
	git_error_set(GIT_ERROR_OBJECT, "malformed header");
781 782
	return -1;
oom:
783
	git_error_set_oom();
784 785
	return -1;
}
786

787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815
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)
816 817 818 819 820 821 822
{
	git_odb_object *obj;
	git_odb *odb;
	const char *buf;
	const char *h, *eol;
	int error;

823 824
	git_str_clear(signature);
	git_str_clear(signed_data);
825 826 827 828 829 830 831 832 833 834

	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;

835
	if (obj->cached.type != GIT_OBJECT_COMMIT) {
836
		git_error_set(GIT_ERROR_INVALID, "the requested type does not match the type in the ODB");
837 838 839 840
		error = GIT_ENOTFOUND;
		goto cleanup;
	}

841 842
	buf = git_odb_object_data(obj);

843
	while ((h = strchr(buf, '\n')) && h[1] != '\0') {
844 845
		h++;
		if (git__prefixcmp(buf, field)) {
846
			if (git_str_put(signed_data, buf, h - buf) < 0)
847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864
				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 */

865 866
		git_str_put(signature, h, eol - h);
		if (git_str_oom(signature))
867 868 869 870
			goto oom;

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

877
			git_str_put(signature, h, eol - h);
878 879
		}

880
		if (git_str_oom(signature))
881 882
			goto oom;

883
		error = git_str_puts(signed_data, eol+1);
884
		git_odb_object_free(obj);
885
		return error;
886 887
	}

888
	git_error_set(GIT_ERROR_OBJECT, "this commit is not signed");
889 890 891 892
	error = GIT_ENOTFOUND;
	goto cleanup;

malformed:
893
	git_error_set(GIT_ERROR_OBJECT, "malformed header");
894 895 896
	error = -1;
	goto cleanup;
oom:
897
	git_error_set_oom();
898 899 900 901 902
	error = -1;
	goto cleanup;

cleanup:
	git_odb_object_free(obj);
903 904
	git_str_clear(signature);
	git_str_clear(signed_data);
905 906
	return error;
}
907

908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925
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,
926 927 928 929 930 931 932 933 934 935 936 937 938 939
	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;

940 941
	GIT_ASSERT_ARG(tree);
	GIT_ASSERT_ARG(git_tree_owner(tree) == repo);
942 943 944 945 946 947 948

	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(
949
		out, author, committer,
950 951 952 953 954 955
		message_encoding, message, tree_id,
		&parents_arr);

	git_array_clear(parents_arr);
	return error;
}
956 957 958 959

/**
 * Append to 'out' properly marking continuations when there's a newline in 'content'
 */
960
static int format_header_field(git_str *out, const char *field, const char *content)
961 962 963
{
	const char *lf;

964 965 966
	GIT_ASSERT_ARG(out);
	GIT_ASSERT_ARG(field);
	GIT_ASSERT_ARG(content);
967

968 969
	git_str_puts(out, field);
	git_str_putc(out, ' ');
970 971

	while ((lf = strchr(content, '\n')) != NULL) {
972 973
		git_str_put(out, content, lf - content);
		git_str_puts(out, "\n ");
974 975 976
		content = lf + 1;
	}

977 978
	git_str_puts(out, content);
	git_str_putc(out, '\n');
979

980
	return git_str_oom(out) ? -1 : 0;
981 982
}

983 984 985 986 987 988 989 990
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);

}

991 992 993 994 995 996 997 998 999 1000 1001
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;
1002
	git_str commit = GIT_STR_INIT;
1003 1004
	git_commit *parsed;
	git_array_oid_t parents = GIT_ARRAY_INIT;
1005

1006 1007 1008
	/* 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);
1009 1010
	if (commit_parse(parsed, commit_content, strlen(commit_content), 0) < 0) {
		error = -1;
1011
		goto cleanup;
1012
	}
1013 1014 1015 1016 1017 1018 1019

	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 */
1020 1021
	header_end = strstr(commit_content, "\n\n");
	if (!header_end) {
1022
		git_error_set(GIT_ERROR_INVALID, "malformed commit contents");
1023 1024
		error = -1;
		goto cleanup;
1025 1026 1027 1028
	}

	/* The header ends after the first LF */
	header_end++;
1029
	git_str_put(&commit, commit_content, header_end - commit_content);
1030 1031 1032

	if (signature != NULL) {
		field = signature_field ? signature_field : "gpgsig";
1033 1034 1035

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

1038
	git_str_puts(&commit, header_end);
1039

1040
	if (git_str_oom(&commit))
1041 1042 1043 1044 1045
		return -1;

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

1046
	if ((error = git_odb_write(out, odb, commit.ptr, commit.size, GIT_OBJECT_COMMIT)) < 0)
1047 1048 1049
		goto cleanup;

cleanup:
1050
	git_commit__free(parsed);
1051
	git_str_dispose(&commit);
1052 1053
	return error;
}
1054 1055 1056 1057

int git_commit_committer_with_mailmap(
	git_signature **out, const git_commit *commit, const git_mailmap *mailmap)
{
1058
	return git_mailmap_resolve_signature(out, mailmap, commit->committer);
1059 1060 1061 1062 1063
}

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