setup: unset ref storage when reinitializing repository version
[git.git] / commit.c
blob1d08951007bcd9c3722737ef7b4b6ba3ada2f5f5
1 #include "git-compat-util.h"
2 #include "tag.h"
3 #include "commit.h"
4 #include "commit-graph.h"
5 #include "environment.h"
6 #include "gettext.h"
7 #include "hex.h"
8 #include "repository.h"
9 #include "object-name.h"
10 #include "object-store-ll.h"
11 #include "utf8.h"
12 #include "diff.h"
13 #include "revision.h"
14 #include "notes.h"
15 #include "alloc.h"
16 #include "gpg-interface.h"
17 #include "mergesort.h"
18 #include "commit-slab.h"
19 #include "prio-queue.h"
20 #include "hash-lookup.h"
21 #include "wt-status.h"
22 #include "advice.h"
23 #include "refs.h"
24 #include "commit-reach.h"
25 #include "setup.h"
26 #include "shallow.h"
27 #include "tree.h"
28 #include "hook.h"
29 #include "parse.h"
30 #include "object-file-convert.h"
32 static struct commit_extra_header *read_commit_extra_header_lines(const char *buf, size_t len, const char **);
34 int save_commit_buffer = 1;
35 int no_graft_file_deprecated_advice;
37 const char *commit_type = "commit";
39 struct commit *lookup_commit_reference_gently(struct repository *r,
40 const struct object_id *oid, int quiet)
42 struct object *obj = deref_tag(r,
43 parse_object(r, oid),
44 NULL, 0);
46 if (!obj)
47 return NULL;
48 return object_as_type(obj, OBJ_COMMIT, quiet);
51 struct commit *lookup_commit_reference(struct repository *r, const struct object_id *oid)
53 return lookup_commit_reference_gently(r, oid, 0);
56 struct commit *lookup_commit_or_die(const struct object_id *oid, const char *ref_name)
58 struct commit *c = lookup_commit_reference(the_repository, oid);
59 if (!c)
60 die(_("could not parse %s"), ref_name);
61 if (!oideq(oid, &c->object.oid)) {
62 warning(_("%s %s is not a commit!"),
63 ref_name, oid_to_hex(oid));
65 return c;
68 struct commit *lookup_commit_object(struct repository *r,
69 const struct object_id *oid)
71 struct object *obj = parse_object(r, oid);
72 return obj ? object_as_type(obj, OBJ_COMMIT, 0) : NULL;
76 struct commit *lookup_commit(struct repository *r, const struct object_id *oid)
78 struct object *obj = lookup_object(r, oid);
79 if (!obj)
80 return create_object(r, oid, alloc_commit_node(r));
81 return object_as_type(obj, OBJ_COMMIT, 0);
84 struct commit *lookup_commit_reference_by_name(const char *name)
86 struct object_id oid;
87 struct commit *commit;
89 if (repo_get_oid_committish(the_repository, name, &oid))
90 return NULL;
91 commit = lookup_commit_reference(the_repository, &oid);
92 if (repo_parse_commit(the_repository, commit))
93 return NULL;
94 return commit;
97 static timestamp_t parse_commit_date(const char *buf, const char *tail)
99 const char *dateptr;
100 const char *eol;
102 if (buf + 6 >= tail)
103 return 0;
104 if (memcmp(buf, "author", 6))
105 return 0;
106 while (buf < tail && *buf++ != '\n')
107 /* nada */;
108 if (buf + 9 >= tail)
109 return 0;
110 if (memcmp(buf, "committer", 9))
111 return 0;
114 * Jump to end-of-line so that we can walk backwards to find the
115 * end-of-email ">". This is more forgiving of malformed cases
116 * because unexpected characters tend to be in the name and email
117 * fields.
119 eol = memchr(buf, '\n', tail - buf);
120 if (!eol)
121 return 0;
122 dateptr = eol;
123 while (dateptr > buf && dateptr[-1] != '>')
124 dateptr--;
125 if (dateptr == buf)
126 return 0;
129 * Trim leading whitespace, but make sure we have at least one
130 * non-whitespace character, as parse_timestamp() will otherwise walk
131 * right past the newline we found in "eol" when skipping whitespace
132 * itself.
134 * In theory it would be sufficient to allow any character not matched
135 * by isspace(), but there's a catch: our isspace() does not
136 * necessarily match the behavior of parse_timestamp(), as the latter
137 * is implemented by system routines which match more exotic control
138 * codes, or even locale-dependent sequences.
140 * Since we expect the timestamp to be a number, we can check for that.
141 * Anything else (e.g., a non-numeric token like "foo") would just
142 * cause parse_timestamp() to return 0 anyway.
144 while (dateptr < eol && isspace(*dateptr))
145 dateptr++;
146 if (!isdigit(*dateptr) && *dateptr != '-')
147 return 0;
150 * We know there is at least one digit (or dash), so we'll begin
151 * parsing there and stop at worst case at eol.
153 * Note that we may feed parse_timestamp() extra characters here if the
154 * commit is malformed, and it will parse as far as it can. For
155 * example, "123foo456" would return "123". That might be questionable
156 * (versus returning "0"), but it would help in a hypothetical case
157 * like "123456+0100", where the whitespace from the timezone is
158 * missing. Since such syntactic errors may be baked into history and
159 * hard to correct now, let's err on trying to make our best guess
160 * here, rather than insist on perfect syntax.
162 return parse_timestamp(dateptr, NULL, 10);
165 static const struct object_id *commit_graft_oid_access(size_t index, const void *table)
167 const struct commit_graft * const *commit_graft_table = table;
168 return &commit_graft_table[index]->oid;
171 int commit_graft_pos(struct repository *r, const struct object_id *oid)
173 return oid_pos(oid, r->parsed_objects->grafts,
174 r->parsed_objects->grafts_nr,
175 commit_graft_oid_access);
178 static void unparse_commit(struct repository *r, const struct object_id *oid)
180 struct commit *c = lookup_commit(r, oid);
182 if (!c->object.parsed)
183 return;
184 free_commit_list(c->parents);
185 c->parents = NULL;
186 c->object.parsed = 0;
189 int register_commit_graft(struct repository *r, struct commit_graft *graft,
190 int ignore_dups)
192 int pos = commit_graft_pos(r, &graft->oid);
194 if (0 <= pos) {
195 if (ignore_dups)
196 free(graft);
197 else {
198 free(r->parsed_objects->grafts[pos]);
199 r->parsed_objects->grafts[pos] = graft;
201 return 1;
203 pos = -pos - 1;
204 ALLOC_GROW(r->parsed_objects->grafts,
205 r->parsed_objects->grafts_nr + 1,
206 r->parsed_objects->grafts_alloc);
207 r->parsed_objects->grafts_nr++;
208 if (pos < r->parsed_objects->grafts_nr)
209 memmove(r->parsed_objects->grafts + pos + 1,
210 r->parsed_objects->grafts + pos,
211 (r->parsed_objects->grafts_nr - pos - 1) *
212 sizeof(*r->parsed_objects->grafts));
213 r->parsed_objects->grafts[pos] = graft;
214 unparse_commit(r, &graft->oid);
215 return 0;
218 struct commit_graft *read_graft_line(struct strbuf *line)
220 /* The format is just "Commit Parent1 Parent2 ...\n" */
221 int i, phase;
222 const char *tail = NULL;
223 struct commit_graft *graft = NULL;
224 struct object_id dummy_oid, *oid;
226 strbuf_rtrim(line);
227 if (!line->len || line->buf[0] == '#')
228 return NULL;
230 * phase 0 verifies line, counts hashes in line and allocates graft
231 * phase 1 fills graft
233 for (phase = 0; phase < 2; phase++) {
234 oid = graft ? &graft->oid : &dummy_oid;
235 if (parse_oid_hex(line->buf, oid, &tail))
236 goto bad_graft_data;
237 for (i = 0; *tail != '\0'; i++) {
238 oid = graft ? &graft->parent[i] : &dummy_oid;
239 if (!isspace(*tail++) || parse_oid_hex(tail, oid, &tail))
240 goto bad_graft_data;
242 if (!graft) {
243 graft = xmalloc(st_add(sizeof(*graft),
244 st_mult(sizeof(struct object_id), i)));
245 graft->nr_parent = i;
248 return graft;
250 bad_graft_data:
251 error("bad graft data: %s", line->buf);
252 assert(!graft);
253 return NULL;
256 static int read_graft_file(struct repository *r, const char *graft_file)
258 FILE *fp = fopen_or_warn(graft_file, "r");
259 struct strbuf buf = STRBUF_INIT;
260 if (!fp)
261 return -1;
262 if (!no_graft_file_deprecated_advice &&
263 advice_enabled(ADVICE_GRAFT_FILE_DEPRECATED))
264 advise(_("Support for <GIT_DIR>/info/grafts is deprecated\n"
265 "and will be removed in a future Git version.\n"
266 "\n"
267 "Please use \"git replace --convert-graft-file\"\n"
268 "to convert the grafts into replace refs.\n"
269 "\n"
270 "Turn this message off by running\n"
271 "\"git config advice.graftFileDeprecated false\""));
272 while (!strbuf_getwholeline(&buf, fp, '\n')) {
273 /* The format is just "Commit Parent1 Parent2 ...\n" */
274 struct commit_graft *graft = read_graft_line(&buf);
275 if (!graft)
276 continue;
277 if (register_commit_graft(r, graft, 1))
278 error("duplicate graft data: %s", buf.buf);
280 fclose(fp);
281 strbuf_release(&buf);
282 return 0;
285 void prepare_commit_graft(struct repository *r)
287 char *graft_file;
289 if (r->parsed_objects->commit_graft_prepared)
290 return;
291 if (!startup_info->have_repository)
292 return;
294 graft_file = get_graft_file(r);
295 read_graft_file(r, graft_file);
296 /* make sure shallows are read */
297 is_repository_shallow(r);
298 r->parsed_objects->commit_graft_prepared = 1;
301 struct commit_graft *lookup_commit_graft(struct repository *r, const struct object_id *oid)
303 int pos;
304 prepare_commit_graft(r);
305 pos = commit_graft_pos(r, oid);
306 if (pos < 0)
307 return NULL;
308 return r->parsed_objects->grafts[pos];
311 int for_each_commit_graft(each_commit_graft_fn fn, void *cb_data)
313 int i, ret;
314 for (i = ret = 0; i < the_repository->parsed_objects->grafts_nr && !ret; i++)
315 ret = fn(the_repository->parsed_objects->grafts[i], cb_data);
316 return ret;
319 void reset_commit_grafts(struct repository *r)
321 int i;
323 for (i = 0; i < r->parsed_objects->grafts_nr; i++) {
324 unparse_commit(r, &r->parsed_objects->grafts[i]->oid);
325 free(r->parsed_objects->grafts[i]);
327 r->parsed_objects->grafts_nr = 0;
328 r->parsed_objects->commit_graft_prepared = 0;
331 struct commit_buffer {
332 void *buffer;
333 unsigned long size;
335 define_commit_slab(buffer_slab, struct commit_buffer);
337 struct buffer_slab *allocate_commit_buffer_slab(void)
339 struct buffer_slab *bs = xmalloc(sizeof(*bs));
340 init_buffer_slab(bs);
341 return bs;
344 void free_commit_buffer_slab(struct buffer_slab *bs)
346 clear_buffer_slab(bs);
347 free(bs);
350 void set_commit_buffer(struct repository *r, struct commit *commit, void *buffer, unsigned long size)
352 struct commit_buffer *v = buffer_slab_at(
353 r->parsed_objects->buffer_slab, commit);
354 v->buffer = buffer;
355 v->size = size;
358 const void *get_cached_commit_buffer(struct repository *r, const struct commit *commit, unsigned long *sizep)
360 struct commit_buffer *v = buffer_slab_peek(
361 r->parsed_objects->buffer_slab, commit);
362 if (!v) {
363 if (sizep)
364 *sizep = 0;
365 return NULL;
367 if (sizep)
368 *sizep = v->size;
369 return v->buffer;
372 const void *repo_get_commit_buffer(struct repository *r,
373 const struct commit *commit,
374 unsigned long *sizep)
376 const void *ret = get_cached_commit_buffer(r, commit, sizep);
377 if (!ret) {
378 enum object_type type;
379 unsigned long size;
380 ret = repo_read_object_file(r, &commit->object.oid, &type, &size);
381 if (!ret)
382 die("cannot read commit object %s",
383 oid_to_hex(&commit->object.oid));
384 if (type != OBJ_COMMIT)
385 die("expected commit for %s, got %s",
386 oid_to_hex(&commit->object.oid), type_name(type));
387 if (sizep)
388 *sizep = size;
390 return ret;
393 void repo_unuse_commit_buffer(struct repository *r,
394 const struct commit *commit,
395 const void *buffer)
397 struct commit_buffer *v = buffer_slab_peek(
398 r->parsed_objects->buffer_slab, commit);
399 if (!(v && v->buffer == buffer))
400 free((void *)buffer);
403 void free_commit_buffer(struct parsed_object_pool *pool, struct commit *commit)
405 struct commit_buffer *v = buffer_slab_peek(
406 pool->buffer_slab, commit);
407 if (v) {
408 FREE_AND_NULL(v->buffer);
409 v->size = 0;
413 static inline void set_commit_tree(struct commit *c, struct tree *t)
415 c->maybe_tree = t;
418 struct tree *repo_get_commit_tree(struct repository *r,
419 const struct commit *commit)
421 if (commit->maybe_tree || !commit->object.parsed)
422 return commit->maybe_tree;
424 if (commit_graph_position(commit) != COMMIT_NOT_FROM_GRAPH)
425 return get_commit_tree_in_graph(r, commit);
427 return NULL;
430 struct object_id *get_commit_tree_oid(const struct commit *commit)
432 struct tree *tree = repo_get_commit_tree(the_repository, commit);
433 return tree ? &tree->object.oid : NULL;
436 void release_commit_memory(struct parsed_object_pool *pool, struct commit *c)
438 set_commit_tree(c, NULL);
439 free_commit_buffer(pool, c);
440 c->index = 0;
441 free_commit_list(c->parents);
443 c->object.parsed = 0;
446 const void *detach_commit_buffer(struct commit *commit, unsigned long *sizep)
448 struct commit_buffer *v = buffer_slab_peek(
449 the_repository->parsed_objects->buffer_slab, commit);
450 void *ret;
452 if (!v) {
453 if (sizep)
454 *sizep = 0;
455 return NULL;
457 ret = v->buffer;
458 if (sizep)
459 *sizep = v->size;
461 v->buffer = NULL;
462 v->size = 0;
463 return ret;
466 int parse_commit_buffer(struct repository *r, struct commit *item, const void *buffer, unsigned long size, int check_graph)
468 const char *tail = buffer;
469 const char *bufptr = buffer;
470 struct object_id parent;
471 struct commit_list **pptr;
472 struct commit_graft *graft;
473 const int tree_entry_len = the_hash_algo->hexsz + 5;
474 const int parent_entry_len = the_hash_algo->hexsz + 7;
475 struct tree *tree;
477 if (item->object.parsed)
478 return 0;
480 * Presumably this is leftover from an earlier failed parse;
481 * clear it out in preparation for us re-parsing (we'll hit the
482 * same error, but that's good, since it lets our caller know
483 * the result cannot be trusted.
485 free_commit_list(item->parents);
486 item->parents = NULL;
488 tail += size;
489 if (tail <= bufptr + tree_entry_len + 1 || memcmp(bufptr, "tree ", 5) ||
490 bufptr[tree_entry_len] != '\n')
491 return error("bogus commit object %s", oid_to_hex(&item->object.oid));
492 if (get_oid_hex(bufptr + 5, &parent) < 0)
493 return error("bad tree pointer in commit %s",
494 oid_to_hex(&item->object.oid));
495 tree = lookup_tree(r, &parent);
496 if (!tree)
497 return error("bad tree pointer %s in commit %s",
498 oid_to_hex(&parent),
499 oid_to_hex(&item->object.oid));
500 set_commit_tree(item, tree);
501 bufptr += tree_entry_len + 1; /* "tree " + "hex sha1" + "\n" */
502 pptr = &item->parents;
504 graft = lookup_commit_graft(r, &item->object.oid);
505 if (graft)
506 r->parsed_objects->substituted_parent = 1;
507 while (bufptr + parent_entry_len < tail && !memcmp(bufptr, "parent ", 7)) {
508 struct commit *new_parent;
510 if (tail <= bufptr + parent_entry_len + 1 ||
511 get_oid_hex(bufptr + 7, &parent) ||
512 bufptr[parent_entry_len] != '\n')
513 return error("bad parents in commit %s", oid_to_hex(&item->object.oid));
514 bufptr += parent_entry_len + 1;
516 * The clone is shallow if nr_parent < 0, and we must
517 * not traverse its real parents even when we unhide them.
519 if (graft && (graft->nr_parent < 0 || !grafts_keep_true_parents))
520 continue;
521 new_parent = lookup_commit(r, &parent);
522 if (!new_parent)
523 return error("bad parent %s in commit %s",
524 oid_to_hex(&parent),
525 oid_to_hex(&item->object.oid));
526 pptr = &commit_list_insert(new_parent, pptr)->next;
528 if (graft) {
529 int i;
530 struct commit *new_parent;
531 for (i = 0; i < graft->nr_parent; i++) {
532 new_parent = lookup_commit(r,
533 &graft->parent[i]);
534 if (!new_parent)
535 return error("bad graft parent %s in commit %s",
536 oid_to_hex(&graft->parent[i]),
537 oid_to_hex(&item->object.oid));
538 pptr = &commit_list_insert(new_parent, pptr)->next;
541 item->date = parse_commit_date(bufptr, tail);
543 if (check_graph)
544 load_commit_graph_info(r, item);
546 item->object.parsed = 1;
547 return 0;
550 int repo_parse_commit_internal(struct repository *r,
551 struct commit *item,
552 int quiet_on_missing,
553 int use_commit_graph)
555 enum object_type type;
556 void *buffer;
557 unsigned long size;
558 struct object_info oi = {
559 .typep = &type,
560 .sizep = &size,
561 .contentp = &buffer,
564 * Git does not support partial clones that exclude commits, so set
565 * OBJECT_INFO_SKIP_FETCH_OBJECT to fail fast when an object is missing.
567 int flags = OBJECT_INFO_LOOKUP_REPLACE | OBJECT_INFO_SKIP_FETCH_OBJECT |
568 OBJECT_INFO_DIE_IF_CORRUPT;
569 int ret;
571 if (!item)
572 return -1;
573 if (item->object.parsed)
574 return 0;
575 if (use_commit_graph && parse_commit_in_graph(r, item)) {
576 static int commit_graph_paranoia = -1;
578 if (commit_graph_paranoia == -1)
579 commit_graph_paranoia = git_env_bool(GIT_COMMIT_GRAPH_PARANOIA, 0);
581 if (commit_graph_paranoia && !has_object(r, &item->object.oid, 0)) {
582 unparse_commit(r, &item->object.oid);
583 return quiet_on_missing ? -1 :
584 error(_("commit %s exists in commit-graph but not in the object database"),
585 oid_to_hex(&item->object.oid));
588 return 0;
591 if (oid_object_info_extended(r, &item->object.oid, &oi, flags) < 0)
592 return quiet_on_missing ? -1 :
593 error("Could not read %s",
594 oid_to_hex(&item->object.oid));
595 if (type != OBJ_COMMIT) {
596 free(buffer);
597 return error("Object %s not a commit",
598 oid_to_hex(&item->object.oid));
601 ret = parse_commit_buffer(r, item, buffer, size, 0);
602 if (save_commit_buffer && !ret) {
603 set_commit_buffer(r, item, buffer, size);
604 return 0;
606 free(buffer);
607 return ret;
610 int repo_parse_commit_gently(struct repository *r,
611 struct commit *item, int quiet_on_missing)
613 return repo_parse_commit_internal(r, item, quiet_on_missing, 1);
616 void parse_commit_or_die(struct commit *item)
618 if (repo_parse_commit(the_repository, item))
619 die("unable to parse commit %s",
620 item ? oid_to_hex(&item->object.oid) : "(null)");
623 int find_commit_subject(const char *commit_buffer, const char **subject)
625 const char *eol;
626 const char *p = commit_buffer;
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;
636 *subject = p;
638 return eol - p;
641 size_t commit_subject_length(const char *body)
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++;
652 return p - body;
655 struct commit_list *commit_list_insert(struct commit *item, struct commit_list **list_p)
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;
664 int commit_list_contains(struct commit *item, struct commit_list *list)
666 while (list) {
667 if (list->item == item)
668 return 1;
669 list = list->next;
672 return 0;
675 unsigned commit_list_count(const struct commit_list *l)
677 unsigned c = 0;
678 for (; l; l = l->next )
679 c++;
680 return c;
683 struct commit_list *copy_commit_list(struct commit_list *list)
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;
691 return head;
694 struct commit_list *reverse_commit_list(struct commit_list *list)
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;
702 return next;
705 void free_commit_list(struct commit_list *list)
707 while (list)
708 pop_commit(&list);
711 struct commit_list * commit_list_insert_by_date(struct commit *item, struct commit_list **list)
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;
719 pp = &p->next;
721 return commit_list_insert(item, pp);
724 static int commit_list_compare_by_date(const struct commit_list *a,
725 const struct commit_list *b)
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;
736 DEFINE_LIST_SORT(static, commit_list_sort, struct commit_list, next);
738 void commit_list_sort_by_date(struct commit_list **list)
740 commit_list_sort(list, commit_list_compare_by_date);
743 struct commit *pop_most_recent_commit(struct commit_list **list,
744 unsigned int mark)
746 struct commit *ret = pop_commit(list);
747 struct commit_list *parents = ret->parents;
749 while (parents) {
750 struct commit *commit = parents->item;
751 if (!repo_parse_commit(the_repository, commit) && !(commit->object.flags & mark)) {
752 commit->object.flags |= mark;
753 commit_list_insert_by_date(commit, list);
755 parents = parents->next;
757 return ret;
760 static void clear_commit_marks_1(struct commit_list **plist,
761 struct commit *commit, unsigned int mark)
763 while (commit) {
764 struct commit_list *parents;
766 if (!(mark & commit->object.flags))
767 return;
769 commit->object.flags &= ~mark;
771 parents = commit->parents;
772 if (!parents)
773 return;
775 while ((parents = parents->next)) {
776 if (parents->item->object.flags & mark)
777 commit_list_insert(parents->item, plist);
780 commit = commit->parents->item;
784 void clear_commit_marks_many(int nr, struct commit **commit, unsigned int mark)
786 struct commit_list *list = NULL;
788 while (nr--) {
789 clear_commit_marks_1(&list, *commit, mark);
790 commit++;
792 while (list)
793 clear_commit_marks_1(&list, pop_commit(&list), mark);
796 void clear_commit_marks(struct commit *commit, unsigned int mark)
798 clear_commit_marks_many(1, &commit, mark);
801 struct commit *pop_commit(struct commit_list **stack)
803 struct commit_list *top = *stack;
804 struct commit *item = top ? top->item : NULL;
806 if (top) {
807 *stack = top->next;
808 free(top);
810 return item;
814 * Topological sort support
817 /* count number of children that have not been emitted */
818 define_commit_slab(indegree_slab, int);
820 define_commit_slab(author_date_slab, timestamp_t);
822 void record_author_date(struct author_date_slab *author_date,
823 struct commit *commit)
825 const char *buffer = repo_get_commit_buffer(the_repository, commit,
826 NULL);
827 struct ident_split ident;
828 const char *ident_line;
829 size_t ident_len;
830 char *date_end;
831 timestamp_t date;
833 ident_line = find_commit_header(buffer, "author", &ident_len);
834 if (!ident_line)
835 goto fail_exit; /* no author line */
836 if (split_ident_line(&ident, ident_line, ident_len) ||
837 !ident.date_begin || !ident.date_end)
838 goto fail_exit; /* malformed "author" line */
840 date = parse_timestamp(ident.date_begin, &date_end, 10);
841 if (date_end != ident.date_end)
842 goto fail_exit; /* malformed date */
843 *(author_date_slab_at(author_date, commit)) = date;
845 fail_exit:
846 repo_unuse_commit_buffer(the_repository, commit, buffer);
849 int compare_commits_by_author_date(const void *a_, const void *b_,
850 void *cb_data)
852 const struct commit *a = a_, *b = b_;
853 struct author_date_slab *author_date = cb_data;
854 timestamp_t a_date = *(author_date_slab_at(author_date, a));
855 timestamp_t b_date = *(author_date_slab_at(author_date, b));
857 /* newer commits with larger date first */
858 if (a_date < b_date)
859 return 1;
860 else if (a_date > b_date)
861 return -1;
862 return 0;
865 int compare_commits_by_gen_then_commit_date(const void *a_, const void *b_,
866 void *unused UNUSED)
868 const struct commit *a = a_, *b = b_;
869 const timestamp_t generation_a = commit_graph_generation(a),
870 generation_b = commit_graph_generation(b);
872 /* newer commits first */
873 if (generation_a < generation_b)
874 return 1;
875 else if (generation_a > generation_b)
876 return -1;
878 /* use date as a heuristic when generations are equal */
879 if (a->date < b->date)
880 return 1;
881 else if (a->date > b->date)
882 return -1;
883 return 0;
886 int compare_commits_by_commit_date(const void *a_, const void *b_,
887 void *unused UNUSED)
889 const struct commit *a = a_, *b = b_;
890 /* newer commits with larger date first */
891 if (a->date < b->date)
892 return 1;
893 else if (a->date > b->date)
894 return -1;
895 return 0;
899 * Performs an in-place topological sort on the list supplied.
901 void sort_in_topological_order(struct commit_list **list, enum rev_sort_order sort_order)
903 struct commit_list *next, *orig = *list;
904 struct commit_list **pptr;
905 struct indegree_slab indegree;
906 struct prio_queue queue;
907 struct commit *commit;
908 struct author_date_slab author_date;
910 if (!orig)
911 return;
912 *list = NULL;
914 init_indegree_slab(&indegree);
915 memset(&queue, '\0', sizeof(queue));
917 switch (sort_order) {
918 default: /* REV_SORT_IN_GRAPH_ORDER */
919 queue.compare = NULL;
920 break;
921 case REV_SORT_BY_COMMIT_DATE:
922 queue.compare = compare_commits_by_commit_date;
923 break;
924 case REV_SORT_BY_AUTHOR_DATE:
925 init_author_date_slab(&author_date);
926 queue.compare = compare_commits_by_author_date;
927 queue.cb_data = &author_date;
928 break;
931 /* Mark them and clear the indegree */
932 for (next = orig; next; next = next->next) {
933 struct commit *commit = next->item;
934 *(indegree_slab_at(&indegree, commit)) = 1;
935 /* also record the author dates, if needed */
936 if (sort_order == REV_SORT_BY_AUTHOR_DATE)
937 record_author_date(&author_date, commit);
940 /* update the indegree */
941 for (next = orig; next; next = next->next) {
942 struct commit_list *parents = next->item->parents;
943 while (parents) {
944 struct commit *parent = parents->item;
945 int *pi = indegree_slab_at(&indegree, parent);
947 if (*pi)
948 (*pi)++;
949 parents = parents->next;
954 * find the tips
956 * tips are nodes not reachable from any other node in the list
958 * the tips serve as a starting set for the work queue.
960 for (next = orig; next; next = next->next) {
961 struct commit *commit = next->item;
963 if (*(indegree_slab_at(&indegree, commit)) == 1)
964 prio_queue_put(&queue, commit);
968 * This is unfortunate; the initial tips need to be shown
969 * in the order given from the revision traversal machinery.
971 if (sort_order == REV_SORT_IN_GRAPH_ORDER)
972 prio_queue_reverse(&queue);
974 /* We no longer need the commit list */
975 free_commit_list(orig);
977 pptr = list;
978 *list = NULL;
979 while ((commit = prio_queue_get(&queue)) != NULL) {
980 struct commit_list *parents;
982 for (parents = commit->parents; parents ; parents = parents->next) {
983 struct commit *parent = parents->item;
984 int *pi = indegree_slab_at(&indegree, parent);
986 if (!*pi)
987 continue;
990 * parents are only enqueued for emission
991 * when all their children have been emitted thereby
992 * guaranteeing topological order.
994 if (--(*pi) == 1)
995 prio_queue_put(&queue, parent);
998 * all children of commit have already been
999 * emitted. we can emit it now.
1001 *(indegree_slab_at(&indegree, commit)) = 0;
1003 pptr = &commit_list_insert(commit, pptr)->next;
1006 clear_indegree_slab(&indegree);
1007 clear_prio_queue(&queue);
1008 if (sort_order == REV_SORT_BY_AUTHOR_DATE)
1009 clear_author_date_slab(&author_date);
1012 struct rev_collect {
1013 struct commit **commit;
1014 int nr;
1015 int alloc;
1016 unsigned int initial : 1;
1019 static void add_one_commit(struct object_id *oid, struct rev_collect *revs)
1021 struct commit *commit;
1023 if (is_null_oid(oid))
1024 return;
1026 commit = lookup_commit(the_repository, oid);
1027 if (!commit ||
1028 (commit->object.flags & TMP_MARK) ||
1029 repo_parse_commit(the_repository, commit))
1030 return;
1032 ALLOC_GROW(revs->commit, revs->nr + 1, revs->alloc);
1033 revs->commit[revs->nr++] = commit;
1034 commit->object.flags |= TMP_MARK;
1037 static int collect_one_reflog_ent(struct object_id *ooid, struct object_id *noid,
1038 const char *ident UNUSED,
1039 timestamp_t timestamp UNUSED, int tz UNUSED,
1040 const char *message UNUSED, void *cbdata)
1042 struct rev_collect *revs = cbdata;
1044 if (revs->initial) {
1045 revs->initial = 0;
1046 add_one_commit(ooid, revs);
1048 add_one_commit(noid, revs);
1049 return 0;
1052 struct commit *get_fork_point(const char *refname, struct commit *commit)
1054 struct object_id oid;
1055 struct rev_collect revs;
1056 struct commit_list *bases = NULL;
1057 int i;
1058 struct commit *ret = NULL;
1059 char *full_refname;
1061 switch (repo_dwim_ref(the_repository, refname, strlen(refname), &oid,
1062 &full_refname, 0)) {
1063 case 0:
1064 die("No such ref: '%s'", refname);
1065 case 1:
1066 break; /* good */
1067 default:
1068 die("Ambiguous refname: '%s'", refname);
1071 memset(&revs, 0, sizeof(revs));
1072 revs.initial = 1;
1073 refs_for_each_reflog_ent(get_main_ref_store(the_repository),
1074 full_refname, collect_one_reflog_ent, &revs);
1076 if (!revs.nr)
1077 add_one_commit(&oid, &revs);
1079 for (i = 0; i < revs.nr; i++)
1080 revs.commit[i]->object.flags &= ~TMP_MARK;
1082 if (repo_get_merge_bases_many(the_repository, commit, revs.nr,
1083 revs.commit, &bases) < 0)
1084 exit(128);
1087 * There should be one and only one merge base, when we found
1088 * a common ancestor among reflog entries.
1090 if (!bases || bases->next)
1091 goto cleanup_return;
1093 /* And the found one must be one of the reflog entries */
1094 for (i = 0; i < revs.nr; i++)
1095 if (&bases->item->object == &revs.commit[i]->object)
1096 break; /* found */
1097 if (revs.nr <= i)
1098 goto cleanup_return;
1100 ret = bases->item;
1102 cleanup_return:
1103 free(revs.commit);
1104 free_commit_list(bases);
1105 free(full_refname);
1106 return ret;
1110 * Indexed by hash algorithm identifier.
1112 static const char *gpg_sig_headers[] = {
1113 NULL,
1114 "gpgsig",
1115 "gpgsig-sha256",
1118 int add_header_signature(struct strbuf *buf, struct strbuf *sig, const struct git_hash_algo *algo)
1120 int inspos, copypos;
1121 const char *eoh;
1122 const char *gpg_sig_header = gpg_sig_headers[hash_algo_by_ptr(algo)];
1123 int gpg_sig_header_len = strlen(gpg_sig_header);
1125 /* find the end of the header */
1126 eoh = strstr(buf->buf, "\n\n");
1127 if (!eoh)
1128 inspos = buf->len;
1129 else
1130 inspos = eoh - buf->buf + 1;
1132 for (copypos = 0; sig->buf[copypos]; ) {
1133 const char *bol = sig->buf + copypos;
1134 const char *eol = strchrnul(bol, '\n');
1135 int len = (eol - bol) + !!*eol;
1137 if (!copypos) {
1138 strbuf_insert(buf, inspos, gpg_sig_header, gpg_sig_header_len);
1139 inspos += gpg_sig_header_len;
1141 strbuf_insertstr(buf, inspos++, " ");
1142 strbuf_insert(buf, inspos, bol, len);
1143 inspos += len;
1144 copypos += len;
1146 return 0;
1149 static int sign_commit_to_strbuf(struct strbuf *sig, struct strbuf *buf, const char *keyid)
1151 if (!keyid || !*keyid)
1152 keyid = get_signing_key();
1153 if (sign_buffer(buf, sig, keyid))
1154 return -1;
1155 return 0;
1158 int parse_signed_commit(const struct commit *commit,
1159 struct strbuf *payload, struct strbuf *signature,
1160 const struct git_hash_algo *algop)
1162 unsigned long size;
1163 const char *buffer = repo_get_commit_buffer(the_repository, commit,
1164 &size);
1165 int ret = parse_buffer_signed_by_header(buffer, size, payload, signature, algop);
1167 repo_unuse_commit_buffer(the_repository, commit, buffer);
1168 return ret;
1171 int parse_buffer_signed_by_header(const char *buffer,
1172 unsigned long size,
1173 struct strbuf *payload,
1174 struct strbuf *signature,
1175 const struct git_hash_algo *algop)
1177 int in_signature = 0, saw_signature = 0, other_signature = 0;
1178 const char *line, *tail, *p;
1179 const char *gpg_sig_header = gpg_sig_headers[hash_algo_by_ptr(algop)];
1181 line = buffer;
1182 tail = buffer + size;
1183 while (line < tail) {
1184 const char *sig = NULL;
1185 const char *next = memchr(line, '\n', tail - line);
1187 next = next ? next + 1 : tail;
1188 if (in_signature && line[0] == ' ')
1189 sig = line + 1;
1190 else if (skip_prefix(line, gpg_sig_header, &p) &&
1191 *p == ' ') {
1192 sig = line + strlen(gpg_sig_header) + 1;
1193 other_signature = 0;
1195 else if (starts_with(line, "gpgsig"))
1196 other_signature = 1;
1197 else if (other_signature && line[0] != ' ')
1198 other_signature = 0;
1199 if (sig) {
1200 strbuf_add(signature, sig, next - sig);
1201 saw_signature = 1;
1202 in_signature = 1;
1203 } else {
1204 if (*line == '\n')
1205 /* dump the whole remainder of the buffer */
1206 next = tail;
1207 if (!other_signature)
1208 strbuf_add(payload, line, next - line);
1209 in_signature = 0;
1211 line = next;
1213 return saw_signature;
1216 int remove_signature(struct strbuf *buf)
1218 const char *line = buf->buf;
1219 const char *tail = buf->buf + buf->len;
1220 int in_signature = 0;
1221 struct sigbuf {
1222 const char *start;
1223 const char *end;
1224 } sigs[2], *sigp = &sigs[0];
1225 int i;
1226 const char *orig_buf = buf->buf;
1228 memset(sigs, 0, sizeof(sigs));
1230 while (line < tail) {
1231 const char *next = memchr(line, '\n', tail - line);
1232 next = next ? next + 1 : tail;
1234 if (in_signature && line[0] == ' ')
1235 sigp->end = next;
1236 else if (starts_with(line, "gpgsig")) {
1237 int i;
1238 for (i = 1; i < GIT_HASH_NALGOS; i++) {
1239 const char *p;
1240 if (skip_prefix(line, gpg_sig_headers[i], &p) &&
1241 *p == ' ') {
1242 sigp->start = line;
1243 sigp->end = next;
1244 in_signature = 1;
1247 } else {
1248 if (*line == '\n')
1249 /* dump the whole remainder of the buffer */
1250 next = tail;
1251 if (in_signature && sigp - sigs != ARRAY_SIZE(sigs))
1252 sigp++;
1253 in_signature = 0;
1255 line = next;
1258 for (i = ARRAY_SIZE(sigs) - 1; i >= 0; i--)
1259 if (sigs[i].start)
1260 strbuf_remove(buf, sigs[i].start - orig_buf, sigs[i].end - sigs[i].start);
1262 return sigs[0].start != NULL;
1265 static void handle_signed_tag(struct commit *parent, struct commit_extra_header ***tail)
1267 struct merge_remote_desc *desc;
1268 struct commit_extra_header *mergetag;
1269 char *buf;
1270 unsigned long size;
1271 enum object_type type;
1272 struct strbuf payload = STRBUF_INIT;
1273 struct strbuf signature = STRBUF_INIT;
1275 desc = merge_remote_util(parent);
1276 if (!desc || !desc->obj)
1277 return;
1278 buf = repo_read_object_file(the_repository, &desc->obj->oid, &type,
1279 &size);
1280 if (!buf || type != OBJ_TAG)
1281 goto free_return;
1282 if (!parse_signature(buf, size, &payload, &signature))
1283 goto free_return;
1285 * We could verify this signature and either omit the tag when
1286 * it does not validate, but the integrator may not have the
1287 * public key of the signer of the tag being merged, while a
1288 * later auditor may have it while auditing, so let's not run
1289 * verify-signed-buffer here for now...
1291 * if (verify_signed_buffer(buf, len, buf + len, size - len, ...))
1292 * warn("warning: signed tag unverified.");
1294 CALLOC_ARRAY(mergetag, 1);
1295 mergetag->key = xstrdup("mergetag");
1296 mergetag->value = buf;
1297 mergetag->len = size;
1299 **tail = mergetag;
1300 *tail = &mergetag->next;
1301 strbuf_release(&payload);
1302 strbuf_release(&signature);
1303 return;
1305 free_return:
1306 free(buf);
1309 int check_commit_signature(const struct commit *commit, struct signature_check *sigc)
1311 struct strbuf payload = STRBUF_INIT;
1312 struct strbuf signature = STRBUF_INIT;
1313 int ret = 1;
1315 sigc->result = 'N';
1317 if (parse_signed_commit(commit, &payload, &signature, the_hash_algo) <= 0)
1318 goto out;
1320 sigc->payload_type = SIGNATURE_PAYLOAD_COMMIT;
1321 sigc->payload = strbuf_detach(&payload, &sigc->payload_len);
1322 ret = check_signature(sigc, signature.buf, signature.len);
1324 out:
1325 strbuf_release(&payload);
1326 strbuf_release(&signature);
1328 return ret;
1331 void verify_merge_signature(struct commit *commit, int verbosity,
1332 int check_trust)
1334 char hex[GIT_MAX_HEXSZ + 1];
1335 struct signature_check signature_check;
1336 int ret;
1337 memset(&signature_check, 0, sizeof(signature_check));
1339 ret = check_commit_signature(commit, &signature_check);
1341 repo_find_unique_abbrev_r(the_repository, hex, &commit->object.oid,
1342 DEFAULT_ABBREV);
1343 switch (signature_check.result) {
1344 case 'G':
1345 if (ret || (check_trust && signature_check.trust_level < TRUST_MARGINAL))
1346 die(_("Commit %s has an untrusted GPG signature, "
1347 "allegedly by %s."), hex, signature_check.signer);
1348 break;
1349 case 'B':
1350 die(_("Commit %s has a bad GPG signature "
1351 "allegedly by %s."), hex, signature_check.signer);
1352 default: /* 'N' */
1353 die(_("Commit %s does not have a GPG signature."), hex);
1355 if (verbosity >= 0 && signature_check.result == 'G')
1356 printf(_("Commit %s has a good GPG signature by %s\n"),
1357 hex, signature_check.signer);
1359 signature_check_clear(&signature_check);
1362 void append_merge_tag_headers(struct commit_list *parents,
1363 struct commit_extra_header ***tail)
1365 while (parents) {
1366 struct commit *parent = parents->item;
1367 handle_signed_tag(parent, tail);
1368 parents = parents->next;
1372 static int convert_commit_extra_headers(struct commit_extra_header *orig,
1373 struct commit_extra_header **result)
1375 const struct git_hash_algo *compat = the_repository->compat_hash_algo;
1376 const struct git_hash_algo *algo = the_repository->hash_algo;
1377 struct commit_extra_header *extra = NULL, **tail = &extra;
1378 struct strbuf out = STRBUF_INIT;
1379 while (orig) {
1380 struct commit_extra_header *new;
1381 CALLOC_ARRAY(new, 1);
1382 if (!strcmp(orig->key, "mergetag")) {
1383 if (convert_object_file(&out, algo, compat,
1384 orig->value, orig->len,
1385 OBJ_TAG, 1)) {
1386 free(new);
1387 free_commit_extra_headers(extra);
1388 return -1;
1390 new->key = xstrdup("mergetag");
1391 new->value = strbuf_detach(&out, &new->len);
1392 } else {
1393 new->key = xstrdup(orig->key);
1394 new->len = orig->len;
1395 new->value = xmemdupz(orig->value, orig->len);
1397 *tail = new;
1398 tail = &new->next;
1399 orig = orig->next;
1401 *result = extra;
1402 return 0;
1405 static void add_extra_header(struct strbuf *buffer,
1406 struct commit_extra_header *extra)
1408 strbuf_addstr(buffer, extra->key);
1409 if (extra->len)
1410 strbuf_add_lines(buffer, " ", extra->value, extra->len);
1411 else
1412 strbuf_addch(buffer, '\n');
1415 struct commit_extra_header *read_commit_extra_headers(struct commit *commit,
1416 const char **exclude)
1418 struct commit_extra_header *extra = NULL;
1419 unsigned long size;
1420 const char *buffer = repo_get_commit_buffer(the_repository, commit,
1421 &size);
1422 extra = read_commit_extra_header_lines(buffer, size, exclude);
1423 repo_unuse_commit_buffer(the_repository, commit, buffer);
1424 return extra;
1427 int for_each_mergetag(each_mergetag_fn fn, struct commit *commit, void *data)
1429 struct commit_extra_header *extra, *to_free;
1430 int res = 0;
1432 to_free = read_commit_extra_headers(commit, NULL);
1433 for (extra = to_free; !res && extra; extra = extra->next) {
1434 if (strcmp(extra->key, "mergetag"))
1435 continue; /* not a merge tag */
1436 res = fn(commit, extra, data);
1438 free_commit_extra_headers(to_free);
1439 return res;
1442 static inline int standard_header_field(const char *field, size_t len)
1444 return ((len == 4 && !memcmp(field, "tree", 4)) ||
1445 (len == 6 && !memcmp(field, "parent", 6)) ||
1446 (len == 6 && !memcmp(field, "author", 6)) ||
1447 (len == 9 && !memcmp(field, "committer", 9)) ||
1448 (len == 8 && !memcmp(field, "encoding", 8)));
1451 static int excluded_header_field(const char *field, size_t len, const char **exclude)
1453 if (!exclude)
1454 return 0;
1456 while (*exclude) {
1457 size_t xlen = strlen(*exclude);
1458 if (len == xlen && !memcmp(field, *exclude, xlen))
1459 return 1;
1460 exclude++;
1462 return 0;
1465 static struct commit_extra_header *read_commit_extra_header_lines(
1466 const char *buffer, size_t size,
1467 const char **exclude)
1469 struct commit_extra_header *extra = NULL, **tail = &extra, *it = NULL;
1470 const char *line, *next, *eof, *eob;
1471 struct strbuf buf = STRBUF_INIT;
1473 for (line = buffer, eob = line + size;
1474 line < eob && *line != '\n';
1475 line = next) {
1476 next = memchr(line, '\n', eob - line);
1477 next = next ? next + 1 : eob;
1478 if (*line == ' ') {
1479 /* continuation */
1480 if (it)
1481 strbuf_add(&buf, line + 1, next - (line + 1));
1482 continue;
1484 if (it)
1485 it->value = strbuf_detach(&buf, &it->len);
1486 strbuf_reset(&buf);
1487 it = NULL;
1489 eof = memchr(line, ' ', next - line);
1490 if (!eof)
1491 eof = next;
1492 else if (standard_header_field(line, eof - line) ||
1493 excluded_header_field(line, eof - line, exclude))
1494 continue;
1496 CALLOC_ARRAY(it, 1);
1497 it->key = xmemdupz(line, eof-line);
1498 *tail = it;
1499 tail = &it->next;
1500 if (eof + 1 < next)
1501 strbuf_add(&buf, eof + 1, next - (eof + 1));
1503 if (it)
1504 it->value = strbuf_detach(&buf, &it->len);
1505 return extra;
1508 void free_commit_extra_headers(struct commit_extra_header *extra)
1510 while (extra) {
1511 struct commit_extra_header *next = extra->next;
1512 free(extra->key);
1513 free(extra->value);
1514 free(extra);
1515 extra = next;
1519 int commit_tree(const char *msg, size_t msg_len, const struct object_id *tree,
1520 struct commit_list *parents, struct object_id *ret,
1521 const char *author, const char *sign_commit)
1523 struct commit_extra_header *extra = NULL, **tail = &extra;
1524 int result;
1526 append_merge_tag_headers(parents, &tail);
1527 result = commit_tree_extended(msg, msg_len, tree, parents, ret, author,
1528 NULL, sign_commit, extra);
1529 free_commit_extra_headers(extra);
1530 return result;
1533 static int find_invalid_utf8(const char *buf, int len)
1535 int offset = 0;
1536 static const unsigned int max_codepoint[] = {
1537 0x7f, 0x7ff, 0xffff, 0x10ffff
1540 while (len) {
1541 unsigned char c = *buf++;
1542 int bytes, bad_offset;
1543 unsigned int codepoint;
1544 unsigned int min_val, max_val;
1546 len--;
1547 offset++;
1549 /* Simple US-ASCII? No worries. */
1550 if (c < 0x80)
1551 continue;
1553 bad_offset = offset-1;
1556 * Count how many more high bits set: that's how
1557 * many more bytes this sequence should have.
1559 bytes = 0;
1560 while (c & 0x40) {
1561 c <<= 1;
1562 bytes++;
1566 * Must be between 1 and 3 more bytes. Longer sequences result in
1567 * codepoints beyond U+10FFFF, which are guaranteed never to exist.
1569 if (bytes < 1 || 3 < bytes)
1570 return bad_offset;
1572 /* Do we *have* that many bytes? */
1573 if (len < bytes)
1574 return bad_offset;
1577 * Place the encoded bits at the bottom of the value and compute the
1578 * valid range.
1580 codepoint = (c & 0x7f) >> bytes;
1581 min_val = max_codepoint[bytes-1] + 1;
1582 max_val = max_codepoint[bytes];
1584 offset += bytes;
1585 len -= bytes;
1587 /* And verify that they are good continuation bytes */
1588 do {
1589 codepoint <<= 6;
1590 codepoint |= *buf & 0x3f;
1591 if ((*buf++ & 0xc0) != 0x80)
1592 return bad_offset;
1593 } while (--bytes);
1595 /* Reject codepoints that are out of range for the sequence length. */
1596 if (codepoint < min_val || codepoint > max_val)
1597 return bad_offset;
1598 /* Surrogates are only for UTF-16 and cannot be encoded in UTF-8. */
1599 if ((codepoint & 0x1ff800) == 0xd800)
1600 return bad_offset;
1601 /* U+xxFFFE and U+xxFFFF are guaranteed non-characters. */
1602 if ((codepoint & 0xfffe) == 0xfffe)
1603 return bad_offset;
1604 /* So are anything in the range U+FDD0..U+FDEF. */
1605 if (codepoint >= 0xfdd0 && codepoint <= 0xfdef)
1606 return bad_offset;
1608 return -1;
1612 * This verifies that the buffer is in proper utf8 format.
1614 * If it isn't, it assumes any non-utf8 characters are Latin1,
1615 * and does the conversion.
1617 static int verify_utf8(struct strbuf *buf)
1619 int ok = 1;
1620 long pos = 0;
1622 for (;;) {
1623 int bad;
1624 unsigned char c;
1625 unsigned char replace[2];
1627 bad = find_invalid_utf8(buf->buf + pos, buf->len - pos);
1628 if (bad < 0)
1629 return ok;
1630 pos += bad;
1631 ok = 0;
1632 c = buf->buf[pos];
1633 strbuf_remove(buf, pos, 1);
1635 /* We know 'c' must be in the range 128-255 */
1636 replace[0] = 0xc0 + (c >> 6);
1637 replace[1] = 0x80 + (c & 0x3f);
1638 strbuf_insert(buf, pos, replace, 2);
1639 pos += 2;
1643 static const char commit_utf8_warn[] =
1644 N_("Warning: commit message did not conform to UTF-8.\n"
1645 "You may want to amend it after fixing the message, or set the config\n"
1646 "variable i18n.commitEncoding to the encoding your project uses.\n");
1648 static void write_commit_tree(struct strbuf *buffer, const char *msg, size_t msg_len,
1649 const struct object_id *tree,
1650 const struct object_id *parents, size_t parents_len,
1651 const char *author, const char *committer,
1652 struct commit_extra_header *extra)
1654 int encoding_is_utf8;
1655 size_t i;
1657 /* Not having i18n.commitencoding is the same as having utf-8 */
1658 encoding_is_utf8 = is_encoding_utf8(git_commit_encoding);
1660 strbuf_grow(buffer, 8192); /* should avoid reallocs for the headers */
1661 strbuf_addf(buffer, "tree %s\n", oid_to_hex(tree));
1664 * NOTE! This ordering means that the same exact tree merged with a
1665 * different order of parents will be a _different_ changeset even
1666 * if everything else stays the same.
1668 for (i = 0; i < parents_len; i++)
1669 strbuf_addf(buffer, "parent %s\n", oid_to_hex(&parents[i]));
1671 /* Person/date information */
1672 if (!author)
1673 author = git_author_info(IDENT_STRICT);
1674 strbuf_addf(buffer, "author %s\n", author);
1675 if (!committer)
1676 committer = git_committer_info(IDENT_STRICT);
1677 strbuf_addf(buffer, "committer %s\n", committer);
1678 if (!encoding_is_utf8)
1679 strbuf_addf(buffer, "encoding %s\n", git_commit_encoding);
1681 while (extra) {
1682 add_extra_header(buffer, extra);
1683 extra = extra->next;
1685 strbuf_addch(buffer, '\n');
1687 /* And add the comment */
1688 strbuf_add(buffer, msg, msg_len);
1691 int commit_tree_extended(const char *msg, size_t msg_len,
1692 const struct object_id *tree,
1693 struct commit_list *parents, struct object_id *ret,
1694 const char *author, const char *committer,
1695 const char *sign_commit,
1696 struct commit_extra_header *extra)
1698 struct repository *r = the_repository;
1699 int result = 0;
1700 int encoding_is_utf8;
1701 struct strbuf buffer = STRBUF_INIT, compat_buffer = STRBUF_INIT;
1702 struct strbuf sig = STRBUF_INIT, compat_sig = STRBUF_INIT;
1703 struct object_id *parent_buf = NULL, *compat_oid = NULL;
1704 struct object_id compat_oid_buf;
1705 size_t i, nparents;
1707 /* Not having i18n.commitencoding is the same as having utf-8 */
1708 encoding_is_utf8 = is_encoding_utf8(git_commit_encoding);
1710 assert_oid_type(tree, OBJ_TREE);
1712 if (memchr(msg, '\0', msg_len))
1713 return error("a NUL byte in commit log message not allowed.");
1715 nparents = commit_list_count(parents);
1716 CALLOC_ARRAY(parent_buf, nparents);
1717 i = 0;
1718 while (parents) {
1719 struct commit *parent = pop_commit(&parents);
1720 oidcpy(&parent_buf[i++], &parent->object.oid);
1723 write_commit_tree(&buffer, msg, msg_len, tree, parent_buf, nparents, author, committer, extra);
1724 if (sign_commit && sign_commit_to_strbuf(&sig, &buffer, sign_commit)) {
1725 result = -1;
1726 goto out;
1728 if (r->compat_hash_algo) {
1729 struct commit_extra_header *compat_extra = NULL;
1730 struct object_id mapped_tree;
1731 struct object_id *mapped_parents;
1733 CALLOC_ARRAY(mapped_parents, nparents);
1735 if (repo_oid_to_algop(r, tree, r->compat_hash_algo, &mapped_tree)) {
1736 result = -1;
1737 free(mapped_parents);
1738 goto out;
1740 for (i = 0; i < nparents; i++)
1741 if (repo_oid_to_algop(r, &parent_buf[i], r->compat_hash_algo, &mapped_parents[i])) {
1742 result = -1;
1743 free(mapped_parents);
1744 goto out;
1746 if (convert_commit_extra_headers(extra, &compat_extra)) {
1747 result = -1;
1748 free(mapped_parents);
1749 goto out;
1751 write_commit_tree(&compat_buffer, msg, msg_len, &mapped_tree,
1752 mapped_parents, nparents, author, committer, compat_extra);
1753 free_commit_extra_headers(compat_extra);
1754 free(mapped_parents);
1756 if (sign_commit && sign_commit_to_strbuf(&compat_sig, &compat_buffer, sign_commit)) {
1757 result = -1;
1758 goto out;
1762 if (sign_commit) {
1763 struct sig_pairs {
1764 struct strbuf *sig;
1765 const struct git_hash_algo *algo;
1766 } bufs [2] = {
1767 { &compat_sig, r->compat_hash_algo },
1768 { &sig, r->hash_algo },
1770 int i;
1773 * We write algorithms in the order they were implemented in
1774 * Git to produce a stable hash when multiple algorithms are
1775 * used.
1777 if (r->compat_hash_algo && hash_algo_by_ptr(bufs[0].algo) > hash_algo_by_ptr(bufs[1].algo))
1778 SWAP(bufs[0], bufs[1]);
1781 * We traverse each algorithm in order, and apply the signature
1782 * to each buffer.
1784 for (i = 0; i < ARRAY_SIZE(bufs); i++) {
1785 if (!bufs[i].algo)
1786 continue;
1787 add_header_signature(&buffer, bufs[i].sig, bufs[i].algo);
1788 if (r->compat_hash_algo)
1789 add_header_signature(&compat_buffer, bufs[i].sig, bufs[i].algo);
1793 /* And check the encoding. */
1794 if (encoding_is_utf8 && (!verify_utf8(&buffer) || !verify_utf8(&compat_buffer)))
1795 fprintf(stderr, _(commit_utf8_warn));
1797 if (r->compat_hash_algo) {
1798 hash_object_file(r->compat_hash_algo, compat_buffer.buf, compat_buffer.len,
1799 OBJ_COMMIT, &compat_oid_buf);
1800 compat_oid = &compat_oid_buf;
1803 result = write_object_file_flags(buffer.buf, buffer.len, OBJ_COMMIT,
1804 ret, compat_oid, 0);
1805 out:
1806 free(parent_buf);
1807 strbuf_release(&buffer);
1808 strbuf_release(&compat_buffer);
1809 strbuf_release(&sig);
1810 strbuf_release(&compat_sig);
1811 return result;
1814 define_commit_slab(merge_desc_slab, struct merge_remote_desc *);
1815 static struct merge_desc_slab merge_desc_slab = COMMIT_SLAB_INIT(1, merge_desc_slab);
1817 struct merge_remote_desc *merge_remote_util(struct commit *commit)
1819 return *merge_desc_slab_at(&merge_desc_slab, commit);
1822 void set_merge_remote_desc(struct commit *commit,
1823 const char *name, struct object *obj)
1825 struct merge_remote_desc *desc;
1826 FLEX_ALLOC_STR(desc, name, name);
1827 desc->obj = obj;
1828 *merge_desc_slab_at(&merge_desc_slab, commit) = desc;
1831 struct commit *get_merge_parent(const char *name)
1833 struct object *obj;
1834 struct commit *commit;
1835 struct object_id oid;
1836 if (repo_get_oid(the_repository, name, &oid))
1837 return NULL;
1838 obj = parse_object(the_repository, &oid);
1839 commit = (struct commit *)repo_peel_to_type(the_repository, name, 0,
1840 obj, OBJ_COMMIT);
1841 if (commit && !merge_remote_util(commit))
1842 set_merge_remote_desc(commit, name, obj);
1843 return commit;
1847 * Append a commit to the end of the commit_list.
1849 * next starts by pointing to the variable that holds the head of an
1850 * empty commit_list, and is updated to point to the "next" field of
1851 * the last item on the list as new commits are appended.
1853 * Usage example:
1855 * struct commit_list *list;
1856 * struct commit_list **next = &list;
1858 * next = commit_list_append(c1, next);
1859 * next = commit_list_append(c2, next);
1860 * assert(commit_list_count(list) == 2);
1861 * return list;
1863 struct commit_list **commit_list_append(struct commit *commit,
1864 struct commit_list **next)
1866 struct commit_list *new_commit = xmalloc(sizeof(struct commit_list));
1867 new_commit->item = commit;
1868 *next = new_commit;
1869 new_commit->next = NULL;
1870 return &new_commit->next;
1873 const char *find_header_mem(const char *msg, size_t len,
1874 const char *key, size_t *out_len)
1876 int key_len = strlen(key);
1877 const char *line = msg;
1880 * NEEDSWORK: It's possible for strchrnul() to scan beyond the range
1881 * given by len. However, current callers are safe because they compute
1882 * len by scanning a NUL-terminated block of memory starting at msg.
1883 * Nonetheless, it would be better to ensure the function does not look
1884 * at msg beyond the len provided by the caller.
1886 while (line && line < msg + len) {
1887 const char *eol = strchrnul(line, '\n');
1889 if (line == eol)
1890 return NULL;
1892 if (eol - line > key_len &&
1893 !strncmp(line, key, key_len) &&
1894 line[key_len] == ' ') {
1895 *out_len = eol - line - key_len - 1;
1896 return line + key_len + 1;
1898 line = *eol ? eol + 1 : NULL;
1900 return NULL;
1903 const char *find_commit_header(const char *msg, const char *key, size_t *out_len)
1905 return find_header_mem(msg, strlen(msg), key, out_len);
1908 * Inspect the given string and determine the true "end" of the log message, in
1909 * order to find where to put a new Signed-off-by trailer. Ignored are
1910 * trailing comment lines and blank lines. To support "git commit -s
1911 * --amend" on an existing commit, we also ignore "Conflicts:". To
1912 * support "git commit -v", we truncate at cut lines.
1914 * Returns the number of bytes from the tail to ignore, to be fed as
1915 * the second parameter to append_signoff().
1917 size_t ignored_log_message_bytes(const char *buf, size_t len)
1919 size_t boc = 0;
1920 size_t bol = 0;
1921 int in_old_conflicts_block = 0;
1922 size_t cutoff = wt_status_locate_end(buf, len);
1924 while (bol < cutoff) {
1925 const char *next_line = memchr(buf + bol, '\n', len - bol);
1927 if (!next_line)
1928 next_line = buf + len;
1929 else
1930 next_line++;
1932 if (starts_with_mem(buf + bol, cutoff - bol, comment_line_str) ||
1933 buf[bol] == '\n') {
1934 /* is this the first of the run of comments? */
1935 if (!boc)
1936 boc = bol;
1937 /* otherwise, it is just continuing */
1938 } else if (starts_with(buf + bol, "Conflicts:\n")) {
1939 in_old_conflicts_block = 1;
1940 if (!boc)
1941 boc = bol;
1942 } else if (in_old_conflicts_block && buf[bol] == '\t') {
1943 ; /* a pathname in the conflicts block */
1944 } else if (boc) {
1945 /* the previous was not trailing comment */
1946 boc = 0;
1947 in_old_conflicts_block = 0;
1949 bol = next_line - buf;
1951 return boc ? len - boc : len - cutoff;
1954 int run_commit_hook(int editor_is_used, const char *index_file,
1955 int *invoked_hook, const char *name, ...)
1957 struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT;
1958 va_list args;
1959 const char *arg;
1961 strvec_pushf(&opt.env, "GIT_INDEX_FILE=%s", index_file);
1964 * Let the hook know that no editor will be launched.
1966 if (!editor_is_used)
1967 strvec_push(&opt.env, "GIT_EDITOR=:");
1969 va_start(args, name);
1970 while ((arg = va_arg(args, const char *)))
1971 strvec_push(&opt.args, arg);
1972 va_end(args);
1974 opt.invoked_hook = invoked_hook;
1975 return run_hooks_opt(name, &opt);