freshlybakedca.ke
Git fork
1#define USE_THE_REPOSITORY_VARIABLE
2
3#include "git-compat-util.h"
4#include "tag.h"
5#include "commit.h"
6#include "commit-graph.h"
7#include "environment.h"
8#include "gettext.h"
9#include "hex.h"
10#include "repository.h"
11#include "object-name.h"
12#include "odb.h"
13#include "utf8.h"
14#include "diff.h"
15#include "revision.h"
16#include "notes.h"
17#include "alloc.h"
18#include "gpg-interface.h"
19#include "mergesort.h"
20#include "commit-slab.h"
21#include "prio-queue.h"
22#include "hash-lookup.h"
23#include "wt-status.h"
24#include "advice.h"
25#include "refs.h"
26#include "commit-reach.h"
27#include "setup.h"
28#include "shallow.h"
29#include "tree.h"
30#include "hook.h"
31#include "parse.h"
32#include "object-file.h"
33#include "object-file-convert.h"
34#include "prio-queue.h"
35
36static struct commit_extra_header *read_commit_extra_header_lines(const char *buf, size_t len, const char **);
37
38int save_commit_buffer = 1;
39int no_graft_file_deprecated_advice;
40
41const char *commit_type = "commit";
42
43struct commit *lookup_commit_reference_gently(struct repository *r,
44 const struct object_id *oid, int quiet)
45{
46 struct object *obj = deref_tag(r,
47 parse_object(r, oid),
48 NULL, 0);
49
50 if (!obj)
51 return NULL;
52 return object_as_type(obj, OBJ_COMMIT, quiet);
53}
54
55struct commit *lookup_commit_reference(struct repository *r, const struct object_id *oid)
56{
57 return lookup_commit_reference_gently(r, oid, 0);
58}
59
60struct commit *lookup_commit_or_die(const struct object_id *oid, const char *ref_name)
61{
62 struct commit *c = lookup_commit_reference(the_repository, oid);
63 if (!c)
64 die(_("could not parse %s"), ref_name);
65 if (!oideq(oid, &c->object.oid)) {
66 warning(_("%s %s is not a commit!"),
67 ref_name, oid_to_hex(oid));
68 }
69 return c;
70}
71
72struct commit *lookup_commit_object(struct repository *r,
73 const struct object_id *oid)
74{
75 struct object *obj = parse_object(r, oid);
76 return obj ? object_as_type(obj, OBJ_COMMIT, 0) : NULL;
77
78}
79
80struct commit *lookup_commit(struct repository *r, const struct object_id *oid)
81{
82 struct object *obj = lookup_object(r, oid);
83 if (!obj)
84 return create_object(r, oid, alloc_commit_node(r));
85 return object_as_type(obj, OBJ_COMMIT, 0);
86}
87
88struct commit *lookup_commit_reference_by_name(const char *name)
89{
90 return lookup_commit_reference_by_name_gently(name, 0);
91}
92
93struct commit *lookup_commit_reference_by_name_gently(const char *name,
94 int quiet)
95{
96 struct object_id oid;
97 struct commit *commit;
98
99 if (repo_get_oid_committish(the_repository, name, &oid))
100 return NULL;
101 commit = lookup_commit_reference_gently(the_repository, &oid, quiet);
102 if (repo_parse_commit(the_repository, commit))
103 return NULL;
104 return commit;
105}
106
107static timestamp_t parse_commit_date(const char *buf, const char *tail)
108{
109 const char *dateptr;
110 const char *eol;
111
112 if (buf + 6 >= tail)
113 return 0;
114 if (memcmp(buf, "author", 6))
115 return 0;
116 while (buf < tail && *buf++ != '\n')
117 /* nada */;
118 if (buf + 9 >= tail)
119 return 0;
120 if (memcmp(buf, "committer", 9))
121 return 0;
122
123 /*
124 * Jump to end-of-line so that we can walk backwards to find the
125 * end-of-email ">". This is more forgiving of malformed cases
126 * because unexpected characters tend to be in the name and email
127 * fields.
128 */
129 eol = memchr(buf, '\n', tail - buf);
130 if (!eol)
131 return 0;
132 dateptr = eol;
133 while (dateptr > buf && dateptr[-1] != '>')
134 dateptr--;
135 if (dateptr == buf)
136 return 0;
137
138 /*
139 * Trim leading whitespace, but make sure we have at least one
140 * non-whitespace character, as parse_timestamp() will otherwise walk
141 * right past the newline we found in "eol" when skipping whitespace
142 * itself.
143 *
144 * In theory it would be sufficient to allow any character not matched
145 * by isspace(), but there's a catch: our isspace() does not
146 * necessarily match the behavior of parse_timestamp(), as the latter
147 * is implemented by system routines which match more exotic control
148 * codes, or even locale-dependent sequences.
149 *
150 * Since we expect the timestamp to be a number, we can check for that.
151 * Anything else (e.g., a non-numeric token like "foo") would just
152 * cause parse_timestamp() to return 0 anyway.
153 */
154 while (dateptr < eol && isspace(*dateptr))
155 dateptr++;
156 if (!isdigit(*dateptr) && *dateptr != '-')
157 return 0;
158
159 /*
160 * We know there is at least one digit (or dash), so we'll begin
161 * parsing there and stop at worst case at eol.
162 *
163 * Note that we may feed parse_timestamp() extra characters here if the
164 * commit is malformed, and it will parse as far as it can. For
165 * example, "123foo456" would return "123". That might be questionable
166 * (versus returning "0"), but it would help in a hypothetical case
167 * like "123456+0100", where the whitespace from the timezone is
168 * missing. Since such syntactic errors may be baked into history and
169 * hard to correct now, let's err on trying to make our best guess
170 * here, rather than insist on perfect syntax.
171 */
172 return parse_timestamp(dateptr, NULL, 10);
173}
174
175static const struct object_id *commit_graft_oid_access(size_t index, const void *table)
176{
177 const struct commit_graft * const *commit_graft_table = table;
178 return &commit_graft_table[index]->oid;
179}
180
181int commit_graft_pos(struct repository *r, const struct object_id *oid)
182{
183 return oid_pos(oid, r->parsed_objects->grafts,
184 r->parsed_objects->grafts_nr,
185 commit_graft_oid_access);
186}
187
188void unparse_commit(struct repository *r, const struct object_id *oid)
189{
190 struct commit *c = lookup_commit(r, oid);
191
192 if (!c->object.parsed)
193 return;
194 free_commit_list(c->parents);
195 c->parents = NULL;
196 c->object.parsed = 0;
197}
198
199int register_commit_graft(struct repository *r, struct commit_graft *graft,
200 int ignore_dups)
201{
202 int pos = commit_graft_pos(r, &graft->oid);
203
204 if (0 <= pos) {
205 if (ignore_dups)
206 free(graft);
207 else {
208 free(r->parsed_objects->grafts[pos]);
209 r->parsed_objects->grafts[pos] = graft;
210 }
211 return 1;
212 }
213 pos = -pos - 1;
214 ALLOC_GROW(r->parsed_objects->grafts,
215 r->parsed_objects->grafts_nr + 1,
216 r->parsed_objects->grafts_alloc);
217 r->parsed_objects->grafts_nr++;
218 if (pos < r->parsed_objects->grafts_nr)
219 memmove(r->parsed_objects->grafts + pos + 1,
220 r->parsed_objects->grafts + pos,
221 (r->parsed_objects->grafts_nr - pos - 1) *
222 sizeof(*r->parsed_objects->grafts));
223 r->parsed_objects->grafts[pos] = graft;
224 unparse_commit(r, &graft->oid);
225 return 0;
226}
227
228struct commit_graft *read_graft_line(struct strbuf *line)
229{
230 /* The format is just "Commit Parent1 Parent2 ...\n" */
231 int i, phase;
232 const char *tail = NULL;
233 struct commit_graft *graft = NULL;
234 struct object_id dummy_oid, *oid;
235
236 strbuf_rtrim(line);
237 if (!line->len || line->buf[0] == '#')
238 return NULL;
239 /*
240 * phase 0 verifies line, counts hashes in line and allocates graft
241 * phase 1 fills graft
242 */
243 for (phase = 0; phase < 2; phase++) {
244 oid = graft ? &graft->oid : &dummy_oid;
245 if (parse_oid_hex(line->buf, oid, &tail))
246 goto bad_graft_data;
247 for (i = 0; *tail != '\0'; i++) {
248 oid = graft ? &graft->parent[i] : &dummy_oid;
249 if (!isspace(*tail++) || parse_oid_hex(tail, oid, &tail))
250 goto bad_graft_data;
251 }
252 if (!graft) {
253 graft = xmalloc(st_add(sizeof(*graft),
254 st_mult(sizeof(struct object_id), i)));
255 graft->nr_parent = i;
256 }
257 }
258 return graft;
259
260bad_graft_data:
261 error("bad graft data: %s", line->buf);
262 assert(!graft);
263 return NULL;
264}
265
266static int read_graft_file(struct repository *r, const char *graft_file)
267{
268 FILE *fp = fopen_or_warn(graft_file, "r");
269 struct strbuf buf = STRBUF_INIT;
270 if (!fp)
271 return -1;
272 if (!no_graft_file_deprecated_advice &&
273 advice_enabled(ADVICE_GRAFT_FILE_DEPRECATED))
274 advise(_("Support for <GIT_DIR>/info/grafts is deprecated\n"
275 "and will be removed in a future Git version.\n"
276 "\n"
277 "Please use \"git replace --convert-graft-file\"\n"
278 "to convert the grafts into replace refs.\n"
279 "\n"
280 "Turn this message off by running\n"
281 "\"git config set advice.graftFileDeprecated false\""));
282 while (!strbuf_getwholeline(&buf, fp, '\n')) {
283 /* The format is just "Commit Parent1 Parent2 ...\n" */
284 struct commit_graft *graft = read_graft_line(&buf);
285 if (!graft)
286 continue;
287 if (register_commit_graft(r, graft, 1))
288 error("duplicate graft data: %s", buf.buf);
289 }
290 fclose(fp);
291 strbuf_release(&buf);
292 return 0;
293}
294
295void prepare_commit_graft(struct repository *r)
296{
297 const char *graft_file;
298
299 if (r->parsed_objects->commit_graft_prepared)
300 return;
301 if (!startup_info->have_repository)
302 return;
303
304 graft_file = repo_get_graft_file(r);
305 read_graft_file(r, graft_file);
306 /* make sure shallows are read */
307 is_repository_shallow(r);
308 r->parsed_objects->commit_graft_prepared = 1;
309}
310
311struct commit_graft *lookup_commit_graft(struct repository *r, const struct object_id *oid)
312{
313 int pos;
314 prepare_commit_graft(r);
315 pos = commit_graft_pos(r, oid);
316 if (pos < 0)
317 return NULL;
318 return r->parsed_objects->grafts[pos];
319}
320
321int for_each_commit_graft(each_commit_graft_fn fn, void *cb_data)
322{
323 int i, ret;
324 for (i = ret = 0; i < the_repository->parsed_objects->grafts_nr && !ret; i++)
325 ret = fn(the_repository->parsed_objects->grafts[i], cb_data);
326 return ret;
327}
328
329struct commit_buffer {
330 void *buffer;
331 unsigned long size;
332};
333define_commit_slab(buffer_slab, struct commit_buffer);
334
335struct buffer_slab *allocate_commit_buffer_slab(void)
336{
337 struct buffer_slab *bs = xmalloc(sizeof(*bs));
338 init_buffer_slab(bs);
339 return bs;
340}
341
342void free_commit_buffer_slab(struct buffer_slab *bs)
343{
344 clear_buffer_slab(bs);
345 free(bs);
346}
347
348void set_commit_buffer(struct repository *r, struct commit *commit, void *buffer, unsigned long size)
349{
350 struct commit_buffer *v = buffer_slab_at(
351 r->parsed_objects->buffer_slab, commit);
352 v->buffer = buffer;
353 v->size = size;
354}
355
356const void *get_cached_commit_buffer(struct repository *r, const struct commit *commit, unsigned long *sizep)
357{
358 struct commit_buffer *v = buffer_slab_peek(
359 r->parsed_objects->buffer_slab, commit);
360 if (!v) {
361 if (sizep)
362 *sizep = 0;
363 return NULL;
364 }
365 if (sizep)
366 *sizep = v->size;
367 return v->buffer;
368}
369
370const void *repo_get_commit_buffer(struct repository *r,
371 const struct commit *commit,
372 unsigned long *sizep)
373{
374 const void *ret = get_cached_commit_buffer(r, commit, sizep);
375 if (!ret) {
376 enum object_type type;
377 unsigned long size;
378 ret = odb_read_object(r->objects, &commit->object.oid, &type, &size);
379 if (!ret)
380 die("cannot read commit object %s",
381 oid_to_hex(&commit->object.oid));
382 if (type != OBJ_COMMIT)
383 die("expected commit for %s, got %s",
384 oid_to_hex(&commit->object.oid), type_name(type));
385 if (sizep)
386 *sizep = size;
387 }
388 return ret;
389}
390
391void repo_unuse_commit_buffer(struct repository *r,
392 const struct commit *commit,
393 const void *buffer)
394{
395 struct commit_buffer *v = buffer_slab_peek(
396 r->parsed_objects->buffer_slab, commit);
397 if (!(v && v->buffer == buffer))
398 free((void *)buffer);
399}
400
401void free_commit_buffer(struct parsed_object_pool *pool, struct commit *commit)
402{
403 struct commit_buffer *v = buffer_slab_peek(
404 pool->buffer_slab, commit);
405 if (v) {
406 FREE_AND_NULL(v->buffer);
407 v->size = 0;
408 }
409}
410
411static inline void set_commit_tree(struct commit *c, struct tree *t)
412{
413 c->maybe_tree = t;
414}
415
416struct tree *repo_get_commit_tree(struct repository *r,
417 const struct commit *commit)
418{
419 if (commit->maybe_tree || !commit->object.parsed)
420 return commit->maybe_tree;
421
422 if (commit_graph_position(commit) != COMMIT_NOT_FROM_GRAPH)
423 return get_commit_tree_in_graph(r, commit);
424
425 return NULL;
426}
427
428struct object_id *get_commit_tree_oid(const struct commit *commit)
429{
430 struct tree *tree = repo_get_commit_tree(the_repository, commit);
431 return tree ? &tree->object.oid : NULL;
432}
433
434void release_commit_memory(struct parsed_object_pool *pool, struct commit *c)
435{
436 set_commit_tree(c, NULL);
437 free_commit_buffer(pool, c);
438 c->index = 0;
439 free_commit_list(c->parents);
440
441 c->object.parsed = 0;
442}
443
444const void *detach_commit_buffer(struct commit *commit, unsigned long *sizep)
445{
446 struct commit_buffer *v = buffer_slab_peek(
447 the_repository->parsed_objects->buffer_slab, commit);
448 void *ret;
449
450 if (!v) {
451 if (sizep)
452 *sizep = 0;
453 return NULL;
454 }
455 ret = v->buffer;
456 if (sizep)
457 *sizep = v->size;
458
459 v->buffer = NULL;
460 v->size = 0;
461 return ret;
462}
463
464int parse_commit_buffer(struct repository *r, struct commit *item, const void *buffer, unsigned long size, int check_graph)
465{
466 const char *tail = buffer;
467 const char *bufptr = buffer;
468 struct object_id parent;
469 struct commit_list **pptr;
470 struct commit_graft *graft;
471 const int tree_entry_len = the_hash_algo->hexsz + 5;
472 const int parent_entry_len = the_hash_algo->hexsz + 7;
473 struct tree *tree;
474
475 if (item->object.parsed)
476 return 0;
477 /*
478 * Presumably this is leftover from an earlier failed parse;
479 * clear it out in preparation for us re-parsing (we'll hit the
480 * same error, but that's good, since it lets our caller know
481 * the result cannot be trusted.
482 */
483 free_commit_list(item->parents);
484 item->parents = NULL;
485
486 tail += size;
487 if (tail <= bufptr + tree_entry_len + 1 || memcmp(bufptr, "tree ", 5) ||
488 bufptr[tree_entry_len] != '\n')
489 return error("bogus commit object %s", oid_to_hex(&item->object.oid));
490 if (get_oid_hex(bufptr + 5, &parent) < 0)
491 return error("bad tree pointer in commit %s",
492 oid_to_hex(&item->object.oid));
493 tree = lookup_tree(r, &parent);
494 if (!tree)
495 return error("bad tree pointer %s in commit %s",
496 oid_to_hex(&parent),
497 oid_to_hex(&item->object.oid));
498 set_commit_tree(item, tree);
499 bufptr += tree_entry_len + 1; /* "tree " + "hex sha1" + "\n" */
500 pptr = &item->parents;
501
502 graft = lookup_commit_graft(r, &item->object.oid);
503 if (graft)
504 r->parsed_objects->substituted_parent = 1;
505 while (bufptr + parent_entry_len < tail && !memcmp(bufptr, "parent ", 7)) {
506 struct commit *new_parent;
507
508 if (tail <= bufptr + parent_entry_len + 1 ||
509 get_oid_hex(bufptr + 7, &parent) ||
510 bufptr[parent_entry_len] != '\n')
511 return error("bad parents in commit %s", oid_to_hex(&item->object.oid));
512 bufptr += parent_entry_len + 1;
513 /*
514 * The clone is shallow if nr_parent < 0, and we must
515 * not traverse its real parents even when we unhide them.
516 */
517 if (graft && (graft->nr_parent < 0 || !grafts_keep_true_parents))
518 continue;
519 new_parent = lookup_commit(r, &parent);
520 if (!new_parent)
521 return error("bad parent %s in commit %s",
522 oid_to_hex(&parent),
523 oid_to_hex(&item->object.oid));
524 pptr = &commit_list_insert(new_parent, pptr)->next;
525 }
526 if (graft) {
527 int i;
528 struct commit *new_parent;
529 for (i = 0; i < graft->nr_parent; i++) {
530 new_parent = lookup_commit(r,
531 &graft->parent[i]);
532 if (!new_parent)
533 return error("bad graft parent %s in commit %s",
534 oid_to_hex(&graft->parent[i]),
535 oid_to_hex(&item->object.oid));
536 pptr = &commit_list_insert(new_parent, pptr)->next;
537 }
538 }
539 item->date = parse_commit_date(bufptr, tail);
540
541 if (check_graph)
542 load_commit_graph_info(r, item);
543
544 item->object.parsed = 1;
545 return 0;
546}
547
548int repo_parse_commit_internal(struct repository *r,
549 struct commit *item,
550 int quiet_on_missing,
551 int use_commit_graph)
552{
553 enum object_type type;
554 void *buffer;
555 unsigned long size;
556 struct object_info oi = {
557 .typep = &type,
558 .sizep = &size,
559 .contentp = &buffer,
560 };
561 /*
562 * Git does not support partial clones that exclude commits, so set
563 * OBJECT_INFO_SKIP_FETCH_OBJECT to fail fast when an object is missing.
564 */
565 int flags = OBJECT_INFO_LOOKUP_REPLACE | OBJECT_INFO_SKIP_FETCH_OBJECT |
566 OBJECT_INFO_DIE_IF_CORRUPT;
567 int ret;
568
569 if (!item)
570 return -1;
571 if (item->object.parsed)
572 return 0;
573 if (use_commit_graph && parse_commit_in_graph(r, item)) {
574 static int commit_graph_paranoia = -1;
575
576 if (commit_graph_paranoia == -1)
577 commit_graph_paranoia = git_env_bool(GIT_COMMIT_GRAPH_PARANOIA, 0);
578
579 if (commit_graph_paranoia && !odb_has_object(r->objects, &item->object.oid, 0)) {
580 unparse_commit(r, &item->object.oid);
581 return quiet_on_missing ? -1 :
582 error(_("commit %s exists in commit-graph but not in the object database"),
583 oid_to_hex(&item->object.oid));
584 }
585
586 return 0;
587 }
588
589 if (odb_read_object_info_extended(r->objects, &item->object.oid,
590 &oi, flags) < 0)
591 return quiet_on_missing ? -1 :
592 error("Could not read %s",
593 oid_to_hex(&item->object.oid));
594 if (type != OBJ_COMMIT) {
595 free(buffer);
596 return error("Object %s not a commit",
597 oid_to_hex(&item->object.oid));
598 }
599
600 ret = parse_commit_buffer(r, item, buffer, size, 0);
601 if (save_commit_buffer && !ret &&
602 !get_cached_commit_buffer(r, item, NULL)) {
603 set_commit_buffer(r, item, buffer, size);
604 return 0;
605 }
606 free(buffer);
607 return ret;
608}
609
610int repo_parse_commit_gently(struct repository *r,
611 struct commit *item, int quiet_on_missing)
612{
613 return repo_parse_commit_internal(r, item, quiet_on_missing, 1);
614}
615
616void parse_commit_or_die(struct commit *item)
617{
618 if (repo_parse_commit(the_repository, item))
619 die("unable to parse commit %s",
620 item ? oid_to_hex(&item->object.oid) : "(null)");
621}
622
623int find_commit_subject(const char *commit_buffer, const char **subject)
624{
625 const char *eol;
626 const char *p = commit_buffer;
627
628 while (*p && (*p != '\n' || p[1] != '\n'))
629 p++;
630 if (*p) {
631 p = skip_blank_lines(p + 2);
632 eol = strchrnul(p, '\n');
633 } else
634 eol = p;
635
636 *subject = p;
637
638 return eol - p;
639}
640
641size_t commit_subject_length(const char *body)
642{
643 const char *p = body;
644 while (*p) {
645 const char *next = skip_blank_lines(p);
646 if (next != p)
647 break;
648 p = strchrnul(p, '\n');
649 if (*p)
650 p++;
651 }
652 return p - body;
653}
654
655struct commit_list *commit_list_insert(struct commit *item, struct commit_list **list_p)
656{
657 struct commit_list *new_list = xmalloc(sizeof(struct commit_list));
658 new_list->item = item;
659 new_list->next = *list_p;
660 *list_p = new_list;
661 return new_list;
662}
663
664int commit_list_contains(struct commit *item, struct commit_list *list)
665{
666 while (list) {
667 if (list->item == item)
668 return 1;
669 list = list->next;
670 }
671
672 return 0;
673}
674
675unsigned commit_list_count(const struct commit_list *l)
676{
677 unsigned c = 0;
678 for (; l; l = l->next )
679 c++;
680 return c;
681}
682
683struct commit_list *copy_commit_list(const struct commit_list *list)
684{
685 struct commit_list *head = NULL;
686 struct commit_list **pp = &head;
687 while (list) {
688 pp = commit_list_append(list->item, pp);
689 list = list->next;
690 }
691 return head;
692}
693
694struct commit_list *reverse_commit_list(struct commit_list *list)
695{
696 struct commit_list *next = NULL, *current, *backup;
697 for (current = list; current; current = backup) {
698 backup = current->next;
699 current->next = next;
700 next = current;
701 }
702 return next;
703}
704
705void free_commit_list(struct commit_list *list)
706{
707 while (list)
708 pop_commit(&list);
709}
710
711struct commit_list * commit_list_insert_by_date(struct commit *item, struct commit_list **list)
712{
713 struct commit_list **pp = list;
714 struct commit_list *p;
715 while ((p = *pp) != NULL) {
716 if (p->item->date < item->date) {
717 break;
718 }
719 pp = &p->next;
720 }
721 return commit_list_insert(item, pp);
722}
723
724static int commit_list_compare_by_date(const struct commit_list *a,
725 const struct commit_list *b)
726{
727 timestamp_t a_date = a->item->date;
728 timestamp_t b_date = b->item->date;
729 if (a_date < b_date)
730 return 1;
731 if (a_date > b_date)
732 return -1;
733 return 0;
734}
735
736DEFINE_LIST_SORT(static, commit_list_sort, struct commit_list, next);
737
738void commit_list_sort_by_date(struct commit_list **list)
739{
740 commit_list_sort(list, commit_list_compare_by_date);
741}
742
743struct commit *pop_most_recent_commit(struct prio_queue *queue,
744 unsigned int mark)
745{
746 struct commit *ret = prio_queue_peek(queue);
747 int get_pending = 1;
748 struct commit_list *parents = ret->parents;
749
750 while (parents) {
751 struct commit *commit = parents->item;
752 if (!repo_parse_commit(the_repository, commit) && !(commit->object.flags & mark)) {
753 commit->object.flags |= mark;
754 if (get_pending)
755 prio_queue_replace(queue, commit);
756 else
757 prio_queue_put(queue, commit);
758 get_pending = 0;
759 }
760 parents = parents->next;
761 }
762 if (get_pending)
763 prio_queue_get(queue);
764 return ret;
765}
766
767static void clear_commit_marks_1(struct commit_list **plist,
768 struct commit *commit, unsigned int mark)
769{
770 while (commit) {
771 struct commit_list *parents;
772
773 if (!(mark & commit->object.flags))
774 return;
775
776 commit->object.flags &= ~mark;
777
778 parents = commit->parents;
779 if (!parents)
780 return;
781
782 while ((parents = parents->next)) {
783 if (parents->item->object.flags & mark)
784 commit_list_insert(parents->item, plist);
785 }
786
787 commit = commit->parents->item;
788 }
789}
790
791void clear_commit_marks_many(size_t nr, struct commit **commit, unsigned int mark)
792{
793 for (size_t i = 0; i < nr; i++)
794 clear_commit_marks(commit[i], mark);
795}
796
797void clear_commit_marks(struct commit *commit, unsigned int mark)
798{
799 struct commit_list *list = NULL;
800
801 clear_commit_marks_1(&list, commit, mark);
802 while (list)
803 clear_commit_marks_1(&list, pop_commit(&list), mark);
804}
805
806struct commit *pop_commit(struct commit_list **stack)
807{
808 struct commit_list *top = *stack;
809 struct commit *item = top ? top->item : NULL;
810
811 if (top) {
812 *stack = top->next;
813 free(top);
814 }
815 return item;
816}
817
818/*
819 * Topological sort support
820 */
821
822/* count number of children that have not been emitted */
823define_commit_slab(indegree_slab, int);
824
825define_commit_slab(author_date_slab, timestamp_t);
826
827void record_author_date(struct author_date_slab *author_date,
828 struct commit *commit)
829{
830 const char *buffer = repo_get_commit_buffer(the_repository, commit,
831 NULL);
832 struct ident_split ident;
833 const char *ident_line;
834 size_t ident_len;
835 char *date_end;
836 timestamp_t date;
837
838 ident_line = find_commit_header(buffer, "author", &ident_len);
839 if (!ident_line)
840 goto fail_exit; /* no author line */
841 if (split_ident_line(&ident, ident_line, ident_len) ||
842 !ident.date_begin || !ident.date_end)
843 goto fail_exit; /* malformed "author" line */
844
845 date = parse_timestamp(ident.date_begin, &date_end, 10);
846 if (date_end != ident.date_end)
847 goto fail_exit; /* malformed date */
848 *(author_date_slab_at(author_date, commit)) = date;
849
850fail_exit:
851 repo_unuse_commit_buffer(the_repository, commit, buffer);
852}
853
854int compare_commits_by_author_date(const void *a_, const void *b_,
855 void *cb_data)
856{
857 const struct commit *a = a_, *b = b_;
858 struct author_date_slab *author_date = cb_data;
859 timestamp_t a_date = *(author_date_slab_at(author_date, a));
860 timestamp_t b_date = *(author_date_slab_at(author_date, b));
861
862 /* newer commits with larger date first */
863 if (a_date < b_date)
864 return 1;
865 else if (a_date > b_date)
866 return -1;
867 return 0;
868}
869
870int compare_commits_by_gen_then_commit_date(const void *a_, const void *b_,
871 void *unused UNUSED)
872{
873 const struct commit *a = a_, *b = b_;
874 const timestamp_t generation_a = commit_graph_generation(a),
875 generation_b = commit_graph_generation(b);
876
877 /* newer commits first */
878 if (generation_a < generation_b)
879 return 1;
880 else if (generation_a > generation_b)
881 return -1;
882
883 /* use date as a heuristic when generations are equal */
884 if (a->date < b->date)
885 return 1;
886 else if (a->date > b->date)
887 return -1;
888 return 0;
889}
890
891int compare_commits_by_commit_date(const void *a_, const void *b_,
892 void *unused UNUSED)
893{
894 const struct commit *a = a_, *b = b_;
895 /* newer commits with larger date first */
896 if (a->date < b->date)
897 return 1;
898 else if (a->date > b->date)
899 return -1;
900 return 0;
901}
902
903/*
904 * Performs an in-place topological sort on the list supplied.
905 */
906void sort_in_topological_order(struct commit_list **list, enum rev_sort_order sort_order)
907{
908 struct commit_list *next, *orig = *list;
909 struct commit_list **pptr;
910 struct indegree_slab indegree;
911 struct prio_queue queue;
912 struct commit *commit;
913 struct author_date_slab author_date;
914
915 if (!orig)
916 return;
917 *list = NULL;
918
919 init_indegree_slab(&indegree);
920 memset(&queue, '\0', sizeof(queue));
921
922 switch (sort_order) {
923 default: /* REV_SORT_IN_GRAPH_ORDER */
924 queue.compare = NULL;
925 break;
926 case REV_SORT_BY_COMMIT_DATE:
927 queue.compare = compare_commits_by_commit_date;
928 break;
929 case REV_SORT_BY_AUTHOR_DATE:
930 init_author_date_slab(&author_date);
931 queue.compare = compare_commits_by_author_date;
932 queue.cb_data = &author_date;
933 break;
934 }
935
936 /* Mark them and clear the indegree */
937 for (next = orig; next; next = next->next) {
938 struct commit *commit = next->item;
939 *(indegree_slab_at(&indegree, commit)) = 1;
940 /* also record the author dates, if needed */
941 if (sort_order == REV_SORT_BY_AUTHOR_DATE)
942 record_author_date(&author_date, commit);
943 }
944
945 /* update the indegree */
946 for (next = orig; next; next = next->next) {
947 struct commit_list *parents = next->item->parents;
948 while (parents) {
949 struct commit *parent = parents->item;
950 int *pi = indegree_slab_at(&indegree, parent);
951
952 if (*pi)
953 (*pi)++;
954 parents = parents->next;
955 }
956 }
957
958 /*
959 * find the tips
960 *
961 * tips are nodes not reachable from any other node in the list
962 *
963 * the tips serve as a starting set for the work queue.
964 */
965 for (next = orig; next; next = next->next) {
966 struct commit *commit = next->item;
967
968 if (*(indegree_slab_at(&indegree, commit)) == 1)
969 prio_queue_put(&queue, commit);
970 }
971
972 /*
973 * This is unfortunate; the initial tips need to be shown
974 * in the order given from the revision traversal machinery.
975 */
976 if (sort_order == REV_SORT_IN_GRAPH_ORDER)
977 prio_queue_reverse(&queue);
978
979 /* We no longer need the commit list */
980 free_commit_list(orig);
981
982 pptr = list;
983 *list = NULL;
984 while ((commit = prio_queue_get(&queue)) != NULL) {
985 struct commit_list *parents;
986
987 for (parents = commit->parents; parents ; parents = parents->next) {
988 struct commit *parent = parents->item;
989 int *pi = indegree_slab_at(&indegree, parent);
990
991 if (!*pi)
992 continue;
993
994 /*
995 * parents are only enqueued for emission
996 * when all their children have been emitted thereby
997 * guaranteeing topological order.
998 */
999 if (--(*pi) == 1)
1000 prio_queue_put(&queue, parent);
1001 }
1002 /*
1003 * all children of commit have already been
1004 * emitted. we can emit it now.
1005 */
1006 *(indegree_slab_at(&indegree, commit)) = 0;
1007
1008 pptr = &commit_list_insert(commit, pptr)->next;
1009 }
1010
1011 clear_indegree_slab(&indegree);
1012 clear_prio_queue(&queue);
1013 if (sort_order == REV_SORT_BY_AUTHOR_DATE)
1014 clear_author_date_slab(&author_date);
1015}
1016
1017struct rev_collect {
1018 struct commit **commit;
1019 int nr;
1020 int alloc;
1021 unsigned int initial : 1;
1022};
1023
1024static void add_one_commit(struct object_id *oid, struct rev_collect *revs)
1025{
1026 struct commit *commit;
1027
1028 if (is_null_oid(oid))
1029 return;
1030
1031 commit = lookup_commit(the_repository, oid);
1032 if (!commit ||
1033 (commit->object.flags & TMP_MARK) ||
1034 repo_parse_commit(the_repository, commit))
1035 return;
1036
1037 ALLOC_GROW(revs->commit, revs->nr + 1, revs->alloc);
1038 revs->commit[revs->nr++] = commit;
1039 commit->object.flags |= TMP_MARK;
1040}
1041
1042static int collect_one_reflog_ent(const char *refname UNUSED,
1043 struct object_id *ooid, struct object_id *noid,
1044 const char *ident UNUSED,
1045 timestamp_t timestamp UNUSED, int tz UNUSED,
1046 const char *message UNUSED, void *cbdata)
1047{
1048 struct rev_collect *revs = cbdata;
1049
1050 if (revs->initial) {
1051 revs->initial = 0;
1052 add_one_commit(ooid, revs);
1053 }
1054 add_one_commit(noid, revs);
1055 return 0;
1056}
1057
1058struct commit *get_fork_point(const char *refname, struct commit *commit)
1059{
1060 struct object_id oid;
1061 struct rev_collect revs;
1062 struct commit_list *bases = NULL;
1063 int i;
1064 struct commit *ret = NULL;
1065 char *full_refname;
1066
1067 switch (repo_dwim_ref(the_repository, refname, strlen(refname), &oid,
1068 &full_refname, 0)) {
1069 case 0:
1070 die("No such ref: '%s'", refname);
1071 case 1:
1072 break; /* good */
1073 default:
1074 die("Ambiguous refname: '%s'", refname);
1075 }
1076
1077 memset(&revs, 0, sizeof(revs));
1078 revs.initial = 1;
1079 refs_for_each_reflog_ent(get_main_ref_store(the_repository),
1080 full_refname, collect_one_reflog_ent, &revs);
1081
1082 if (!revs.nr)
1083 add_one_commit(&oid, &revs);
1084
1085 for (i = 0; i < revs.nr; i++)
1086 revs.commit[i]->object.flags &= ~TMP_MARK;
1087
1088 if (repo_get_merge_bases_many(the_repository, commit, revs.nr,
1089 revs.commit, &bases) < 0)
1090 exit(128);
1091
1092 /*
1093 * There should be one and only one merge base, when we found
1094 * a common ancestor among reflog entries.
1095 */
1096 if (!bases || bases->next)
1097 goto cleanup_return;
1098
1099 /* And the found one must be one of the reflog entries */
1100 for (i = 0; i < revs.nr; i++)
1101 if (&bases->item->object == &revs.commit[i]->object)
1102 break; /* found */
1103 if (revs.nr <= i)
1104 goto cleanup_return;
1105
1106 ret = bases->item;
1107
1108cleanup_return:
1109 free(revs.commit);
1110 free_commit_list(bases);
1111 free(full_refname);
1112 return ret;
1113}
1114
1115/*
1116 * Indexed by hash algorithm identifier.
1117 */
1118static const char *gpg_sig_headers[] = {
1119 NULL,
1120 "gpgsig",
1121 "gpgsig-sha256",
1122};
1123
1124int add_header_signature(struct strbuf *buf, struct strbuf *sig, const struct git_hash_algo *algo)
1125{
1126 int inspos, copypos;
1127 const char *eoh;
1128 const char *gpg_sig_header = gpg_sig_headers[hash_algo_by_ptr(algo)];
1129 int gpg_sig_header_len = strlen(gpg_sig_header);
1130
1131 /* find the end of the header */
1132 eoh = strstr(buf->buf, "\n\n");
1133 if (!eoh)
1134 inspos = buf->len;
1135 else
1136 inspos = eoh - buf->buf + 1;
1137
1138 for (copypos = 0; sig->buf[copypos]; ) {
1139 const char *bol = sig->buf + copypos;
1140 const char *eol = strchrnul(bol, '\n');
1141 int len = (eol - bol) + !!*eol;
1142
1143 if (!copypos) {
1144 strbuf_insert(buf, inspos, gpg_sig_header, gpg_sig_header_len);
1145 inspos += gpg_sig_header_len;
1146 }
1147 strbuf_insertstr(buf, inspos++, " ");
1148 strbuf_insert(buf, inspos, bol, len);
1149 inspos += len;
1150 copypos += len;
1151 }
1152 return 0;
1153}
1154
1155static int sign_commit_to_strbuf(struct strbuf *sig, struct strbuf *buf, const char *keyid)
1156{
1157 char *keyid_to_free = NULL;
1158 int ret = 0;
1159 if (!keyid || !*keyid)
1160 keyid = keyid_to_free = get_signing_key();
1161 if (sign_buffer(buf, sig, keyid))
1162 ret = -1;
1163 free(keyid_to_free);
1164 return ret;
1165}
1166
1167int parse_signed_commit(const struct commit *commit,
1168 struct strbuf *payload, struct strbuf *signature,
1169 const struct git_hash_algo *algop)
1170{
1171 unsigned long size;
1172 const char *buffer = repo_get_commit_buffer(the_repository, commit,
1173 &size);
1174 int ret = parse_buffer_signed_by_header(buffer, size, payload, signature, algop);
1175
1176 repo_unuse_commit_buffer(the_repository, commit, buffer);
1177 return ret;
1178}
1179
1180int parse_buffer_signed_by_header(const char *buffer,
1181 unsigned long size,
1182 struct strbuf *payload,
1183 struct strbuf *signature,
1184 const struct git_hash_algo *algop)
1185{
1186 int in_signature = 0, saw_signature = 0, other_signature = 0;
1187 const char *line, *tail, *p;
1188 const char *gpg_sig_header = gpg_sig_headers[hash_algo_by_ptr(algop)];
1189
1190 line = buffer;
1191 tail = buffer + size;
1192 while (line < tail) {
1193 const char *sig = NULL;
1194 const char *next = memchr(line, '\n', tail - line);
1195
1196 next = next ? next + 1 : tail;
1197 if (in_signature && line[0] == ' ')
1198 sig = line + 1;
1199 else if (skip_prefix(line, gpg_sig_header, &p) &&
1200 *p == ' ') {
1201 sig = line + strlen(gpg_sig_header) + 1;
1202 other_signature = 0;
1203 }
1204 else if (starts_with(line, "gpgsig"))
1205 other_signature = 1;
1206 else if (other_signature && line[0] != ' ')
1207 other_signature = 0;
1208 if (sig) {
1209 strbuf_add(signature, sig, next - sig);
1210 saw_signature = 1;
1211 in_signature = 1;
1212 } else {
1213 if (*line == '\n')
1214 /* dump the whole remainder of the buffer */
1215 next = tail;
1216 if (!other_signature)
1217 strbuf_add(payload, line, next - line);
1218 in_signature = 0;
1219 }
1220 line = next;
1221 }
1222 return saw_signature;
1223}
1224
1225int remove_signature(struct strbuf *buf)
1226{
1227 const char *line = buf->buf;
1228 const char *tail = buf->buf + buf->len;
1229 int in_signature = 0;
1230 struct sigbuf {
1231 const char *start;
1232 const char *end;
1233 } sigs[2], *sigp = &sigs[0];
1234 int i;
1235 const char *orig_buf = buf->buf;
1236
1237 memset(sigs, 0, sizeof(sigs));
1238
1239 while (line < tail) {
1240 const char *next = memchr(line, '\n', tail - line);
1241 next = next ? next + 1 : tail;
1242
1243 if (in_signature && line[0] == ' ')
1244 sigp->end = next;
1245 else if (starts_with(line, "gpgsig")) {
1246 int i;
1247 for (i = 1; i < GIT_HASH_NALGOS; i++) {
1248 const char *p;
1249 if (skip_prefix(line, gpg_sig_headers[i], &p) &&
1250 *p == ' ') {
1251 sigp->start = line;
1252 sigp->end = next;
1253 in_signature = 1;
1254 }
1255 }
1256 } else {
1257 if (*line == '\n')
1258 /* dump the whole remainder of the buffer */
1259 next = tail;
1260 if (in_signature && sigp - sigs != ARRAY_SIZE(sigs))
1261 sigp++;
1262 in_signature = 0;
1263 }
1264 line = next;
1265 }
1266
1267 for (i = ARRAY_SIZE(sigs) - 1; i >= 0; i--)
1268 if (sigs[i].start)
1269 strbuf_remove(buf, sigs[i].start - orig_buf, sigs[i].end - sigs[i].start);
1270
1271 return sigs[0].start != NULL;
1272}
1273
1274static void handle_signed_tag(const struct commit *parent, struct commit_extra_header ***tail)
1275{
1276 struct merge_remote_desc *desc;
1277 struct commit_extra_header *mergetag;
1278 char *buf;
1279 unsigned long size;
1280 enum object_type type;
1281 struct strbuf payload = STRBUF_INIT;
1282 struct strbuf signature = STRBUF_INIT;
1283
1284 desc = merge_remote_util(parent);
1285 if (!desc || !desc->obj)
1286 return;
1287 buf = odb_read_object(the_repository->objects, &desc->obj->oid,
1288 &type, &size);
1289 if (!buf || type != OBJ_TAG)
1290 goto free_return;
1291 if (!parse_signature(buf, size, &payload, &signature))
1292 goto free_return;
1293 /*
1294 * We could verify this signature and either omit the tag when
1295 * it does not validate, but the integrator may not have the
1296 * public key of the signer of the tag being merged, while a
1297 * later auditor may have it while auditing, so let's not run
1298 * verify-signed-buffer here for now...
1299 *
1300 * if (verify_signed_buffer(buf, len, buf + len, size - len, ...))
1301 * warn("warning: signed tag unverified.");
1302 */
1303 CALLOC_ARRAY(mergetag, 1);
1304 mergetag->key = xstrdup("mergetag");
1305 mergetag->value = buf;
1306 mergetag->len = size;
1307
1308 **tail = mergetag;
1309 *tail = &mergetag->next;
1310 strbuf_release(&payload);
1311 strbuf_release(&signature);
1312 return;
1313
1314free_return:
1315 free(buf);
1316}
1317
1318int check_commit_signature(const struct commit *commit, struct signature_check *sigc)
1319{
1320 struct strbuf payload = STRBUF_INIT;
1321 struct strbuf signature = STRBUF_INIT;
1322 int ret = 1;
1323
1324 sigc->result = 'N';
1325
1326 if (parse_signed_commit(commit, &payload, &signature, the_hash_algo) <= 0)
1327 goto out;
1328
1329 sigc->payload_type = SIGNATURE_PAYLOAD_COMMIT;
1330 sigc->payload = strbuf_detach(&payload, &sigc->payload_len);
1331 ret = check_signature(sigc, signature.buf, signature.len);
1332
1333 out:
1334 strbuf_release(&payload);
1335 strbuf_release(&signature);
1336
1337 return ret;
1338}
1339
1340void verify_merge_signature(struct commit *commit, int verbosity,
1341 int check_trust)
1342{
1343 char hex[GIT_MAX_HEXSZ + 1];
1344 struct signature_check signature_check;
1345 int ret;
1346 memset(&signature_check, 0, sizeof(signature_check));
1347
1348 ret = check_commit_signature(commit, &signature_check);
1349
1350 repo_find_unique_abbrev_r(the_repository, hex, &commit->object.oid,
1351 DEFAULT_ABBREV);
1352 switch (signature_check.result) {
1353 case 'G':
1354 if (ret || (check_trust && signature_check.trust_level < TRUST_MARGINAL))
1355 die(_("Commit %s has an untrusted GPG signature, "
1356 "allegedly by %s."), hex, signature_check.signer);
1357 break;
1358 case 'B':
1359 die(_("Commit %s has a bad GPG signature "
1360 "allegedly by %s."), hex, signature_check.signer);
1361 default: /* 'N' */
1362 die(_("Commit %s does not have a GPG signature."), hex);
1363 }
1364 if (verbosity >= 0 && signature_check.result == 'G')
1365 printf(_("Commit %s has a good GPG signature by %s\n"),
1366 hex, signature_check.signer);
1367
1368 signature_check_clear(&signature_check);
1369}
1370
1371void append_merge_tag_headers(const struct commit_list *parents,
1372 struct commit_extra_header ***tail)
1373{
1374 while (parents) {
1375 const struct commit *parent = parents->item;
1376 handle_signed_tag(parent, tail);
1377 parents = parents->next;
1378 }
1379}
1380
1381static int convert_commit_extra_headers(const struct commit_extra_header *orig,
1382 struct commit_extra_header **result)
1383{
1384 const struct git_hash_algo *compat = the_repository->compat_hash_algo;
1385 const struct git_hash_algo *algo = the_repository->hash_algo;
1386 struct commit_extra_header *extra = NULL, **tail = &extra;
1387 struct strbuf out = STRBUF_INIT;
1388 while (orig) {
1389 struct commit_extra_header *new;
1390 CALLOC_ARRAY(new, 1);
1391 if (!strcmp(orig->key, "mergetag")) {
1392 if (convert_object_file(the_repository, &out, algo, compat,
1393 orig->value, orig->len,
1394 OBJ_TAG, 1)) {
1395 free(new);
1396 free_commit_extra_headers(extra);
1397 return -1;
1398 }
1399 new->key = xstrdup("mergetag");
1400 new->value = strbuf_detach(&out, &new->len);
1401 } else {
1402 new->key = xstrdup(orig->key);
1403 new->len = orig->len;
1404 new->value = xmemdupz(orig->value, orig->len);
1405 }
1406 *tail = new;
1407 tail = &new->next;
1408 orig = orig->next;
1409 }
1410 *result = extra;
1411 return 0;
1412}
1413
1414static void add_extra_header(struct strbuf *buffer,
1415 const struct commit_extra_header *extra)
1416{
1417 strbuf_addstr(buffer, extra->key);
1418 if (extra->len)
1419 strbuf_add_lines(buffer, " ", extra->value, extra->len);
1420 else
1421 strbuf_addch(buffer, '\n');
1422}
1423
1424struct commit_extra_header *read_commit_extra_headers(struct commit *commit,
1425 const char **exclude)
1426{
1427 struct commit_extra_header *extra = NULL;
1428 unsigned long size;
1429 const char *buffer = repo_get_commit_buffer(the_repository, commit,
1430 &size);
1431 extra = read_commit_extra_header_lines(buffer, size, exclude);
1432 repo_unuse_commit_buffer(the_repository, commit, buffer);
1433 return extra;
1434}
1435
1436int for_each_mergetag(each_mergetag_fn fn, struct commit *commit, void *data)
1437{
1438 struct commit_extra_header *extra, *to_free;
1439 int res = 0;
1440
1441 to_free = read_commit_extra_headers(commit, NULL);
1442 for (extra = to_free; !res && extra; extra = extra->next) {
1443 if (strcmp(extra->key, "mergetag"))
1444 continue; /* not a merge tag */
1445 res = fn(commit, extra, data);
1446 }
1447 free_commit_extra_headers(to_free);
1448 return res;
1449}
1450
1451static inline int standard_header_field(const char *field, size_t len)
1452{
1453 return ((len == 4 && !memcmp(field, "tree", 4)) ||
1454 (len == 6 && !memcmp(field, "parent", 6)) ||
1455 (len == 6 && !memcmp(field, "author", 6)) ||
1456 (len == 9 && !memcmp(field, "committer", 9)) ||
1457 (len == 8 && !memcmp(field, "encoding", 8)));
1458}
1459
1460static int excluded_header_field(const char *field, size_t len, const char **exclude)
1461{
1462 if (!exclude)
1463 return 0;
1464
1465 while (*exclude) {
1466 size_t xlen = strlen(*exclude);
1467 if (len == xlen && !memcmp(field, *exclude, xlen))
1468 return 1;
1469 exclude++;
1470 }
1471 return 0;
1472}
1473
1474static struct commit_extra_header *read_commit_extra_header_lines(
1475 const char *buffer, size_t size,
1476 const char **exclude)
1477{
1478 struct commit_extra_header *extra = NULL, **tail = &extra, *it = NULL;
1479 const char *line, *next, *eof, *eob;
1480 struct strbuf buf = STRBUF_INIT;
1481
1482 for (line = buffer, eob = line + size;
1483 line < eob && *line != '\n';
1484 line = next) {
1485 next = memchr(line, '\n', eob - line);
1486 next = next ? next + 1 : eob;
1487 if (*line == ' ') {
1488 /* continuation */
1489 if (it)
1490 strbuf_add(&buf, line + 1, next - (line + 1));
1491 continue;
1492 }
1493 if (it)
1494 it->value = strbuf_detach(&buf, &it->len);
1495 strbuf_reset(&buf);
1496 it = NULL;
1497
1498 eof = memchr(line, ' ', next - line);
1499 if (!eof)
1500 eof = next;
1501 else if (standard_header_field(line, eof - line) ||
1502 excluded_header_field(line, eof - line, exclude))
1503 continue;
1504
1505 CALLOC_ARRAY(it, 1);
1506 it->key = xmemdupz(line, eof-line);
1507 *tail = it;
1508 tail = &it->next;
1509 if (eof + 1 < next)
1510 strbuf_add(&buf, eof + 1, next - (eof + 1));
1511 }
1512 if (it)
1513 it->value = strbuf_detach(&buf, &it->len);
1514 return extra;
1515}
1516
1517void free_commit_extra_headers(struct commit_extra_header *extra)
1518{
1519 while (extra) {
1520 struct commit_extra_header *next = extra->next;
1521 free(extra->key);
1522 free(extra->value);
1523 free(extra);
1524 extra = next;
1525 }
1526}
1527
1528int commit_tree(const char *msg, size_t msg_len, const struct object_id *tree,
1529 const struct commit_list *parents, struct object_id *ret,
1530 const char *author, const char *sign_commit)
1531{
1532 struct commit_extra_header *extra = NULL, **tail = &extra;
1533 int result;
1534
1535 append_merge_tag_headers(parents, &tail);
1536 result = commit_tree_extended(msg, msg_len, tree, parents, ret, author,
1537 NULL, sign_commit, extra);
1538 free_commit_extra_headers(extra);
1539 return result;
1540}
1541
1542static int find_invalid_utf8(const char *buf, int len)
1543{
1544 int offset = 0;
1545 static const unsigned int max_codepoint[] = {
1546 0x7f, 0x7ff, 0xffff, 0x10ffff
1547 };
1548
1549 while (len) {
1550 unsigned char c = *buf++;
1551 int bytes, bad_offset;
1552 unsigned int codepoint;
1553 unsigned int min_val, max_val;
1554
1555 len--;
1556 offset++;
1557
1558 /* Simple US-ASCII? No worries. */
1559 if (c < 0x80)
1560 continue;
1561
1562 bad_offset = offset-1;
1563
1564 /*
1565 * Count how many more high bits set: that's how
1566 * many more bytes this sequence should have.
1567 */
1568 bytes = 0;
1569 while (c & 0x40) {
1570 c <<= 1;
1571 bytes++;
1572 }
1573
1574 /*
1575 * Must be between 1 and 3 more bytes. Longer sequences result in
1576 * codepoints beyond U+10FFFF, which are guaranteed never to exist.
1577 */
1578 if (bytes < 1 || 3 < bytes)
1579 return bad_offset;
1580
1581 /* Do we *have* that many bytes? */
1582 if (len < bytes)
1583 return bad_offset;
1584
1585 /*
1586 * Place the encoded bits at the bottom of the value and compute the
1587 * valid range.
1588 */
1589 codepoint = (c & 0x7f) >> bytes;
1590 min_val = max_codepoint[bytes-1] + 1;
1591 max_val = max_codepoint[bytes];
1592
1593 offset += bytes;
1594 len -= bytes;
1595
1596 /* And verify that they are good continuation bytes */
1597 do {
1598 codepoint <<= 6;
1599 codepoint |= *buf & 0x3f;
1600 if ((*buf++ & 0xc0) != 0x80)
1601 return bad_offset;
1602 } while (--bytes);
1603
1604 /* Reject codepoints that are out of range for the sequence length. */
1605 if (codepoint < min_val || codepoint > max_val)
1606 return bad_offset;
1607 /* Surrogates are only for UTF-16 and cannot be encoded in UTF-8. */
1608 if ((codepoint & 0x1ff800) == 0xd800)
1609 return bad_offset;
1610 /* U+xxFFFE and U+xxFFFF are guaranteed non-characters. */
1611 if ((codepoint & 0xfffe) == 0xfffe)
1612 return bad_offset;
1613 /* So are anything in the range U+FDD0..U+FDEF. */
1614 if (codepoint >= 0xfdd0 && codepoint <= 0xfdef)
1615 return bad_offset;
1616 }
1617 return -1;
1618}
1619
1620/*
1621 * This verifies that the buffer is in proper utf8 format.
1622 *
1623 * If it isn't, it assumes any non-utf8 characters are Latin1,
1624 * and does the conversion.
1625 */
1626static int verify_utf8(struct strbuf *buf)
1627{
1628 int ok = 1;
1629 long pos = 0;
1630
1631 for (;;) {
1632 int bad;
1633 unsigned char c;
1634 unsigned char replace[2];
1635
1636 bad = find_invalid_utf8(buf->buf + pos, buf->len - pos);
1637 if (bad < 0)
1638 return ok;
1639 pos += bad;
1640 ok = 0;
1641 c = buf->buf[pos];
1642 strbuf_remove(buf, pos, 1);
1643
1644 /* We know 'c' must be in the range 128-255 */
1645 replace[0] = 0xc0 + (c >> 6);
1646 replace[1] = 0x80 + (c & 0x3f);
1647 strbuf_insert(buf, pos, replace, 2);
1648 pos += 2;
1649 }
1650}
1651
1652static const char commit_utf8_warn[] =
1653N_("Warning: commit message did not conform to UTF-8.\n"
1654 "You may want to amend it after fixing the message, or set the config\n"
1655 "variable i18n.commitEncoding to the encoding your project uses.\n");
1656
1657static void write_commit_tree(struct strbuf *buffer, const char *msg, size_t msg_len,
1658 const struct object_id *tree,
1659 const struct object_id *parents, size_t parents_len,
1660 const char *author, const char *committer,
1661 const struct commit_extra_header *extra)
1662{
1663 int encoding_is_utf8;
1664 size_t i;
1665
1666 /* Not having i18n.commitencoding is the same as having utf-8 */
1667 encoding_is_utf8 = is_encoding_utf8(git_commit_encoding);
1668
1669 strbuf_grow(buffer, 8192); /* should avoid reallocs for the headers */
1670 strbuf_addf(buffer, "tree %s\n", oid_to_hex(tree));
1671
1672 /*
1673 * NOTE! This ordering means that the same exact tree merged with a
1674 * different order of parents will be a _different_ changeset even
1675 * if everything else stays the same.
1676 */
1677 for (i = 0; i < parents_len; i++)
1678 strbuf_addf(buffer, "parent %s\n", oid_to_hex(&parents[i]));
1679
1680 /* Person/date information */
1681 if (!author)
1682 author = git_author_info(IDENT_STRICT);
1683 strbuf_addf(buffer, "author %s\n", author);
1684 if (!committer)
1685 committer = git_committer_info(IDENT_STRICT);
1686 strbuf_addf(buffer, "committer %s\n", committer);
1687 if (!encoding_is_utf8)
1688 strbuf_addf(buffer, "encoding %s\n", git_commit_encoding);
1689
1690 while (extra) {
1691 add_extra_header(buffer, extra);
1692 extra = extra->next;
1693 }
1694 strbuf_addch(buffer, '\n');
1695
1696 /* And add the comment */
1697 strbuf_add(buffer, msg, msg_len);
1698}
1699
1700int commit_tree_extended(const char *msg, size_t msg_len,
1701 const struct object_id *tree,
1702 const struct commit_list *parents, struct object_id *ret,
1703 const char *author, const char *committer,
1704 const char *sign_commit,
1705 const struct commit_extra_header *extra)
1706{
1707 struct repository *r = the_repository;
1708 int result = 0;
1709 int encoding_is_utf8;
1710 struct strbuf buffer = STRBUF_INIT, compat_buffer = STRBUF_INIT;
1711 struct strbuf sig = STRBUF_INIT, compat_sig = STRBUF_INIT;
1712 struct object_id *parent_buf = NULL, *compat_oid = NULL;
1713 struct object_id compat_oid_buf;
1714 size_t i, nparents;
1715
1716 /* Not having i18n.commitencoding is the same as having utf-8 */
1717 encoding_is_utf8 = is_encoding_utf8(git_commit_encoding);
1718
1719 odb_assert_oid_type(the_repository->objects, tree, OBJ_TREE);
1720
1721 if (memchr(msg, '\0', msg_len))
1722 return error("a NUL byte in commit log message not allowed.");
1723
1724 nparents = commit_list_count(parents);
1725 CALLOC_ARRAY(parent_buf, nparents);
1726 i = 0;
1727 for (const struct commit_list *p = parents; p; p = p->next)
1728 oidcpy(&parent_buf[i++], &p->item->object.oid);
1729
1730 write_commit_tree(&buffer, msg, msg_len, tree, parent_buf, nparents, author, committer, extra);
1731 if (sign_commit && sign_commit_to_strbuf(&sig, &buffer, sign_commit)) {
1732 result = -1;
1733 goto out;
1734 }
1735 if (r->compat_hash_algo) {
1736 struct commit_extra_header *compat_extra = NULL;
1737 struct object_id mapped_tree;
1738 struct object_id *mapped_parents;
1739
1740 CALLOC_ARRAY(mapped_parents, nparents);
1741
1742 if (repo_oid_to_algop(r, tree, r->compat_hash_algo, &mapped_tree)) {
1743 result = -1;
1744 free(mapped_parents);
1745 goto out;
1746 }
1747 for (i = 0; i < nparents; i++)
1748 if (repo_oid_to_algop(r, &parent_buf[i], r->compat_hash_algo, &mapped_parents[i])) {
1749 result = -1;
1750 free(mapped_parents);
1751 goto out;
1752 }
1753 if (convert_commit_extra_headers(extra, &compat_extra)) {
1754 result = -1;
1755 free(mapped_parents);
1756 goto out;
1757 }
1758 write_commit_tree(&compat_buffer, msg, msg_len, &mapped_tree,
1759 mapped_parents, nparents, author, committer, compat_extra);
1760 free_commit_extra_headers(compat_extra);
1761 free(mapped_parents);
1762
1763 if (sign_commit && sign_commit_to_strbuf(&compat_sig, &compat_buffer, sign_commit)) {
1764 result = -1;
1765 goto out;
1766 }
1767 }
1768
1769 if (sign_commit) {
1770 struct sig_pairs {
1771 struct strbuf *sig;
1772 const struct git_hash_algo *algo;
1773 } bufs [2] = {
1774 { &compat_sig, r->compat_hash_algo },
1775 { &sig, r->hash_algo },
1776 };
1777
1778 /*
1779 * We write algorithms in the order they were implemented in
1780 * Git to produce a stable hash when multiple algorithms are
1781 * used.
1782 */
1783 if (r->compat_hash_algo && hash_algo_by_ptr(bufs[0].algo) > hash_algo_by_ptr(bufs[1].algo))
1784 SWAP(bufs[0], bufs[1]);
1785
1786 /*
1787 * We traverse each algorithm in order, and apply the signature
1788 * to each buffer.
1789 */
1790 for (size_t i = 0; i < ARRAY_SIZE(bufs); i++) {
1791 if (!bufs[i].algo)
1792 continue;
1793 add_header_signature(&buffer, bufs[i].sig, bufs[i].algo);
1794 if (r->compat_hash_algo)
1795 add_header_signature(&compat_buffer, bufs[i].sig, bufs[i].algo);
1796 }
1797 }
1798
1799 /* And check the encoding. */
1800 if (encoding_is_utf8 && (!verify_utf8(&buffer) || !verify_utf8(&compat_buffer)))
1801 fprintf(stderr, _(commit_utf8_warn));
1802
1803 if (r->compat_hash_algo) {
1804 hash_object_file(r->compat_hash_algo, compat_buffer.buf, compat_buffer.len,
1805 OBJ_COMMIT, &compat_oid_buf);
1806 compat_oid = &compat_oid_buf;
1807 }
1808
1809 result = odb_write_object_ext(the_repository->objects, buffer.buf, buffer.len,
1810 OBJ_COMMIT, ret, compat_oid, 0);
1811out:
1812 free(parent_buf);
1813 strbuf_release(&buffer);
1814 strbuf_release(&compat_buffer);
1815 strbuf_release(&sig);
1816 strbuf_release(&compat_sig);
1817 return result;
1818}
1819
1820define_commit_slab(merge_desc_slab, struct merge_remote_desc *);
1821static struct merge_desc_slab merge_desc_slab = COMMIT_SLAB_INIT(1, merge_desc_slab);
1822
1823struct merge_remote_desc *merge_remote_util(const struct commit *commit)
1824{
1825 return *merge_desc_slab_at(&merge_desc_slab, commit);
1826}
1827
1828void set_merge_remote_desc(struct commit *commit,
1829 const char *name, struct object *obj)
1830{
1831 struct merge_remote_desc *desc;
1832 FLEX_ALLOC_STR(desc, name, name);
1833 desc->obj = obj;
1834 *merge_desc_slab_at(&merge_desc_slab, commit) = desc;
1835}
1836
1837struct commit *get_merge_parent(const char *name)
1838{
1839 struct object *obj;
1840 struct commit *commit;
1841 struct object_id oid;
1842 if (repo_get_oid(the_repository, name, &oid))
1843 return NULL;
1844 obj = parse_object(the_repository, &oid);
1845 commit = (struct commit *)repo_peel_to_type(the_repository, name, 0,
1846 obj, OBJ_COMMIT);
1847 if (commit && !merge_remote_util(commit))
1848 set_merge_remote_desc(commit, name, obj);
1849 return commit;
1850}
1851
1852/*
1853 * Append a commit to the end of the commit_list.
1854 *
1855 * next starts by pointing to the variable that holds the head of an
1856 * empty commit_list, and is updated to point to the "next" field of
1857 * the last item on the list as new commits are appended.
1858 *
1859 * Usage example:
1860 *
1861 * struct commit_list *list;
1862 * struct commit_list **next = &list;
1863 *
1864 * next = commit_list_append(c1, next);
1865 * next = commit_list_append(c2, next);
1866 * assert(commit_list_count(list) == 2);
1867 * return list;
1868 */
1869struct commit_list **commit_list_append(struct commit *commit,
1870 struct commit_list **next)
1871{
1872 struct commit_list *new_commit = xmalloc(sizeof(struct commit_list));
1873 new_commit->item = commit;
1874 *next = new_commit;
1875 new_commit->next = NULL;
1876 return &new_commit->next;
1877}
1878
1879const char *find_commit_header(const char *msg, const char *key, size_t *out_len)
1880{
1881 int key_len = strlen(key);
1882 const char *line = msg;
1883
1884 while (line) {
1885 const char *eol = strchrnul(line, '\n');
1886
1887 if (line == eol)
1888 return NULL;
1889
1890 if (eol - line > key_len &&
1891 !strncmp(line, key, key_len) &&
1892 line[key_len] == ' ') {
1893 *out_len = eol - line - key_len - 1;
1894 return line + key_len + 1;
1895 }
1896 line = *eol ? eol + 1 : NULL;
1897 }
1898 return NULL;
1899}
1900
1901/*
1902 * Inspect the given string and determine the true "end" of the log message, in
1903 * order to find where to put a new Signed-off-by trailer. Ignored are
1904 * trailing comment lines and blank lines. To support "git commit -s
1905 * --amend" on an existing commit, we also ignore "Conflicts:". To
1906 * support "git commit -v", we truncate at cut lines.
1907 *
1908 * Returns the number of bytes from the tail to ignore, to be fed as
1909 * the second parameter to append_signoff().
1910 */
1911size_t ignored_log_message_bytes(const char *buf, size_t len)
1912{
1913 size_t boc = 0;
1914 size_t bol = 0;
1915 int in_old_conflicts_block = 0;
1916 size_t cutoff = wt_status_locate_end(buf, len);
1917
1918 while (bol < cutoff) {
1919 const char *next_line = memchr(buf + bol, '\n', len - bol);
1920
1921 if (!next_line)
1922 next_line = buf + len;
1923 else
1924 next_line++;
1925
1926 if (starts_with_mem(buf + bol, cutoff - bol, comment_line_str) ||
1927 buf[bol] == '\n') {
1928 /* is this the first of the run of comments? */
1929 if (!boc)
1930 boc = bol;
1931 /* otherwise, it is just continuing */
1932 } else if (starts_with(buf + bol, "Conflicts:\n")) {
1933 in_old_conflicts_block = 1;
1934 if (!boc)
1935 boc = bol;
1936 } else if (in_old_conflicts_block && buf[bol] == '\t') {
1937 ; /* a pathname in the conflicts block */
1938 } else if (boc) {
1939 /* the previous was not trailing comment */
1940 boc = 0;
1941 in_old_conflicts_block = 0;
1942 }
1943 bol = next_line - buf;
1944 }
1945 return boc ? len - boc : len - cutoff;
1946}
1947
1948int run_commit_hook(int editor_is_used, const char *index_file,
1949 int *invoked_hook, const char *name, ...)
1950{
1951 struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT;
1952 va_list args;
1953 const char *arg;
1954
1955 strvec_pushf(&opt.env, "GIT_INDEX_FILE=%s", index_file);
1956
1957 /*
1958 * Let the hook know that no editor will be launched.
1959 */
1960 if (!editor_is_used)
1961 strvec_push(&opt.env, "GIT_EDITOR=:");
1962
1963 va_start(args, name);
1964 while ((arg = va_arg(args, const char *)))
1965 strvec_push(&opt.args, arg);
1966 va_end(args);
1967
1968 opt.invoked_hook = invoked_hook;
1969 return run_hooks_opt(the_repository, name, &opt);
1970}