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(struct object_id *ooid, struct object_id *noid,
1043 const char *ident UNUSED,
1044 timestamp_t timestamp UNUSED, int tz UNUSED,
1045 const char *message UNUSED, void *cbdata)
1046{
1047 struct rev_collect *revs = cbdata;
1048
1049 if (revs->initial) {
1050 revs->initial = 0;
1051 add_one_commit(ooid, revs);
1052 }
1053 add_one_commit(noid, revs);
1054 return 0;
1055}
1056
1057struct commit *get_fork_point(const char *refname, struct commit *commit)
1058{
1059 struct object_id oid;
1060 struct rev_collect revs;
1061 struct commit_list *bases = NULL;
1062 int i;
1063 struct commit *ret = NULL;
1064 char *full_refname;
1065
1066 switch (repo_dwim_ref(the_repository, refname, strlen(refname), &oid,
1067 &full_refname, 0)) {
1068 case 0:
1069 die("No such ref: '%s'", refname);
1070 case 1:
1071 break; /* good */
1072 default:
1073 die("Ambiguous refname: '%s'", refname);
1074 }
1075
1076 memset(&revs, 0, sizeof(revs));
1077 revs.initial = 1;
1078 refs_for_each_reflog_ent(get_main_ref_store(the_repository),
1079 full_refname, collect_one_reflog_ent, &revs);
1080
1081 if (!revs.nr)
1082 add_one_commit(&oid, &revs);
1083
1084 for (i = 0; i < revs.nr; i++)
1085 revs.commit[i]->object.flags &= ~TMP_MARK;
1086
1087 if (repo_get_merge_bases_many(the_repository, commit, revs.nr,
1088 revs.commit, &bases) < 0)
1089 exit(128);
1090
1091 /*
1092 * There should be one and only one merge base, when we found
1093 * a common ancestor among reflog entries.
1094 */
1095 if (!bases || bases->next)
1096 goto cleanup_return;
1097
1098 /* And the found one must be one of the reflog entries */
1099 for (i = 0; i < revs.nr; i++)
1100 if (&bases->item->object == &revs.commit[i]->object)
1101 break; /* found */
1102 if (revs.nr <= i)
1103 goto cleanup_return;
1104
1105 ret = bases->item;
1106
1107cleanup_return:
1108 free(revs.commit);
1109 free_commit_list(bases);
1110 free(full_refname);
1111 return ret;
1112}
1113
1114/*
1115 * Indexed by hash algorithm identifier.
1116 */
1117static const char *gpg_sig_headers[] = {
1118 NULL,
1119 "gpgsig",
1120 "gpgsig-sha256",
1121};
1122
1123int add_header_signature(struct strbuf *buf, struct strbuf *sig, const struct git_hash_algo *algo)
1124{
1125 int inspos, copypos;
1126 const char *eoh;
1127 const char *gpg_sig_header = gpg_sig_headers[hash_algo_by_ptr(algo)];
1128 int gpg_sig_header_len = strlen(gpg_sig_header);
1129
1130 /* find the end of the header */
1131 eoh = strstr(buf->buf, "\n\n");
1132 if (!eoh)
1133 inspos = buf->len;
1134 else
1135 inspos = eoh - buf->buf + 1;
1136
1137 for (copypos = 0; sig->buf[copypos]; ) {
1138 const char *bol = sig->buf + copypos;
1139 const char *eol = strchrnul(bol, '\n');
1140 int len = (eol - bol) + !!*eol;
1141
1142 if (!copypos) {
1143 strbuf_insert(buf, inspos, gpg_sig_header, gpg_sig_header_len);
1144 inspos += gpg_sig_header_len;
1145 }
1146 strbuf_insertstr(buf, inspos++, " ");
1147 strbuf_insert(buf, inspos, bol, len);
1148 inspos += len;
1149 copypos += len;
1150 }
1151 return 0;
1152}
1153
1154static int sign_commit_to_strbuf(struct strbuf *sig, struct strbuf *buf, const char *keyid)
1155{
1156 char *keyid_to_free = NULL;
1157 int ret = 0;
1158 if (!keyid || !*keyid)
1159 keyid = keyid_to_free = get_signing_key();
1160 if (sign_buffer(buf, sig, keyid))
1161 ret = -1;
1162 free(keyid_to_free);
1163 return ret;
1164}
1165
1166int parse_signed_commit(const struct commit *commit,
1167 struct strbuf *payload, struct strbuf *signature,
1168 const struct git_hash_algo *algop)
1169{
1170 unsigned long size;
1171 const char *buffer = repo_get_commit_buffer(the_repository, commit,
1172 &size);
1173 int ret = parse_buffer_signed_by_header(buffer, size, payload, signature, algop);
1174
1175 repo_unuse_commit_buffer(the_repository, commit, buffer);
1176 return ret;
1177}
1178
1179int parse_buffer_signed_by_header(const char *buffer,
1180 unsigned long size,
1181 struct strbuf *payload,
1182 struct strbuf *signature,
1183 const struct git_hash_algo *algop)
1184{
1185 int in_signature = 0, saw_signature = 0, other_signature = 0;
1186 const char *line, *tail, *p;
1187 const char *gpg_sig_header = gpg_sig_headers[hash_algo_by_ptr(algop)];
1188
1189 line = buffer;
1190 tail = buffer + size;
1191 while (line < tail) {
1192 const char *sig = NULL;
1193 const char *next = memchr(line, '\n', tail - line);
1194
1195 next = next ? next + 1 : tail;
1196 if (in_signature && line[0] == ' ')
1197 sig = line + 1;
1198 else if (skip_prefix(line, gpg_sig_header, &p) &&
1199 *p == ' ') {
1200 sig = line + strlen(gpg_sig_header) + 1;
1201 other_signature = 0;
1202 }
1203 else if (starts_with(line, "gpgsig"))
1204 other_signature = 1;
1205 else if (other_signature && line[0] != ' ')
1206 other_signature = 0;
1207 if (sig) {
1208 strbuf_add(signature, sig, next - sig);
1209 saw_signature = 1;
1210 in_signature = 1;
1211 } else {
1212 if (*line == '\n')
1213 /* dump the whole remainder of the buffer */
1214 next = tail;
1215 if (!other_signature)
1216 strbuf_add(payload, line, next - line);
1217 in_signature = 0;
1218 }
1219 line = next;
1220 }
1221 return saw_signature;
1222}
1223
1224int remove_signature(struct strbuf *buf)
1225{
1226 const char *line = buf->buf;
1227 const char *tail = buf->buf + buf->len;
1228 int in_signature = 0;
1229 struct sigbuf {
1230 const char *start;
1231 const char *end;
1232 } sigs[2], *sigp = &sigs[0];
1233 int i;
1234 const char *orig_buf = buf->buf;
1235
1236 memset(sigs, 0, sizeof(sigs));
1237
1238 while (line < tail) {
1239 const char *next = memchr(line, '\n', tail - line);
1240 next = next ? next + 1 : tail;
1241
1242 if (in_signature && line[0] == ' ')
1243 sigp->end = next;
1244 else if (starts_with(line, "gpgsig")) {
1245 int i;
1246 for (i = 1; i < GIT_HASH_NALGOS; i++) {
1247 const char *p;
1248 if (skip_prefix(line, gpg_sig_headers[i], &p) &&
1249 *p == ' ') {
1250 sigp->start = line;
1251 sigp->end = next;
1252 in_signature = 1;
1253 }
1254 }
1255 } else {
1256 if (*line == '\n')
1257 /* dump the whole remainder of the buffer */
1258 next = tail;
1259 if (in_signature && sigp - sigs != ARRAY_SIZE(sigs))
1260 sigp++;
1261 in_signature = 0;
1262 }
1263 line = next;
1264 }
1265
1266 for (i = ARRAY_SIZE(sigs) - 1; i >= 0; i--)
1267 if (sigs[i].start)
1268 strbuf_remove(buf, sigs[i].start - orig_buf, sigs[i].end - sigs[i].start);
1269
1270 return sigs[0].start != NULL;
1271}
1272
1273static void handle_signed_tag(const struct commit *parent, struct commit_extra_header ***tail)
1274{
1275 struct merge_remote_desc *desc;
1276 struct commit_extra_header *mergetag;
1277 char *buf;
1278 unsigned long size;
1279 enum object_type type;
1280 struct strbuf payload = STRBUF_INIT;
1281 struct strbuf signature = STRBUF_INIT;
1282
1283 desc = merge_remote_util(parent);
1284 if (!desc || !desc->obj)
1285 return;
1286 buf = odb_read_object(the_repository->objects, &desc->obj->oid,
1287 &type, &size);
1288 if (!buf || type != OBJ_TAG)
1289 goto free_return;
1290 if (!parse_signature(buf, size, &payload, &signature))
1291 goto free_return;
1292 /*
1293 * We could verify this signature and either omit the tag when
1294 * it does not validate, but the integrator may not have the
1295 * public key of the signer of the tag being merged, while a
1296 * later auditor may have it while auditing, so let's not run
1297 * verify-signed-buffer here for now...
1298 *
1299 * if (verify_signed_buffer(buf, len, buf + len, size - len, ...))
1300 * warn("warning: signed tag unverified.");
1301 */
1302 CALLOC_ARRAY(mergetag, 1);
1303 mergetag->key = xstrdup("mergetag");
1304 mergetag->value = buf;
1305 mergetag->len = size;
1306
1307 **tail = mergetag;
1308 *tail = &mergetag->next;
1309 strbuf_release(&payload);
1310 strbuf_release(&signature);
1311 return;
1312
1313free_return:
1314 free(buf);
1315}
1316
1317int check_commit_signature(const struct commit *commit, struct signature_check *sigc)
1318{
1319 struct strbuf payload = STRBUF_INIT;
1320 struct strbuf signature = STRBUF_INIT;
1321 int ret = 1;
1322
1323 sigc->result = 'N';
1324
1325 if (parse_signed_commit(commit, &payload, &signature, the_hash_algo) <= 0)
1326 goto out;
1327
1328 sigc->payload_type = SIGNATURE_PAYLOAD_COMMIT;
1329 sigc->payload = strbuf_detach(&payload, &sigc->payload_len);
1330 ret = check_signature(sigc, signature.buf, signature.len);
1331
1332 out:
1333 strbuf_release(&payload);
1334 strbuf_release(&signature);
1335
1336 return ret;
1337}
1338
1339void verify_merge_signature(struct commit *commit, int verbosity,
1340 int check_trust)
1341{
1342 char hex[GIT_MAX_HEXSZ + 1];
1343 struct signature_check signature_check;
1344 int ret;
1345 memset(&signature_check, 0, sizeof(signature_check));
1346
1347 ret = check_commit_signature(commit, &signature_check);
1348
1349 repo_find_unique_abbrev_r(the_repository, hex, &commit->object.oid,
1350 DEFAULT_ABBREV);
1351 switch (signature_check.result) {
1352 case 'G':
1353 if (ret || (check_trust && signature_check.trust_level < TRUST_MARGINAL))
1354 die(_("Commit %s has an untrusted GPG signature, "
1355 "allegedly by %s."), hex, signature_check.signer);
1356 break;
1357 case 'B':
1358 die(_("Commit %s has a bad GPG signature "
1359 "allegedly by %s."), hex, signature_check.signer);
1360 default: /* 'N' */
1361 die(_("Commit %s does not have a GPG signature."), hex);
1362 }
1363 if (verbosity >= 0 && signature_check.result == 'G')
1364 printf(_("Commit %s has a good GPG signature by %s\n"),
1365 hex, signature_check.signer);
1366
1367 signature_check_clear(&signature_check);
1368}
1369
1370void append_merge_tag_headers(const struct commit_list *parents,
1371 struct commit_extra_header ***tail)
1372{
1373 while (parents) {
1374 const struct commit *parent = parents->item;
1375 handle_signed_tag(parent, tail);
1376 parents = parents->next;
1377 }
1378}
1379
1380static int convert_commit_extra_headers(const struct commit_extra_header *orig,
1381 struct commit_extra_header **result)
1382{
1383 const struct git_hash_algo *compat = the_repository->compat_hash_algo;
1384 const struct git_hash_algo *algo = the_repository->hash_algo;
1385 struct commit_extra_header *extra = NULL, **tail = &extra;
1386 struct strbuf out = STRBUF_INIT;
1387 while (orig) {
1388 struct commit_extra_header *new;
1389 CALLOC_ARRAY(new, 1);
1390 if (!strcmp(orig->key, "mergetag")) {
1391 if (convert_object_file(the_repository, &out, algo, compat,
1392 orig->value, orig->len,
1393 OBJ_TAG, 1)) {
1394 free(new);
1395 free_commit_extra_headers(extra);
1396 return -1;
1397 }
1398 new->key = xstrdup("mergetag");
1399 new->value = strbuf_detach(&out, &new->len);
1400 } else {
1401 new->key = xstrdup(orig->key);
1402 new->len = orig->len;
1403 new->value = xmemdupz(orig->value, orig->len);
1404 }
1405 *tail = new;
1406 tail = &new->next;
1407 orig = orig->next;
1408 }
1409 *result = extra;
1410 return 0;
1411}
1412
1413static void add_extra_header(struct strbuf *buffer,
1414 const struct commit_extra_header *extra)
1415{
1416 strbuf_addstr(buffer, extra->key);
1417 if (extra->len)
1418 strbuf_add_lines(buffer, " ", extra->value, extra->len);
1419 else
1420 strbuf_addch(buffer, '\n');
1421}
1422
1423struct commit_extra_header *read_commit_extra_headers(struct commit *commit,
1424 const char **exclude)
1425{
1426 struct commit_extra_header *extra = NULL;
1427 unsigned long size;
1428 const char *buffer = repo_get_commit_buffer(the_repository, commit,
1429 &size);
1430 extra = read_commit_extra_header_lines(buffer, size, exclude);
1431 repo_unuse_commit_buffer(the_repository, commit, buffer);
1432 return extra;
1433}
1434
1435int for_each_mergetag(each_mergetag_fn fn, struct commit *commit, void *data)
1436{
1437 struct commit_extra_header *extra, *to_free;
1438 int res = 0;
1439
1440 to_free = read_commit_extra_headers(commit, NULL);
1441 for (extra = to_free; !res && extra; extra = extra->next) {
1442 if (strcmp(extra->key, "mergetag"))
1443 continue; /* not a merge tag */
1444 res = fn(commit, extra, data);
1445 }
1446 free_commit_extra_headers(to_free);
1447 return res;
1448}
1449
1450static inline int standard_header_field(const char *field, size_t len)
1451{
1452 return ((len == 4 && !memcmp(field, "tree", 4)) ||
1453 (len == 6 && !memcmp(field, "parent", 6)) ||
1454 (len == 6 && !memcmp(field, "author", 6)) ||
1455 (len == 9 && !memcmp(field, "committer", 9)) ||
1456 (len == 8 && !memcmp(field, "encoding", 8)));
1457}
1458
1459static int excluded_header_field(const char *field, size_t len, const char **exclude)
1460{
1461 if (!exclude)
1462 return 0;
1463
1464 while (*exclude) {
1465 size_t xlen = strlen(*exclude);
1466 if (len == xlen && !memcmp(field, *exclude, xlen))
1467 return 1;
1468 exclude++;
1469 }
1470 return 0;
1471}
1472
1473static struct commit_extra_header *read_commit_extra_header_lines(
1474 const char *buffer, size_t size,
1475 const char **exclude)
1476{
1477 struct commit_extra_header *extra = NULL, **tail = &extra, *it = NULL;
1478 const char *line, *next, *eof, *eob;
1479 struct strbuf buf = STRBUF_INIT;
1480
1481 for (line = buffer, eob = line + size;
1482 line < eob && *line != '\n';
1483 line = next) {
1484 next = memchr(line, '\n', eob - line);
1485 next = next ? next + 1 : eob;
1486 if (*line == ' ') {
1487 /* continuation */
1488 if (it)
1489 strbuf_add(&buf, line + 1, next - (line + 1));
1490 continue;
1491 }
1492 if (it)
1493 it->value = strbuf_detach(&buf, &it->len);
1494 strbuf_reset(&buf);
1495 it = NULL;
1496
1497 eof = memchr(line, ' ', next - line);
1498 if (!eof)
1499 eof = next;
1500 else if (standard_header_field(line, eof - line) ||
1501 excluded_header_field(line, eof - line, exclude))
1502 continue;
1503
1504 CALLOC_ARRAY(it, 1);
1505 it->key = xmemdupz(line, eof-line);
1506 *tail = it;
1507 tail = &it->next;
1508 if (eof + 1 < next)
1509 strbuf_add(&buf, eof + 1, next - (eof + 1));
1510 }
1511 if (it)
1512 it->value = strbuf_detach(&buf, &it->len);
1513 return extra;
1514}
1515
1516void free_commit_extra_headers(struct commit_extra_header *extra)
1517{
1518 while (extra) {
1519 struct commit_extra_header *next = extra->next;
1520 free(extra->key);
1521 free(extra->value);
1522 free(extra);
1523 extra = next;
1524 }
1525}
1526
1527int commit_tree(const char *msg, size_t msg_len, const struct object_id *tree,
1528 const struct commit_list *parents, struct object_id *ret,
1529 const char *author, const char *sign_commit)
1530{
1531 struct commit_extra_header *extra = NULL, **tail = &extra;
1532 int result;
1533
1534 append_merge_tag_headers(parents, &tail);
1535 result = commit_tree_extended(msg, msg_len, tree, parents, ret, author,
1536 NULL, sign_commit, extra);
1537 free_commit_extra_headers(extra);
1538 return result;
1539}
1540
1541static int find_invalid_utf8(const char *buf, int len)
1542{
1543 int offset = 0;
1544 static const unsigned int max_codepoint[] = {
1545 0x7f, 0x7ff, 0xffff, 0x10ffff
1546 };
1547
1548 while (len) {
1549 unsigned char c = *buf++;
1550 int bytes, bad_offset;
1551 unsigned int codepoint;
1552 unsigned int min_val, max_val;
1553
1554 len--;
1555 offset++;
1556
1557 /* Simple US-ASCII? No worries. */
1558 if (c < 0x80)
1559 continue;
1560
1561 bad_offset = offset-1;
1562
1563 /*
1564 * Count how many more high bits set: that's how
1565 * many more bytes this sequence should have.
1566 */
1567 bytes = 0;
1568 while (c & 0x40) {
1569 c <<= 1;
1570 bytes++;
1571 }
1572
1573 /*
1574 * Must be between 1 and 3 more bytes. Longer sequences result in
1575 * codepoints beyond U+10FFFF, which are guaranteed never to exist.
1576 */
1577 if (bytes < 1 || 3 < bytes)
1578 return bad_offset;
1579
1580 /* Do we *have* that many bytes? */
1581 if (len < bytes)
1582 return bad_offset;
1583
1584 /*
1585 * Place the encoded bits at the bottom of the value and compute the
1586 * valid range.
1587 */
1588 codepoint = (c & 0x7f) >> bytes;
1589 min_val = max_codepoint[bytes-1] + 1;
1590 max_val = max_codepoint[bytes];
1591
1592 offset += bytes;
1593 len -= bytes;
1594
1595 /* And verify that they are good continuation bytes */
1596 do {
1597 codepoint <<= 6;
1598 codepoint |= *buf & 0x3f;
1599 if ((*buf++ & 0xc0) != 0x80)
1600 return bad_offset;
1601 } while (--bytes);
1602
1603 /* Reject codepoints that are out of range for the sequence length. */
1604 if (codepoint < min_val || codepoint > max_val)
1605 return bad_offset;
1606 /* Surrogates are only for UTF-16 and cannot be encoded in UTF-8. */
1607 if ((codepoint & 0x1ff800) == 0xd800)
1608 return bad_offset;
1609 /* U+xxFFFE and U+xxFFFF are guaranteed non-characters. */
1610 if ((codepoint & 0xfffe) == 0xfffe)
1611 return bad_offset;
1612 /* So are anything in the range U+FDD0..U+FDEF. */
1613 if (codepoint >= 0xfdd0 && codepoint <= 0xfdef)
1614 return bad_offset;
1615 }
1616 return -1;
1617}
1618
1619/*
1620 * This verifies that the buffer is in proper utf8 format.
1621 *
1622 * If it isn't, it assumes any non-utf8 characters are Latin1,
1623 * and does the conversion.
1624 */
1625static int verify_utf8(struct strbuf *buf)
1626{
1627 int ok = 1;
1628 long pos = 0;
1629
1630 for (;;) {
1631 int bad;
1632 unsigned char c;
1633 unsigned char replace[2];
1634
1635 bad = find_invalid_utf8(buf->buf + pos, buf->len - pos);
1636 if (bad < 0)
1637 return ok;
1638 pos += bad;
1639 ok = 0;
1640 c = buf->buf[pos];
1641 strbuf_remove(buf, pos, 1);
1642
1643 /* We know 'c' must be in the range 128-255 */
1644 replace[0] = 0xc0 + (c >> 6);
1645 replace[1] = 0x80 + (c & 0x3f);
1646 strbuf_insert(buf, pos, replace, 2);
1647 pos += 2;
1648 }
1649}
1650
1651static const char commit_utf8_warn[] =
1652N_("Warning: commit message did not conform to UTF-8.\n"
1653 "You may want to amend it after fixing the message, or set the config\n"
1654 "variable i18n.commitEncoding to the encoding your project uses.\n");
1655
1656static void write_commit_tree(struct strbuf *buffer, const char *msg, size_t msg_len,
1657 const struct object_id *tree,
1658 const struct object_id *parents, size_t parents_len,
1659 const char *author, const char *committer,
1660 const struct commit_extra_header *extra)
1661{
1662 int encoding_is_utf8;
1663 size_t i;
1664
1665 /* Not having i18n.commitencoding is the same as having utf-8 */
1666 encoding_is_utf8 = is_encoding_utf8(git_commit_encoding);
1667
1668 strbuf_grow(buffer, 8192); /* should avoid reallocs for the headers */
1669 strbuf_addf(buffer, "tree %s\n", oid_to_hex(tree));
1670
1671 /*
1672 * NOTE! This ordering means that the same exact tree merged with a
1673 * different order of parents will be a _different_ changeset even
1674 * if everything else stays the same.
1675 */
1676 for (i = 0; i < parents_len; i++)
1677 strbuf_addf(buffer, "parent %s\n", oid_to_hex(&parents[i]));
1678
1679 /* Person/date information */
1680 if (!author)
1681 author = git_author_info(IDENT_STRICT);
1682 strbuf_addf(buffer, "author %s\n", author);
1683 if (!committer)
1684 committer = git_committer_info(IDENT_STRICT);
1685 strbuf_addf(buffer, "committer %s\n", committer);
1686 if (!encoding_is_utf8)
1687 strbuf_addf(buffer, "encoding %s\n", git_commit_encoding);
1688
1689 while (extra) {
1690 add_extra_header(buffer, extra);
1691 extra = extra->next;
1692 }
1693 strbuf_addch(buffer, '\n');
1694
1695 /* And add the comment */
1696 strbuf_add(buffer, msg, msg_len);
1697}
1698
1699int commit_tree_extended(const char *msg, size_t msg_len,
1700 const struct object_id *tree,
1701 const struct commit_list *parents, struct object_id *ret,
1702 const char *author, const char *committer,
1703 const char *sign_commit,
1704 const struct commit_extra_header *extra)
1705{
1706 struct repository *r = the_repository;
1707 int result = 0;
1708 int encoding_is_utf8;
1709 struct strbuf buffer = STRBUF_INIT, compat_buffer = STRBUF_INIT;
1710 struct strbuf sig = STRBUF_INIT, compat_sig = STRBUF_INIT;
1711 struct object_id *parent_buf = NULL, *compat_oid = NULL;
1712 struct object_id compat_oid_buf;
1713 size_t i, nparents;
1714
1715 /* Not having i18n.commitencoding is the same as having utf-8 */
1716 encoding_is_utf8 = is_encoding_utf8(git_commit_encoding);
1717
1718 odb_assert_oid_type(the_repository->objects, tree, OBJ_TREE);
1719
1720 if (memchr(msg, '\0', msg_len))
1721 return error("a NUL byte in commit log message not allowed.");
1722
1723 nparents = commit_list_count(parents);
1724 CALLOC_ARRAY(parent_buf, nparents);
1725 i = 0;
1726 for (const struct commit_list *p = parents; p; p = p->next)
1727 oidcpy(&parent_buf[i++], &p->item->object.oid);
1728
1729 write_commit_tree(&buffer, msg, msg_len, tree, parent_buf, nparents, author, committer, extra);
1730 if (sign_commit && sign_commit_to_strbuf(&sig, &buffer, sign_commit)) {
1731 result = -1;
1732 goto out;
1733 }
1734 if (r->compat_hash_algo) {
1735 struct commit_extra_header *compat_extra = NULL;
1736 struct object_id mapped_tree;
1737 struct object_id *mapped_parents;
1738
1739 CALLOC_ARRAY(mapped_parents, nparents);
1740
1741 if (repo_oid_to_algop(r, tree, r->compat_hash_algo, &mapped_tree)) {
1742 result = -1;
1743 free(mapped_parents);
1744 goto out;
1745 }
1746 for (i = 0; i < nparents; i++)
1747 if (repo_oid_to_algop(r, &parent_buf[i], r->compat_hash_algo, &mapped_parents[i])) {
1748 result = -1;
1749 free(mapped_parents);
1750 goto out;
1751 }
1752 if (convert_commit_extra_headers(extra, &compat_extra)) {
1753 result = -1;
1754 free(mapped_parents);
1755 goto out;
1756 }
1757 write_commit_tree(&compat_buffer, msg, msg_len, &mapped_tree,
1758 mapped_parents, nparents, author, committer, compat_extra);
1759 free_commit_extra_headers(compat_extra);
1760 free(mapped_parents);
1761
1762 if (sign_commit && sign_commit_to_strbuf(&compat_sig, &compat_buffer, sign_commit)) {
1763 result = -1;
1764 goto out;
1765 }
1766 }
1767
1768 if (sign_commit) {
1769 struct sig_pairs {
1770 struct strbuf *sig;
1771 const struct git_hash_algo *algo;
1772 } bufs [2] = {
1773 { &compat_sig, r->compat_hash_algo },
1774 { &sig, r->hash_algo },
1775 };
1776
1777 /*
1778 * We write algorithms in the order they were implemented in
1779 * Git to produce a stable hash when multiple algorithms are
1780 * used.
1781 */
1782 if (r->compat_hash_algo && hash_algo_by_ptr(bufs[0].algo) > hash_algo_by_ptr(bufs[1].algo))
1783 SWAP(bufs[0], bufs[1]);
1784
1785 /*
1786 * We traverse each algorithm in order, and apply the signature
1787 * to each buffer.
1788 */
1789 for (size_t i = 0; i < ARRAY_SIZE(bufs); i++) {
1790 if (!bufs[i].algo)
1791 continue;
1792 add_header_signature(&buffer, bufs[i].sig, bufs[i].algo);
1793 if (r->compat_hash_algo)
1794 add_header_signature(&compat_buffer, bufs[i].sig, bufs[i].algo);
1795 }
1796 }
1797
1798 /* And check the encoding. */
1799 if (encoding_is_utf8 && (!verify_utf8(&buffer) || !verify_utf8(&compat_buffer)))
1800 fprintf(stderr, _(commit_utf8_warn));
1801
1802 if (r->compat_hash_algo) {
1803 hash_object_file(r->compat_hash_algo, compat_buffer.buf, compat_buffer.len,
1804 OBJ_COMMIT, &compat_oid_buf);
1805 compat_oid = &compat_oid_buf;
1806 }
1807
1808 result = odb_write_object_ext(the_repository->objects, buffer.buf, buffer.len,
1809 OBJ_COMMIT, ret, compat_oid, 0);
1810out:
1811 free(parent_buf);
1812 strbuf_release(&buffer);
1813 strbuf_release(&compat_buffer);
1814 strbuf_release(&sig);
1815 strbuf_release(&compat_sig);
1816 return result;
1817}
1818
1819define_commit_slab(merge_desc_slab, struct merge_remote_desc *);
1820static struct merge_desc_slab merge_desc_slab = COMMIT_SLAB_INIT(1, merge_desc_slab);
1821
1822struct merge_remote_desc *merge_remote_util(const struct commit *commit)
1823{
1824 return *merge_desc_slab_at(&merge_desc_slab, commit);
1825}
1826
1827void set_merge_remote_desc(struct commit *commit,
1828 const char *name, struct object *obj)
1829{
1830 struct merge_remote_desc *desc;
1831 FLEX_ALLOC_STR(desc, name, name);
1832 desc->obj = obj;
1833 *merge_desc_slab_at(&merge_desc_slab, commit) = desc;
1834}
1835
1836struct commit *get_merge_parent(const char *name)
1837{
1838 struct object *obj;
1839 struct commit *commit;
1840 struct object_id oid;
1841 if (repo_get_oid(the_repository, name, &oid))
1842 return NULL;
1843 obj = parse_object(the_repository, &oid);
1844 commit = (struct commit *)repo_peel_to_type(the_repository, name, 0,
1845 obj, OBJ_COMMIT);
1846 if (commit && !merge_remote_util(commit))
1847 set_merge_remote_desc(commit, name, obj);
1848 return commit;
1849}
1850
1851/*
1852 * Append a commit to the end of the commit_list.
1853 *
1854 * next starts by pointing to the variable that holds the head of an
1855 * empty commit_list, and is updated to point to the "next" field of
1856 * the last item on the list as new commits are appended.
1857 *
1858 * Usage example:
1859 *
1860 * struct commit_list *list;
1861 * struct commit_list **next = &list;
1862 *
1863 * next = commit_list_append(c1, next);
1864 * next = commit_list_append(c2, next);
1865 * assert(commit_list_count(list) == 2);
1866 * return list;
1867 */
1868struct commit_list **commit_list_append(struct commit *commit,
1869 struct commit_list **next)
1870{
1871 struct commit_list *new_commit = xmalloc(sizeof(struct commit_list));
1872 new_commit->item = commit;
1873 *next = new_commit;
1874 new_commit->next = NULL;
1875 return &new_commit->next;
1876}
1877
1878const char *find_commit_header(const char *msg, const char *key, size_t *out_len)
1879{
1880 int key_len = strlen(key);
1881 const char *line = msg;
1882
1883 while (line) {
1884 const char *eol = strchrnul(line, '\n');
1885
1886 if (line == eol)
1887 return NULL;
1888
1889 if (eol - line > key_len &&
1890 !strncmp(line, key, key_len) &&
1891 line[key_len] == ' ') {
1892 *out_len = eol - line - key_len - 1;
1893 return line + key_len + 1;
1894 }
1895 line = *eol ? eol + 1 : NULL;
1896 }
1897 return NULL;
1898}
1899
1900/*
1901 * Inspect the given string and determine the true "end" of the log message, in
1902 * order to find where to put a new Signed-off-by trailer. Ignored are
1903 * trailing comment lines and blank lines. To support "git commit -s
1904 * --amend" on an existing commit, we also ignore "Conflicts:". To
1905 * support "git commit -v", we truncate at cut lines.
1906 *
1907 * Returns the number of bytes from the tail to ignore, to be fed as
1908 * the second parameter to append_signoff().
1909 */
1910size_t ignored_log_message_bytes(const char *buf, size_t len)
1911{
1912 size_t boc = 0;
1913 size_t bol = 0;
1914 int in_old_conflicts_block = 0;
1915 size_t cutoff = wt_status_locate_end(buf, len);
1916
1917 while (bol < cutoff) {
1918 const char *next_line = memchr(buf + bol, '\n', len - bol);
1919
1920 if (!next_line)
1921 next_line = buf + len;
1922 else
1923 next_line++;
1924
1925 if (starts_with_mem(buf + bol, cutoff - bol, comment_line_str) ||
1926 buf[bol] == '\n') {
1927 /* is this the first of the run of comments? */
1928 if (!boc)
1929 boc = bol;
1930 /* otherwise, it is just continuing */
1931 } else if (starts_with(buf + bol, "Conflicts:\n")) {
1932 in_old_conflicts_block = 1;
1933 if (!boc)
1934 boc = bol;
1935 } else if (in_old_conflicts_block && buf[bol] == '\t') {
1936 ; /* a pathname in the conflicts block */
1937 } else if (boc) {
1938 /* the previous was not trailing comment */
1939 boc = 0;
1940 in_old_conflicts_block = 0;
1941 }
1942 bol = next_line - buf;
1943 }
1944 return boc ? len - boc : len - cutoff;
1945}
1946
1947int run_commit_hook(int editor_is_used, const char *index_file,
1948 int *invoked_hook, const char *name, ...)
1949{
1950 struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT;
1951 va_list args;
1952 const char *arg;
1953
1954 strvec_pushf(&opt.env, "GIT_INDEX_FILE=%s", index_file);
1955
1956 /*
1957 * Let the hook know that no editor will be launched.
1958 */
1959 if (!editor_is_used)
1960 strvec_push(&opt.env, "GIT_EDITOR=:");
1961
1962 va_start(args, name);
1963 while ((arg = va_arg(args, const char *)))
1964 strvec_push(&opt.args, arg);
1965 va_end(args);
1966
1967 opt.invoked_hook = invoked_hook;
1968 return run_hooks_opt(the_repository, name, &opt);
1969}