Elijah Newren | d812c3b | 2023-04-11 00:41:56 -0700 | [diff] [blame] | 1 | #include "git-compat-util.h" |
Linus Torvalds | 961784e | 2005-05-18 16:14:22 -0700 | [diff] [blame] | 2 | #include "tag.h" |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 3 | #include "commit.h" |
Derrick Stolee | 177722b | 2018-04-10 08:56:05 -0400 | [diff] [blame] | 4 | #include "commit-graph.h" |
Elijah Newren | 7ee24e1 | 2023-03-21 06:25:57 +0000 | [diff] [blame] | 5 | #include "environment.h" |
Elijah Newren | f394e09 | 2023-03-21 06:25:54 +0000 | [diff] [blame] | 6 | #include "gettext.h" |
Elijah Newren | 41771fa | 2023-02-24 00:09:27 +0000 | [diff] [blame] | 7 | #include "hex.h" |
Jonathan Nieder | 6a1a79f | 2018-05-15 16:42:16 -0700 | [diff] [blame] | 8 | #include "repository.h" |
Elijah Newren | dabab1d | 2023-04-11 00:41:49 -0700 | [diff] [blame] | 9 | #include "object-name.h" |
Elijah Newren | a034e91 | 2023-05-16 06:34:06 +0000 | [diff] [blame] | 10 | #include "object-store-ll.h" |
Johannes Schindelin | ed09aef | 2006-10-30 20:09:06 +0100 | [diff] [blame] | 11 | #include "pkt-line.h" |
Junio C Hamano | 52883fb | 2006-12-25 11:48:35 -0800 | [diff] [blame] | 12 | #include "utf8.h" |
Junio C Hamano | 199c45b | 2007-04-09 02:34:05 -0700 | [diff] [blame] | 13 | #include "diff.h" |
| 14 | #include "revision.h" |
Johannes Schindelin | a97a746 | 2009-10-09 12:21:57 +0200 | [diff] [blame] | 15 | #include "notes.h" |
Stefan Beller | 14ba97f | 2018-05-15 14:48:42 -0700 | [diff] [blame] | 16 | #include "alloc.h" |
Junio C Hamano | ba3c69a | 2011-10-05 17:23:20 -0700 | [diff] [blame] | 17 | #include "gpg-interface.h" |
René Scharfe | 4690589 | 2012-04-01 00:10:39 +0200 | [diff] [blame] | 18 | #include "mergesort.h" |
Junio C Hamano | a84b794 | 2013-04-13 11:56:41 -0700 | [diff] [blame] | 19 | #include "commit-slab.h" |
Junio C Hamano | da24b10 | 2013-06-06 21:58:12 -0700 | [diff] [blame] | 20 | #include "prio-queue.h" |
Martin Ågren | bc62692 | 2020-12-31 12:56:23 +0100 | [diff] [blame] | 21 | #include "hash-lookup.h" |
Brian Malehorn | d76650b | 2017-05-15 23:06:49 -0700 | [diff] [blame] | 22 | #include "wt-status.h" |
Johannes Schindelin | f9f99b3 | 2018-04-29 00:44:44 +0200 | [diff] [blame] | 23 | #include "advice.h" |
Pratik Karki | 103148a | 2018-09-04 15:00:08 -0700 | [diff] [blame] | 24 | #include "refs.h" |
Junio C Hamano | 0293121 | 2018-11-02 11:04:55 +0900 | [diff] [blame] | 25 | #include "commit-reach.h" |
Phillip Wood | 49697cb | 2019-10-15 10:25:31 +0000 | [diff] [blame] | 26 | #include "run-command.h" |
Elijah Newren | e38da48 | 2023-03-21 06:26:05 +0000 | [diff] [blame] | 27 | #include "setup.h" |
Taylor Blau | 120ad2b | 2020-04-30 13:48:50 -0600 | [diff] [blame] | 28 | #include "shallow.h" |
Elijah Newren | d4a4f92 | 2023-04-22 20:17:26 +0000 | [diff] [blame] | 29 | #include "tree.h" |
Emily Shaffer | f443246 | 2021-12-22 04:59:40 +0100 | [diff] [blame] | 30 | #include "hook.h" |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 31 | |
Junio C Hamano | 82a7529 | 2012-09-15 13:58:15 -0700 | [diff] [blame] | 32 | static struct commit_extra_header *read_commit_extra_header_lines(const char *buf, size_t len, const char **); |
| 33 | |
Linus Torvalds | 60ab26d | 2005-09-15 14:43:17 -0700 | [diff] [blame] | 34 | int save_commit_buffer = 1; |
Ævar Arnfjörð Bjarmason | ab62858 | 2021-08-23 12:44:02 +0200 | [diff] [blame] | 35 | int no_graft_file_deprecated_advice; |
Linus Torvalds | 60ab26d | 2005-09-15 14:43:17 -0700 | [diff] [blame] | 36 | |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 37 | const char *commit_type = "commit"; |
| 38 | |
Stefan Beller | d9a05e7 | 2018-06-28 18:22:21 -0700 | [diff] [blame] | 39 | struct commit *lookup_commit_reference_gently(struct repository *r, |
Stefan Beller | 21e1ee8 | 2018-06-28 18:21:57 -0700 | [diff] [blame] | 40 | const struct object_id *oid, int quiet) |
Linus Torvalds | 961784e | 2005-05-18 16:14:22 -0700 | [diff] [blame] | 41 | { |
Stefan Beller | d9a05e7 | 2018-06-28 18:22:21 -0700 | [diff] [blame] | 42 | struct object *obj = deref_tag(r, |
| 43 | parse_object(r, oid), |
Stefan Beller | 109cd76 | 2018-06-28 18:21:51 -0700 | [diff] [blame] | 44 | NULL, 0); |
Linus Torvalds | 961784e | 2005-05-18 16:14:22 -0700 | [diff] [blame] | 45 | |
| 46 | if (!obj) |
| 47 | return NULL; |
Abhishek Kumar | 6da43d9 | 2020-06-17 14:44:08 +0530 | [diff] [blame] | 48 | return object_as_type(obj, OBJ_COMMIT, quiet); |
Junio C Hamano | f76412e | 2005-08-21 02:51:10 -0700 | [diff] [blame] | 49 | } |
| 50 | |
Stefan Beller | 1f6c72f | 2018-06-28 18:22:22 -0700 | [diff] [blame] | 51 | struct commit *lookup_commit_reference(struct repository *r, const struct object_id *oid) |
Junio C Hamano | f76412e | 2005-08-21 02:51:10 -0700 | [diff] [blame] | 52 | { |
Stefan Beller | 1f6c72f | 2018-06-28 18:22:22 -0700 | [diff] [blame] | 53 | return lookup_commit_reference_gently(r, oid, 0); |
Linus Torvalds | 961784e | 2005-05-18 16:14:22 -0700 | [diff] [blame] | 54 | } |
| 55 | |
brian m. carlson | bc83266 | 2017-05-06 22:10:10 +0000 | [diff] [blame] | 56 | struct commit *lookup_commit_or_die(const struct object_id *oid, const char *ref_name) |
Nguyễn Thái Ngọc Duy | baf18fc | 2011-09-17 21:57:45 +1000 | [diff] [blame] | 57 | { |
Stefan Beller | 2122f67 | 2018-06-28 18:21:58 -0700 | [diff] [blame] | 58 | struct commit *c = lookup_commit_reference(the_repository, oid); |
Nguyễn Thái Ngọc Duy | baf18fc | 2011-09-17 21:57:45 +1000 | [diff] [blame] | 59 | if (!c) |
| 60 | die(_("could not parse %s"), ref_name); |
Jeff King | 9001dc2 | 2018-08-28 17:22:48 -0400 | [diff] [blame] | 61 | if (!oideq(oid, &c->object.oid)) { |
Nguyễn Thái Ngọc Duy | baf18fc | 2011-09-17 21:57:45 +1000 | [diff] [blame] | 62 | warning(_("%s %s is not a commit!"), |
brian m. carlson | bc83266 | 2017-05-06 22:10:10 +0000 | [diff] [blame] | 63 | ref_name, oid_to_hex(oid)); |
Nguyễn Thái Ngọc Duy | baf18fc | 2011-09-17 21:57:45 +1000 | [diff] [blame] | 64 | } |
| 65 | return c; |
| 66 | } |
| 67 | |
Phillip Wood | b8dbfd0 | 2022-10-17 13:17:40 +0000 | [diff] [blame] | 68 | struct commit *lookup_commit_object(struct repository *r, |
| 69 | const struct object_id *oid) |
| 70 | { |
| 71 | struct object *obj = parse_object(r, oid); |
| 72 | return obj ? object_as_type(obj, OBJ_COMMIT, 0) : NULL; |
| 73 | |
| 74 | } |
| 75 | |
Stefan Beller | bacf168 | 2018-06-28 18:22:10 -0700 | [diff] [blame] | 76 | struct commit *lookup_commit(struct repository *r, const struct object_id *oid) |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 77 | { |
Jeff King | d0229ab | 2019-06-20 03:41:14 -0400 | [diff] [blame] | 78 | struct object *obj = lookup_object(r, oid); |
Jeff King | d36f51c | 2014-07-13 02:41:55 -0400 | [diff] [blame] | 79 | if (!obj) |
Jeff King | a378509 | 2019-06-20 03:41:21 -0400 | [diff] [blame] | 80 | return create_object(r, oid, alloc_commit_node(r)); |
Abhishek Kumar | 6da43d9 | 2020-06-17 14:44:08 +0530 | [diff] [blame] | 81 | return object_as_type(obj, OBJ_COMMIT, 0); |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 82 | } |
| 83 | |
Pat Notz | a6fa599 | 2010-11-02 13:59:07 -0600 | [diff] [blame] | 84 | struct commit *lookup_commit_reference_by_name(const char *name) |
| 85 | { |
brian m. carlson | 7683e2e | 2015-03-13 23:39:34 +0000 | [diff] [blame] | 86 | struct object_id oid; |
Pat Notz | a6fa599 | 2010-11-02 13:59:07 -0600 | [diff] [blame] | 87 | struct commit *commit; |
| 88 | |
Ævar Arnfjörð Bjarmason | d850b7a | 2023-03-28 15:58:46 +0200 | [diff] [blame] | 89 | if (repo_get_oid_committish(the_repository, name, &oid)) |
Pat Notz | a6fa599 | 2010-11-02 13:59:07 -0600 | [diff] [blame] | 90 | return NULL; |
Stefan Beller | 2122f67 | 2018-06-28 18:21:58 -0700 | [diff] [blame] | 91 | commit = lookup_commit_reference(the_repository, &oid); |
Ævar Arnfjörð Bjarmason | ecb5091 | 2023-03-28 15:58:48 +0200 | [diff] [blame] | 92 | if (repo_parse_commit(the_repository, commit)) |
Pat Notz | a6fa599 | 2010-11-02 13:59:07 -0600 | [diff] [blame] | 93 | return NULL; |
| 94 | return commit; |
| 95 | } |
| 96 | |
Johannes Schindelin | dddbad7 | 2017-04-26 21:29:31 +0200 | [diff] [blame] | 97 | static timestamp_t parse_commit_date(const char *buf, const char *tail) |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 98 | { |
Martin Koegler | 0a61779 | 2008-01-19 18:35:23 +0100 | [diff] [blame] | 99 | const char *dateptr; |
Jeff King | ea1615d | 2023-04-27 04:14:09 -0400 | [diff] [blame] | 100 | const char *eol; |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 101 | |
Martin Koegler | 0a61779 | 2008-01-19 18:35:23 +0100 | [diff] [blame] | 102 | if (buf + 6 >= tail) |
| 103 | return 0; |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 104 | if (memcmp(buf, "author", 6)) |
| 105 | return 0; |
Martin Koegler | 0a61779 | 2008-01-19 18:35:23 +0100 | [diff] [blame] | 106 | while (buf < tail && *buf++ != '\n') |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 107 | /* nada */; |
Martin Koegler | 0a61779 | 2008-01-19 18:35:23 +0100 | [diff] [blame] | 108 | if (buf + 9 >= tail) |
| 109 | return 0; |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 110 | if (memcmp(buf, "committer", 9)) |
| 111 | return 0; |
Jeff King | ea1615d | 2023-04-27 04:14:09 -0400 | [diff] [blame] | 112 | |
| 113 | /* |
| 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. |
| 118 | */ |
| 119 | eol = memchr(buf, '\n', tail - buf); |
| 120 | if (!eol) |
Martin Koegler | 0a61779 | 2008-01-19 18:35:23 +0100 | [diff] [blame] | 121 | return 0; |
Jeff King | ea1615d | 2023-04-27 04:14:09 -0400 | [diff] [blame] | 122 | dateptr = eol; |
| 123 | while (dateptr > buf && dateptr[-1] != '>') |
| 124 | dateptr--; |
Jeff King | 089d9ad | 2023-04-27 04:17:15 -0400 | [diff] [blame] | 125 | if (dateptr == buf) |
Martin Koegler | 0a61779 | 2008-01-19 18:35:23 +0100 | [diff] [blame] | 126 | return 0; |
Jeff King | ea1615d | 2023-04-27 04:14:09 -0400 | [diff] [blame] | 127 | |
Jeff King | 089d9ad | 2023-04-27 04:17:15 -0400 | [diff] [blame] | 128 | /* |
| 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. |
| 133 | * |
| 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. |
| 139 | * |
| 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. |
| 143 | */ |
| 144 | while (dateptr < eol && isspace(*dateptr)) |
| 145 | dateptr++; |
| 146 | if (!isdigit(*dateptr) && *dateptr != '-') |
| 147 | return 0; |
| 148 | |
| 149 | /* |
| 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. |
Jeff King | 90ef0f1 | 2023-04-27 04:17:24 -0400 | [diff] [blame] | 152 | * |
| 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. |
Jeff King | 089d9ad | 2023-04-27 04:17:15 -0400 | [diff] [blame] | 161 | */ |
Johannes Schindelin | 1aeb7e7 | 2017-04-21 12:45:44 +0200 | [diff] [blame] | 162 | return parse_timestamp(dateptr, NULL, 10); |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 163 | } |
| 164 | |
Jeff King | 8380dcd | 2021-01-28 01:20:23 -0500 | [diff] [blame] | 165 | static const struct object_id *commit_graft_oid_access(size_t index, const void *table) |
Dmitry S. Dolzhenko | 0a9136f | 2014-02-26 22:49:22 +0400 | [diff] [blame] | 166 | { |
Jeff King | 8380dcd | 2021-01-28 01:20:23 -0500 | [diff] [blame] | 167 | const struct commit_graft * const *commit_graft_table = table; |
Jeff King | 45ee13b | 2021-01-28 01:19:42 -0500 | [diff] [blame] | 168 | return &commit_graft_table[index]->oid; |
Dmitry S. Dolzhenko | 0a9136f | 2014-02-26 22:49:22 +0400 | [diff] [blame] | 169 | } |
| 170 | |
Jeff King | 98c431b | 2021-01-28 01:12:35 -0500 | [diff] [blame] | 171 | int commit_graft_pos(struct repository *r, const struct object_id *oid) |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 172 | { |
Jeff King | 45ee13b | 2021-01-28 01:19:42 -0500 | [diff] [blame] | 173 | return oid_pos(oid, r->parsed_objects->grafts, |
| 174 | r->parsed_objects->grafts_nr, |
| 175 | commit_graft_oid_access); |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 176 | } |
| 177 | |
Jonathan Tan | 4d4e49f | 2022-06-06 10:54:37 -0700 | [diff] [blame] | 178 | static void unparse_commit(struct repository *r, const struct object_id *oid) |
| 179 | { |
| 180 | struct commit *c = lookup_commit(r, oid); |
| 181 | |
| 182 | if (!c->object.parsed) |
| 183 | return; |
| 184 | free_commit_list(c->parents); |
| 185 | c->parents = NULL; |
| 186 | c->object.parsed = 0; |
| 187 | } |
| 188 | |
Brandon Williams | a3b78e8 | 2018-05-17 15:51:48 -0700 | [diff] [blame] | 189 | int register_commit_graft(struct repository *r, struct commit_graft *graft, |
| 190 | int ignore_dups) |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 191 | { |
Jeff King | 98c431b | 2021-01-28 01:12:35 -0500 | [diff] [blame] | 192 | int pos = commit_graft_pos(r, &graft->oid); |
Junio C Hamano | a6080a0 | 2007-06-07 00:04:01 -0700 | [diff] [blame] | 193 | |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 194 | if (0 <= pos) { |
| 195 | if (ignore_dups) |
| 196 | free(graft); |
| 197 | else { |
Brandon Williams | a3b78e8 | 2018-05-17 15:51:48 -0700 | [diff] [blame] | 198 | free(r->parsed_objects->grafts[pos]); |
| 199 | r->parsed_objects->grafts[pos] = graft; |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 200 | } |
| 201 | return 1; |
| 202 | } |
| 203 | pos = -pos - 1; |
Brandon Williams | a3b78e8 | 2018-05-17 15:51:48 -0700 | [diff] [blame] | 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; |
Jonathan Tan | 4d4e49f | 2022-06-06 10:54:37 -0700 | [diff] [blame] | 214 | unparse_commit(r, &graft->oid); |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 215 | return 0; |
| 216 | } |
| 217 | |
Patryk Obara | 9a93403 | 2017-08-18 20:33:12 +0200 | [diff] [blame] | 218 | struct commit_graft *read_graft_line(struct strbuf *line) |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 219 | { |
| 220 | /* The format is just "Commit Parent1 Parent2 ...\n" */ |
Patryk Obara | cfa5bf1 | 2017-08-18 20:33:14 +0200 | [diff] [blame] | 221 | int i, phase; |
| 222 | const char *tail = NULL; |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 223 | struct commit_graft *graft = NULL; |
Patryk Obara | cfa5bf1 | 2017-08-18 20:33:14 +0200 | [diff] [blame] | 224 | struct object_id dummy_oid, *oid; |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 225 | |
Patryk Obara | 9a93403 | 2017-08-18 20:33:12 +0200 | [diff] [blame] | 226 | strbuf_rtrim(line); |
| 227 | if (!line->len || line->buf[0] == '#') |
Junio C Hamano | 5bc4ce5 | 2006-04-16 14:24:56 -0700 | [diff] [blame] | 228 | return NULL; |
Patryk Obara | cfa5bf1 | 2017-08-18 20:33:14 +0200 | [diff] [blame] | 229 | /* |
| 230 | * phase 0 verifies line, counts hashes in line and allocates graft |
| 231 | * phase 1 fills graft |
| 232 | */ |
| 233 | for (phase = 0; phase < 2; phase++) { |
| 234 | oid = graft ? &graft->oid : &dummy_oid; |
| 235 | if (parse_oid_hex(line->buf, oid, &tail)) |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 236 | goto bad_graft_data; |
Patryk Obara | cfa5bf1 | 2017-08-18 20:33:14 +0200 | [diff] [blame] | 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; |
| 241 | } |
| 242 | if (!graft) { |
| 243 | graft = xmalloc(st_add(sizeof(*graft), |
| 244 | st_mult(sizeof(struct object_id), i))); |
| 245 | graft->nr_parent = i; |
| 246 | } |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 247 | } |
| 248 | return graft; |
Ralf Thielow | df5d43b | 2010-12-01 20:15:59 +0100 | [diff] [blame] | 249 | |
| 250 | bad_graft_data: |
Patryk Obara | 9a93403 | 2017-08-18 20:33:12 +0200 | [diff] [blame] | 251 | error("bad graft data: %s", line->buf); |
Patryk Obara | cfa5bf1 | 2017-08-18 20:33:14 +0200 | [diff] [blame] | 252 | assert(!graft); |
Ralf Thielow | df5d43b | 2010-12-01 20:15:59 +0100 | [diff] [blame] | 253 | return NULL; |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 254 | } |
| 255 | |
Brandon Williams | d0e5dd0 | 2018-05-17 15:51:49 -0700 | [diff] [blame] | 256 | static int read_graft_file(struct repository *r, const char *graft_file) |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 257 | { |
Nguyễn Thái Ngọc Duy | e9d983f | 2017-05-03 17:16:50 +0700 | [diff] [blame] | 258 | FILE *fp = fopen_or_warn(graft_file, "r"); |
Johannes Schindelin | e228c17 | 2013-12-27 21:49:57 +0100 | [diff] [blame] | 259 | struct strbuf buf = STRBUF_INIT; |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 260 | if (!fp) |
| 261 | return -1; |
Ævar Arnfjörð Bjarmason | ab62858 | 2021-08-23 12:44:02 +0200 | [diff] [blame] | 262 | if (!no_graft_file_deprecated_advice && |
| 263 | advice_enabled(ADVICE_GRAFT_FILE_DEPRECATED)) |
Johannes Schindelin | f9f99b3 | 2018-04-29 00:44:44 +0200 | [diff] [blame] | 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\"")); |
Johannes Schindelin | e228c17 | 2013-12-27 21:49:57 +0100 | [diff] [blame] | 272 | while (!strbuf_getwholeline(&buf, fp, '\n')) { |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 273 | /* The format is just "Commit Parent1 Parent2 ...\n" */ |
Patryk Obara | 9a93403 | 2017-08-18 20:33:12 +0200 | [diff] [blame] | 274 | struct commit_graft *graft = read_graft_line(&buf); |
Junio C Hamano | 5bc4ce5 | 2006-04-16 14:24:56 -0700 | [diff] [blame] | 275 | if (!graft) |
| 276 | continue; |
Brandon Williams | d0e5dd0 | 2018-05-17 15:51:49 -0700 | [diff] [blame] | 277 | if (register_commit_graft(r, graft, 1)) |
Johannes Schindelin | e228c17 | 2013-12-27 21:49:57 +0100 | [diff] [blame] | 278 | error("duplicate graft data: %s", buf.buf); |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 279 | } |
| 280 | fclose(fp); |
Johannes Schindelin | e228c17 | 2013-12-27 21:49:57 +0100 | [diff] [blame] | 281 | strbuf_release(&buf); |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 282 | return 0; |
| 283 | } |
| 284 | |
Derrick Stolee | 20fd6d5 | 2018-08-20 18:24:30 +0000 | [diff] [blame] | 285 | void prepare_commit_graft(struct repository *r) |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 286 | { |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 287 | char *graft_file; |
| 288 | |
Stefan Beller | 2f6c767 | 2018-05-17 15:51:53 -0700 | [diff] [blame] | 289 | if (r->parsed_objects->commit_graft_prepared) |
Junio C Hamano | 5040f17 | 2006-04-06 23:58:51 -0700 | [diff] [blame] | 290 | return; |
Jeff King | 14a9bd2 | 2018-05-31 18:42:53 -0400 | [diff] [blame] | 291 | if (!startup_info->have_repository) |
| 292 | return; |
| 293 | |
Stefan Beller | 2f6c767 | 2018-05-17 15:51:53 -0700 | [diff] [blame] | 294 | graft_file = get_graft_file(r); |
| 295 | read_graft_file(r, graft_file); |
Johannes Schindelin | ed09aef | 2006-10-30 20:09:06 +0100 | [diff] [blame] | 296 | /* make sure shallows are read */ |
Stefan Beller | 2f6c767 | 2018-05-17 15:51:53 -0700 | [diff] [blame] | 297 | is_repository_shallow(r); |
| 298 | r->parsed_objects->commit_graft_prepared = 1; |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 299 | } |
| 300 | |
Stefan Beller | b9dbddf | 2018-05-17 15:51:54 -0700 | [diff] [blame] | 301 | struct commit_graft *lookup_commit_graft(struct repository *r, const struct object_id *oid) |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 302 | { |
| 303 | int pos; |
Stefan Beller | b9dbddf | 2018-05-17 15:51:54 -0700 | [diff] [blame] | 304 | prepare_commit_graft(r); |
Jeff King | 98c431b | 2021-01-28 01:12:35 -0500 | [diff] [blame] | 305 | pos = commit_graft_pos(r, oid); |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 306 | if (pos < 0) |
| 307 | return NULL; |
Stefan Beller | b9dbddf | 2018-05-17 15:51:54 -0700 | [diff] [blame] | 308 | return r->parsed_objects->grafts[pos]; |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 309 | } |
| 310 | |
Nguyễn Thái Ngọc Duy | 09d4664 | 2011-08-18 19:29:35 +0700 | [diff] [blame] | 311 | int for_each_commit_graft(each_commit_graft_fn fn, void *cb_data) |
Johannes Schindelin | ed09aef | 2006-10-30 20:09:06 +0100 | [diff] [blame] | 312 | { |
Nguyễn Thái Ngọc Duy | 09d4664 | 2011-08-18 19:29:35 +0700 | [diff] [blame] | 313 | int i, ret; |
Jonathan Nieder | 6a1a79f | 2018-05-15 16:42:16 -0700 | [diff] [blame] | 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); |
Nguyễn Thái Ngọc Duy | 09d4664 | 2011-08-18 19:29:35 +0700 | [diff] [blame] | 316 | return ret; |
Johannes Schindelin | ed09aef | 2006-10-30 20:09:06 +0100 | [diff] [blame] | 317 | } |
| 318 | |
Jonathan Tan | 2a69ff0 | 2022-03-17 11:24:47 -0700 | [diff] [blame] | 319 | void reset_commit_grafts(struct repository *r) |
| 320 | { |
| 321 | int i; |
| 322 | |
Jonathan Tan | 4d4e49f | 2022-06-06 10:54:37 -0700 | [diff] [blame] | 323 | for (i = 0; i < r->parsed_objects->grafts_nr; i++) { |
| 324 | unparse_commit(r, &r->parsed_objects->grafts[i]->oid); |
Jonathan Tan | 2a69ff0 | 2022-03-17 11:24:47 -0700 | [diff] [blame] | 325 | free(r->parsed_objects->grafts[i]); |
Jonathan Tan | 4d4e49f | 2022-06-06 10:54:37 -0700 | [diff] [blame] | 326 | } |
Jonathan Tan | 2a69ff0 | 2022-03-17 11:24:47 -0700 | [diff] [blame] | 327 | r->parsed_objects->grafts_nr = 0; |
| 328 | r->parsed_objects->commit_graft_prepared = 0; |
| 329 | } |
| 330 | |
Jeff King | 8597ea3 | 2014-06-10 17:44:13 -0400 | [diff] [blame] | 331 | struct commit_buffer { |
| 332 | void *buffer; |
| 333 | unsigned long size; |
| 334 | }; |
| 335 | define_commit_slab(buffer_slab, struct commit_buffer); |
Jeff King | c1b3c71 | 2014-06-10 17:43:02 -0400 | [diff] [blame] | 336 | |
Stefan Beller | 65ea9d4 | 2018-06-28 18:22:15 -0700 | [diff] [blame] | 337 | struct buffer_slab *allocate_commit_buffer_slab(void) |
Jeff King | 66c2827 | 2014-06-10 17:40:14 -0400 | [diff] [blame] | 338 | { |
Stefan Beller | 65ea9d4 | 2018-06-28 18:22:15 -0700 | [diff] [blame] | 339 | struct buffer_slab *bs = xmalloc(sizeof(*bs)); |
| 340 | init_buffer_slab(bs); |
| 341 | return bs; |
| 342 | } |
| 343 | |
| 344 | void free_commit_buffer_slab(struct buffer_slab *bs) |
| 345 | { |
| 346 | clear_buffer_slab(bs); |
| 347 | free(bs); |
| 348 | } |
Johannes Schindelin | f53514b | 2006-10-30 20:09:53 +0100 | [diff] [blame] | 349 | |
Stefan Beller | 1a40fc4 | 2018-06-28 18:22:16 -0700 | [diff] [blame] | 350 | void set_commit_buffer(struct repository *r, struct commit *commit, void *buffer, unsigned long size) |
Jeff King | 66c2827 | 2014-06-10 17:40:14 -0400 | [diff] [blame] | 351 | { |
Stefan Beller | 65ea9d4 | 2018-06-28 18:22:15 -0700 | [diff] [blame] | 352 | struct commit_buffer *v = buffer_slab_at( |
Stefan Beller | 1a40fc4 | 2018-06-28 18:22:16 -0700 | [diff] [blame] | 353 | r->parsed_objects->buffer_slab, commit); |
Jeff King | 8597ea3 | 2014-06-10 17:44:13 -0400 | [diff] [blame] | 354 | v->buffer = buffer; |
| 355 | v->size = size; |
Jeff King | 66c2827 | 2014-06-10 17:40:14 -0400 | [diff] [blame] | 356 | } |
| 357 | |
Stefan Beller | 4ff7e5c | 2018-06-28 18:22:17 -0700 | [diff] [blame] | 358 | const void *get_cached_commit_buffer(struct repository *r, const struct commit *commit, unsigned long *sizep) |
Jeff King | 152ff1c | 2014-06-10 17:40:39 -0400 | [diff] [blame] | 359 | { |
Stefan Beller | 65ea9d4 | 2018-06-28 18:22:15 -0700 | [diff] [blame] | 360 | struct commit_buffer *v = buffer_slab_peek( |
Stefan Beller | 4ff7e5c | 2018-06-28 18:22:17 -0700 | [diff] [blame] | 361 | r->parsed_objects->buffer_slab, commit); |
Junio C Hamano | 862e730 | 2015-05-14 15:25:52 -0700 | [diff] [blame] | 362 | if (!v) { |
| 363 | if (sizep) |
| 364 | *sizep = 0; |
| 365 | return NULL; |
| 366 | } |
Jeff King | 8597ea3 | 2014-06-10 17:44:13 -0400 | [diff] [blame] | 367 | if (sizep) |
| 368 | *sizep = v->size; |
| 369 | return v->buffer; |
Jeff King | 152ff1c | 2014-06-10 17:40:39 -0400 | [diff] [blame] | 370 | } |
| 371 | |
Stefan Beller | 07de3fd | 2018-11-13 16:12:57 -0800 | [diff] [blame] | 372 | const void *repo_get_commit_buffer(struct repository *r, |
| 373 | const struct commit *commit, |
| 374 | unsigned long *sizep) |
Jeff King | 152ff1c | 2014-06-10 17:40:39 -0400 | [diff] [blame] | 375 | { |
Stefan Beller | 07de3fd | 2018-11-13 16:12:57 -0800 | [diff] [blame] | 376 | const void *ret = get_cached_commit_buffer(r, commit, sizep); |
Jeff King | 152ff1c | 2014-06-10 17:40:39 -0400 | [diff] [blame] | 377 | if (!ret) { |
| 378 | enum object_type type; |
| 379 | unsigned long size; |
Stefan Beller | 07de3fd | 2018-11-13 16:12:57 -0800 | [diff] [blame] | 380 | ret = repo_read_object_file(r, &commit->object.oid, &type, &size); |
Jeff King | 152ff1c | 2014-06-10 17:40:39 -0400 | [diff] [blame] | 381 | if (!ret) |
| 382 | die("cannot read commit object %s", |
brian m. carlson | f2fd076 | 2015-11-10 02:22:28 +0000 | [diff] [blame] | 383 | oid_to_hex(&commit->object.oid)); |
Jeff King | 152ff1c | 2014-06-10 17:40:39 -0400 | [diff] [blame] | 384 | if (type != OBJ_COMMIT) |
| 385 | die("expected commit for %s, got %s", |
Brandon Williams | debca9d | 2018-02-14 10:59:24 -0800 | [diff] [blame] | 386 | oid_to_hex(&commit->object.oid), type_name(type)); |
Jeff King | 8597ea3 | 2014-06-10 17:44:13 -0400 | [diff] [blame] | 387 | if (sizep) |
| 388 | *sizep = size; |
Jeff King | 152ff1c | 2014-06-10 17:40:39 -0400 | [diff] [blame] | 389 | } |
| 390 | return ret; |
| 391 | } |
| 392 | |
Stefan Beller | 7031537 | 2018-11-13 16:12:58 -0800 | [diff] [blame] | 393 | void repo_unuse_commit_buffer(struct repository *r, |
| 394 | const struct commit *commit, |
| 395 | const void *buffer) |
Jeff King | 152ff1c | 2014-06-10 17:40:39 -0400 | [diff] [blame] | 396 | { |
Stefan Beller | 65ea9d4 | 2018-06-28 18:22:15 -0700 | [diff] [blame] | 397 | struct commit_buffer *v = buffer_slab_peek( |
Stefan Beller | 7031537 | 2018-11-13 16:12:58 -0800 | [diff] [blame] | 398 | r->parsed_objects->buffer_slab, commit); |
Junio C Hamano | 862e730 | 2015-05-14 15:25:52 -0700 | [diff] [blame] | 399 | if (!(v && v->buffer == buffer)) |
Jeff King | 152ff1c | 2014-06-10 17:40:39 -0400 | [diff] [blame] | 400 | free((void *)buffer); |
| 401 | } |
| 402 | |
Stefan Beller | 6a7895f | 2018-12-14 16:09:40 -0800 | [diff] [blame] | 403 | void free_commit_buffer(struct parsed_object_pool *pool, struct commit *commit) |
Jeff King | 0fb370d | 2014-06-12 18:05:37 -0400 | [diff] [blame] | 404 | { |
Stefan Beller | 65ea9d4 | 2018-06-28 18:22:15 -0700 | [diff] [blame] | 405 | struct commit_buffer *v = buffer_slab_peek( |
Stefan Beller | 6a7895f | 2018-12-14 16:09:40 -0800 | [diff] [blame] | 406 | pool->buffer_slab, commit); |
Junio C Hamano | 862e730 | 2015-05-14 15:25:52 -0700 | [diff] [blame] | 407 | if (v) { |
Ævar Arnfjörð Bjarmason | 6a83d90 | 2017-06-15 23:15:46 +0000 | [diff] [blame] | 408 | FREE_AND_NULL(v->buffer); |
Junio C Hamano | 862e730 | 2015-05-14 15:25:52 -0700 | [diff] [blame] | 409 | v->size = 0; |
| 410 | } |
Jeff King | 0fb370d | 2014-06-12 18:05:37 -0400 | [diff] [blame] | 411 | } |
| 412 | |
Nguyễn Thái Ngọc Duy | a133c40 | 2019-04-16 16:33:18 +0700 | [diff] [blame] | 413 | static inline void set_commit_tree(struct commit *c, struct tree *t) |
| 414 | { |
| 415 | c->maybe_tree = t; |
| 416 | } |
| 417 | |
Nguyễn Thái Ngọc Duy | 301b8c7 | 2019-04-16 16:33:19 +0700 | [diff] [blame] | 418 | struct tree *repo_get_commit_tree(struct repository *r, |
| 419 | const struct commit *commit) |
Derrick Stolee | 5bb03de | 2018-04-06 19:09:34 +0000 | [diff] [blame] | 420 | { |
Derrick Stolee | 7b8a21d | 2018-04-06 19:09:46 +0000 | [diff] [blame] | 421 | if (commit->maybe_tree || !commit->object.parsed) |
| 422 | return commit->maybe_tree; |
| 423 | |
Abhishek Kumar | c49c82a | 2020-06-17 14:44:10 +0530 | [diff] [blame] | 424 | if (commit_graph_position(commit) != COMMIT_NOT_FROM_GRAPH) |
Junio C Hamano | ea2dab1 | 2019-05-09 00:37:25 +0900 | [diff] [blame] | 425 | return get_commit_tree_in_graph(r, commit); |
Derrick Stolee | 7b8a21d | 2018-04-06 19:09:46 +0000 | [diff] [blame] | 426 | |
Jeff King | 8348766 | 2019-04-09 19:13:20 -0700 | [diff] [blame] | 427 | return NULL; |
Derrick Stolee | 5bb03de | 2018-04-06 19:09:34 +0000 | [diff] [blame] | 428 | } |
| 429 | |
| 430 | struct object_id *get_commit_tree_oid(const struct commit *commit) |
| 431 | { |
Ævar Arnfjörð Bjarmason | ecb5091 | 2023-03-28 15:58:48 +0200 | [diff] [blame] | 432 | struct tree *tree = repo_get_commit_tree(the_repository, commit); |
Taylor Blau | 806278d | 2019-09-05 18:04:57 -0400 | [diff] [blame] | 433 | return tree ? &tree->object.oid : NULL; |
Derrick Stolee | 5bb03de | 2018-04-06 19:09:34 +0000 | [diff] [blame] | 434 | } |
| 435 | |
Stefan Beller | 6a7895f | 2018-12-14 16:09:40 -0800 | [diff] [blame] | 436 | void release_commit_memory(struct parsed_object_pool *pool, struct commit *c) |
Stefan Beller | 14ba97f | 2018-05-15 14:48:42 -0700 | [diff] [blame] | 437 | { |
Nguyễn Thái Ngọc Duy | a133c40 | 2019-04-16 16:33:18 +0700 | [diff] [blame] | 438 | set_commit_tree(c, NULL); |
Stefan Beller | 6a7895f | 2018-12-14 16:09:40 -0800 | [diff] [blame] | 439 | free_commit_buffer(pool, c); |
Mike Hommey | 9784f97 | 2019-08-26 11:01:37 +0900 | [diff] [blame] | 440 | c->index = 0; |
Stefan Beller | 14ba97f | 2018-05-15 14:48:42 -0700 | [diff] [blame] | 441 | free_commit_list(c->parents); |
Stefan Beller | 14ba97f | 2018-05-15 14:48:42 -0700 | [diff] [blame] | 442 | |
| 443 | c->object.parsed = 0; |
| 444 | } |
| 445 | |
Jeff King | 8597ea3 | 2014-06-10 17:44:13 -0400 | [diff] [blame] | 446 | const void *detach_commit_buffer(struct commit *commit, unsigned long *sizep) |
Jeff King | 0fb370d | 2014-06-12 18:05:37 -0400 | [diff] [blame] | 447 | { |
Stefan Beller | 65ea9d4 | 2018-06-28 18:22:15 -0700 | [diff] [blame] | 448 | struct commit_buffer *v = buffer_slab_peek( |
| 449 | the_repository->parsed_objects->buffer_slab, commit); |
Jeff King | 8597ea3 | 2014-06-10 17:44:13 -0400 | [diff] [blame] | 450 | void *ret; |
| 451 | |
Junio C Hamano | 862e730 | 2015-05-14 15:25:52 -0700 | [diff] [blame] | 452 | if (!v) { |
| 453 | if (sizep) |
| 454 | *sizep = 0; |
| 455 | return NULL; |
| 456 | } |
Jeff King | 8597ea3 | 2014-06-10 17:44:13 -0400 | [diff] [blame] | 457 | ret = v->buffer; |
| 458 | if (sizep) |
| 459 | *sizep = v->size; |
| 460 | |
| 461 | v->buffer = NULL; |
| 462 | v->size = 0; |
Jeff King | 0fb370d | 2014-06-12 18:05:37 -0400 | [diff] [blame] | 463 | return ret; |
| 464 | } |
| 465 | |
Stefan Beller | fd8030c | 2018-06-28 18:22:13 -0700 | [diff] [blame] | 466 | int parse_commit_buffer(struct repository *r, struct commit *item, const void *buffer, unsigned long size, int check_graph) |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 467 | { |
Nguyễn Thái Ngọc Duy | cf7b1ca | 2011-02-05 17:52:20 +0700 | [diff] [blame] | 468 | const char *tail = buffer; |
| 469 | const char *bufptr = buffer; |
brian m. carlson | 7683e2e | 2015-03-13 23:39:34 +0000 | [diff] [blame] | 470 | struct object_id parent; |
Linus Torvalds | 6c88be1 | 2005-06-20 20:26:03 -0700 | [diff] [blame] | 471 | struct commit_list **pptr; |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 472 | struct commit_graft *graft; |
brian m. carlson | 2770ccb | 2018-07-16 01:27:56 +0000 | [diff] [blame] | 473 | const int tree_entry_len = the_hash_algo->hexsz + 5; |
| 474 | const int parent_entry_len = the_hash_algo->hexsz + 7; |
Jeff King | 12736d2 | 2019-10-18 00:43:29 -0400 | [diff] [blame] | 475 | struct tree *tree; |
Nicolas Pitre | bd2c39f | 2005-05-06 13:48:34 -0400 | [diff] [blame] | 476 | |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 477 | if (item->object.parsed) |
| 478 | return 0; |
Ævar Arnfjörð Bjarmason | bf20fe4 | 2022-04-13 22:01:34 +0200 | [diff] [blame] | 479 | /* |
| 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. |
| 484 | */ |
| 485 | free_commit_list(item->parents); |
| 486 | item->parents = NULL; |
Jeff King | 228c78f | 2019-10-25 17:20:20 -0400 | [diff] [blame] | 487 | |
Junio C Hamano | 3b44f15 | 2006-06-28 03:51:00 -0700 | [diff] [blame] | 488 | tail += size; |
brian m. carlson | 7683e2e | 2015-03-13 23:39:34 +0000 | [diff] [blame] | 489 | if (tail <= bufptr + tree_entry_len + 1 || memcmp(bufptr, "tree ", 5) || |
| 490 | bufptr[tree_entry_len] != '\n') |
brian m. carlson | f2fd076 | 2015-11-10 02:22:28 +0000 | [diff] [blame] | 491 | return error("bogus commit object %s", oid_to_hex(&item->object.oid)); |
brian m. carlson | 26ea3e7 | 2018-05-02 00:25:47 +0000 | [diff] [blame] | 492 | if (get_oid_hex(bufptr + 5, &parent) < 0) |
Junio C Hamano | bd2afde | 2006-02-22 17:47:10 -0800 | [diff] [blame] | 493 | return error("bad tree pointer in commit %s", |
brian m. carlson | f2fd076 | 2015-11-10 02:22:28 +0000 | [diff] [blame] | 494 | oid_to_hex(&item->object.oid)); |
Jeff King | 12736d2 | 2019-10-18 00:43:29 -0400 | [diff] [blame] | 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); |
brian m. carlson | 7683e2e | 2015-03-13 23:39:34 +0000 | [diff] [blame] | 501 | bufptr += tree_entry_len + 1; /* "tree " + "hex sha1" + "\n" */ |
Linus Torvalds | 6c88be1 | 2005-06-20 20:26:03 -0700 | [diff] [blame] | 502 | pptr = &item->parents; |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 503 | |
Stefan Beller | fd8030c | 2018-06-28 18:22:13 -0700 | [diff] [blame] | 504 | graft = lookup_commit_graft(r, &item->object.oid); |
Taylor Blau | ce16364 | 2020-07-08 17:10:53 -0400 | [diff] [blame] | 505 | if (graft) |
| 506 | r->parsed_objects->substituted_parent = 1; |
brian m. carlson | 7683e2e | 2015-03-13 23:39:34 +0000 | [diff] [blame] | 507 | while (bufptr + parent_entry_len < tail && !memcmp(bufptr, "parent ", 7)) { |
Linus Torvalds | f7cc77d | 2005-07-27 15:12:48 -0700 | [diff] [blame] | 508 | struct commit *new_parent; |
| 509 | |
brian m. carlson | 7683e2e | 2015-03-13 23:39:34 +0000 | [diff] [blame] | 510 | if (tail <= bufptr + parent_entry_len + 1 || |
brian m. carlson | 26ea3e7 | 2018-05-02 00:25:47 +0000 | [diff] [blame] | 511 | get_oid_hex(bufptr + 7, &parent) || |
brian m. carlson | 7683e2e | 2015-03-13 23:39:34 +0000 | [diff] [blame] | 512 | bufptr[parent_entry_len] != '\n') |
brian m. carlson | f2fd076 | 2015-11-10 02:22:28 +0000 | [diff] [blame] | 513 | return error("bad parents in commit %s", oid_to_hex(&item->object.oid)); |
brian m. carlson | 7683e2e | 2015-03-13 23:39:34 +0000 | [diff] [blame] | 514 | bufptr += parent_entry_len + 1; |
Johannes Schindelin | 7f3140c | 2009-07-23 17:33:49 +0200 | [diff] [blame] | 515 | /* |
| 516 | * The clone is shallow if nr_parent < 0, and we must |
| 517 | * not traverse its real parents even when we unhide them. |
| 518 | */ |
René Scharfe | 3a5f308 | 2023-07-21 14:41:56 +0200 | [diff] [blame] | 519 | if (graft && (graft->nr_parent < 0 || !grafts_keep_true_parents)) |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 520 | continue; |
Stefan Beller | fd8030c | 2018-06-28 18:22:13 -0700 | [diff] [blame] | 521 | new_parent = lookup_commit(r, &parent); |
Jeff King | c78fe00 | 2019-10-18 00:42:13 -0400 | [diff] [blame] | 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; |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 527 | } |
| 528 | if (graft) { |
| 529 | int i; |
| 530 | struct commit *new_parent; |
| 531 | for (i = 0; i < graft->nr_parent; i++) { |
Stefan Beller | fd8030c | 2018-06-28 18:22:13 -0700 | [diff] [blame] | 532 | new_parent = lookup_commit(r, |
Stefan Beller | c1f5eb4 | 2018-06-28 18:21:59 -0700 | [diff] [blame] | 533 | &graft->parent[i]); |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 534 | if (!new_parent) |
Jeff King | c78fe00 | 2019-10-18 00:42:13 -0400 | [diff] [blame] | 535 | return error("bad graft parent %s in commit %s", |
| 536 | oid_to_hex(&graft->parent[i]), |
| 537 | oid_to_hex(&item->object.oid)); |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 538 | pptr = &commit_list_insert(new_parent, pptr)->next; |
Junio C Hamano | 5da5c8f | 2005-07-30 00:58:28 -0700 | [diff] [blame] | 539 | } |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 540 | } |
Martin Koegler | 0a61779 | 2008-01-19 18:35:23 +0100 | [diff] [blame] | 541 | item->date = parse_commit_date(bufptr, tail); |
Junio C Hamano | 27dedf0 | 2005-11-16 21:32:44 -0800 | [diff] [blame] | 542 | |
Derrick Stolee | e2838d8 | 2018-05-01 12:47:13 +0000 | [diff] [blame] | 543 | if (check_graph) |
Derrick Stolee | c794405 | 2019-05-09 07:22:31 -0700 | [diff] [blame] | 544 | load_commit_graph_info(r, item); |
Derrick Stolee | e2838d8 | 2018-05-01 12:47:13 +0000 | [diff] [blame] | 545 | |
Jeff King | 228c78f | 2019-10-25 17:20:20 -0400 | [diff] [blame] | 546 | item->object.parsed = 1; |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 547 | return 0; |
| 548 | } |
| 549 | |
Stefan Beller | 9e5252a | 2018-11-13 16:12:50 -0800 | [diff] [blame] | 550 | int repo_parse_commit_internal(struct repository *r, |
| 551 | struct commit *item, |
| 552 | int quiet_on_missing, |
| 553 | int use_commit_graph) |
Nicolas Pitre | bd2c39f | 2005-05-06 13:48:34 -0400 | [diff] [blame] | 554 | { |
Nicolas Pitre | 21666f1 | 2007-02-26 14:55:59 -0500 | [diff] [blame] | 555 | enum object_type type; |
Nicolas Pitre | bd2c39f | 2005-05-06 13:48:34 -0400 | [diff] [blame] | 556 | void *buffer; |
| 557 | unsigned long size; |
Jonathan Tan | 7e2ad1c | 2022-12-14 11:17:43 -0800 | [diff] [blame] | 558 | struct object_info oi = { |
| 559 | .typep = &type, |
| 560 | .sizep = &size, |
| 561 | .contentp = &buffer, |
| 562 | }; |
| 563 | /* |
| 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. |
| 566 | */ |
| 567 | int flags = OBJECT_INFO_LOOKUP_REPLACE | OBJECT_INFO_SKIP_FETCH_OBJECT | |
| 568 | OBJECT_INFO_DIE_IF_CORRUPT; |
Nicolas Pitre | bd2c39f | 2005-05-06 13:48:34 -0400 | [diff] [blame] | 569 | int ret; |
| 570 | |
Martin Koegler | 9786f68 | 2008-02-18 21:48:02 +0100 | [diff] [blame] | 571 | if (!item) |
| 572 | return -1; |
Nicolas Pitre | bd2c39f | 2005-05-06 13:48:34 -0400 | [diff] [blame] | 573 | if (item->object.parsed) |
| 574 | return 0; |
Stefan Beller | 9e5252a | 2018-11-13 16:12:50 -0800 | [diff] [blame] | 575 | if (use_commit_graph && parse_commit_in_graph(r, item)) |
Derrick Stolee | 177722b | 2018-04-10 08:56:05 -0400 | [diff] [blame] | 576 | return 0; |
Jonathan Tan | 7e2ad1c | 2022-12-14 11:17:43 -0800 | [diff] [blame] | 577 | |
| 578 | if (oid_object_info_extended(r, &item->object.oid, &oi, flags) < 0) |
Jeff King | 9cc2b07 | 2015-06-01 05:56:26 -0400 | [diff] [blame] | 579 | return quiet_on_missing ? -1 : |
| 580 | error("Could not read %s", |
brian m. carlson | f2fd076 | 2015-11-10 02:22:28 +0000 | [diff] [blame] | 581 | oid_to_hex(&item->object.oid)); |
Nicolas Pitre | 21666f1 | 2007-02-26 14:55:59 -0500 | [diff] [blame] | 582 | if (type != OBJ_COMMIT) { |
Nicolas Pitre | bd2c39f | 2005-05-06 13:48:34 -0400 | [diff] [blame] | 583 | free(buffer); |
| 584 | return error("Object %s not a commit", |
brian m. carlson | f2fd076 | 2015-11-10 02:22:28 +0000 | [diff] [blame] | 585 | oid_to_hex(&item->object.oid)); |
Nicolas Pitre | bd2c39f | 2005-05-06 13:48:34 -0400 | [diff] [blame] | 586 | } |
Derrick Stolee | 9b19ada | 2018-06-27 09:24:30 -0400 | [diff] [blame] | 587 | |
Stefan Beller | 9e5252a | 2018-11-13 16:12:50 -0800 | [diff] [blame] | 588 | ret = parse_commit_buffer(r, item, buffer, size, 0); |
Linus Torvalds | 60ab26d | 2005-09-15 14:43:17 -0700 | [diff] [blame] | 589 | if (save_commit_buffer && !ret) { |
Stefan Beller | 9e5252a | 2018-11-13 16:12:50 -0800 | [diff] [blame] | 590 | set_commit_buffer(r, item, buffer, size); |
Linus Torvalds | 3ff1fbb | 2005-05-25 18:27:14 -0700 | [diff] [blame] | 591 | return 0; |
| 592 | } |
Nicolas Pitre | bd2c39f | 2005-05-06 13:48:34 -0400 | [diff] [blame] | 593 | free(buffer); |
| 594 | return ret; |
| 595 | } |
| 596 | |
Stefan Beller | 9e5252a | 2018-11-13 16:12:50 -0800 | [diff] [blame] | 597 | int repo_parse_commit_gently(struct repository *r, |
| 598 | struct commit *item, int quiet_on_missing) |
Derrick Stolee | 9b19ada | 2018-06-27 09:24:30 -0400 | [diff] [blame] | 599 | { |
Stefan Beller | 9e5252a | 2018-11-13 16:12:50 -0800 | [diff] [blame] | 600 | return repo_parse_commit_internal(r, item, quiet_on_missing, 1); |
Derrick Stolee | 9b19ada | 2018-06-27 09:24:30 -0400 | [diff] [blame] | 601 | } |
| 602 | |
Jeff King | 7059dcc | 2013-10-24 04:52:36 -0400 | [diff] [blame] | 603 | void parse_commit_or_die(struct commit *item) |
| 604 | { |
Ævar Arnfjörð Bjarmason | ecb5091 | 2023-03-28 15:58:48 +0200 | [diff] [blame] | 605 | if (repo_parse_commit(the_repository, item)) |
Jeff King | 7059dcc | 2013-10-24 04:52:36 -0400 | [diff] [blame] | 606 | die("unable to parse commit %s", |
brian m. carlson | f2fd076 | 2015-11-10 02:22:28 +0000 | [diff] [blame] | 607 | item ? oid_to_hex(&item->object.oid) : "(null)"); |
Jeff King | 7059dcc | 2013-10-24 04:52:36 -0400 | [diff] [blame] | 608 | } |
| 609 | |
Christian Couder | 11af2aa | 2010-07-22 15:18:30 +0200 | [diff] [blame] | 610 | int find_commit_subject(const char *commit_buffer, const char **subject) |
| 611 | { |
| 612 | const char *eol; |
| 613 | const char *p = commit_buffer; |
| 614 | |
| 615 | while (*p && (*p != '\n' || p[1] != '\n')) |
| 616 | p++; |
| 617 | if (*p) { |
Johannes Schindelin | 4e1b06d | 2016-06-22 22:20:20 +0200 | [diff] [blame] | 618 | p = skip_blank_lines(p + 2); |
Junio C Hamano | 9c9b03b | 2017-01-27 18:01:41 -0800 | [diff] [blame] | 619 | eol = strchrnul(p, '\n'); |
Christian Couder | 11af2aa | 2010-07-22 15:18:30 +0200 | [diff] [blame] | 620 | } else |
| 621 | eol = p; |
| 622 | |
| 623 | *subject = p; |
| 624 | |
| 625 | return eol - p; |
| 626 | } |
| 627 | |
Charvi Mendiratta | 6e0e288 | 2021-03-15 13:24:31 +0530 | [diff] [blame] | 628 | size_t commit_subject_length(const char *body) |
| 629 | { |
| 630 | const char *p = body; |
| 631 | while (*p) { |
| 632 | const char *next = skip_blank_lines(p); |
| 633 | if (next != p) |
| 634 | break; |
| 635 | p = strchrnul(p, '\n'); |
| 636 | if (*p) |
| 637 | p++; |
| 638 | } |
| 639 | return p - body; |
| 640 | } |
| 641 | |
Linus Torvalds | ac5155e | 2005-05-30 18:44:02 -0700 | [diff] [blame] | 642 | struct commit_list *commit_list_insert(struct commit *item, struct commit_list **list_p) |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 643 | { |
Christopher Li | 812666c | 2005-04-26 12:00:58 -0700 | [diff] [blame] | 644 | struct commit_list *new_list = xmalloc(sizeof(struct commit_list)); |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 645 | new_list->item = item; |
| 646 | new_list->next = *list_p; |
| 647 | *list_p = new_list; |
Linus Torvalds | ac5155e | 2005-05-30 18:44:02 -0700 | [diff] [blame] | 648 | return new_list; |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 649 | } |
| 650 | |
Derrick Stolee | 597b2c3 | 2020-12-08 17:04:13 -0500 | [diff] [blame] | 651 | int commit_list_contains(struct commit *item, struct commit_list *list) |
| 652 | { |
| 653 | while (list) { |
| 654 | if (list->item == item) |
| 655 | return 1; |
| 656 | list = list->next; |
| 657 | } |
| 658 | |
| 659 | return 0; |
| 660 | } |
| 661 | |
Miklos Vajna | 6531947 | 2008-06-27 18:21:55 +0200 | [diff] [blame] | 662 | unsigned commit_list_count(const struct commit_list *l) |
| 663 | { |
| 664 | unsigned c = 0; |
| 665 | for (; l; l = l->next ) |
| 666 | c++; |
| 667 | return c; |
| 668 | } |
| 669 | |
Thomas Rast | 53d00b3 | 2013-07-31 22:13:20 +0200 | [diff] [blame] | 670 | struct commit_list *copy_commit_list(struct commit_list *list) |
| 671 | { |
| 672 | struct commit_list *head = NULL; |
| 673 | struct commit_list **pp = &head; |
| 674 | while (list) { |
René Scharfe | cb979db | 2014-07-10 11:47:47 +0200 | [diff] [blame] | 675 | pp = commit_list_append(list->item, pp); |
Thomas Rast | 53d00b3 | 2013-07-31 22:13:20 +0200 | [diff] [blame] | 676 | list = list->next; |
| 677 | } |
| 678 | return head; |
| 679 | } |
| 680 | |
Elijah Newren | b0ca120 | 2020-12-16 22:27:59 +0000 | [diff] [blame] | 681 | struct commit_list *reverse_commit_list(struct commit_list *list) |
| 682 | { |
| 683 | struct commit_list *next = NULL, *current, *backup; |
| 684 | for (current = list; current; current = backup) { |
| 685 | backup = current->next; |
| 686 | current->next = next; |
| 687 | next = current; |
| 688 | } |
| 689 | return next; |
| 690 | } |
| 691 | |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 692 | void free_commit_list(struct commit_list *list) |
| 693 | { |
René Scharfe | e510ab8 | 2015-10-24 18:21:31 +0200 | [diff] [blame] | 694 | while (list) |
| 695 | pop_commit(&list); |
Daniel Barkalow | 175785e | 2005-04-18 11:39:48 -0700 | [diff] [blame] | 696 | } |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 697 | |
Thiago Farina | 47e44ed | 2010-11-26 23:58:14 -0200 | [diff] [blame] | 698 | struct commit_list * commit_list_insert_by_date(struct commit *item, struct commit_list **list) |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 699 | { |
| 700 | struct commit_list **pp = list; |
| 701 | struct commit_list *p; |
| 702 | while ((p = *pp) != NULL) { |
| 703 | if (p->item->date < item->date) { |
| 704 | break; |
| 705 | } |
| 706 | pp = &p->next; |
| 707 | } |
Linus Torvalds | f755494 | 2005-07-06 09:31:17 -0700 | [diff] [blame] | 708 | return commit_list_insert(item, pp); |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 709 | } |
| 710 | |
René Scharfe | c0fb577 | 2022-07-16 18:59:05 +0200 | [diff] [blame] | 711 | static int commit_list_compare_by_date(const struct commit_list *a, |
| 712 | const struct commit_list *b) |
René Scharfe | 4690589 | 2012-04-01 00:10:39 +0200 | [diff] [blame] | 713 | { |
René Scharfe | c0fb577 | 2022-07-16 18:59:05 +0200 | [diff] [blame] | 714 | timestamp_t a_date = a->item->date; |
| 715 | timestamp_t b_date = b->item->date; |
René Scharfe | 4690589 | 2012-04-01 00:10:39 +0200 | [diff] [blame] | 716 | if (a_date < b_date) |
| 717 | return 1; |
| 718 | if (a_date > b_date) |
| 719 | return -1; |
| 720 | return 0; |
| 721 | } |
| 722 | |
René Scharfe | c0fb577 | 2022-07-16 18:59:05 +0200 | [diff] [blame] | 723 | DEFINE_LIST_SORT(static, commit_list_sort, struct commit_list, next); |
Junio C Hamano | a6080a0 | 2007-06-07 00:04:01 -0700 | [diff] [blame] | 724 | |
Thiago Farina | 47e44ed | 2010-11-26 23:58:14 -0200 | [diff] [blame] | 725 | void commit_list_sort_by_date(struct commit_list **list) |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 726 | { |
René Scharfe | c0fb577 | 2022-07-16 18:59:05 +0200 | [diff] [blame] | 727 | commit_list_sort(list, commit_list_compare_by_date); |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 728 | } |
| 729 | |
Daniel Barkalow | 58e28af | 2005-04-23 20:29:22 -0700 | [diff] [blame] | 730 | struct commit *pop_most_recent_commit(struct commit_list **list, |
| 731 | unsigned int mark) |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 732 | { |
René Scharfe | e510ab8 | 2015-10-24 18:21:31 +0200 | [diff] [blame] | 733 | struct commit *ret = pop_commit(list); |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 734 | struct commit_list *parents = ret->parents; |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 735 | |
| 736 | while (parents) { |
Linus Torvalds | 4056c09 | 2005-04-23 19:21:28 -0700 | [diff] [blame] | 737 | struct commit *commit = parents->item; |
Ævar Arnfjörð Bjarmason | ecb5091 | 2023-03-28 15:58:48 +0200 | [diff] [blame] | 738 | if (!repo_parse_commit(the_repository, commit) && !(commit->object.flags & mark)) { |
Daniel Barkalow | 58e28af | 2005-04-23 20:29:22 -0700 | [diff] [blame] | 739 | commit->object.flags |= mark; |
Thiago Farina | 47e44ed | 2010-11-26 23:58:14 -0200 | [diff] [blame] | 740 | commit_list_insert_by_date(commit, list); |
Linus Torvalds | 4056c09 | 2005-04-23 19:21:28 -0700 | [diff] [blame] | 741 | } |
Daniel Barkalow | dd97f85 | 2005-04-23 18:47:23 -0700 | [diff] [blame] | 742 | parents = parents->next; |
| 743 | } |
| 744 | return ret; |
| 745 | } |
Linus Torvalds | e3bc7a3 | 2005-06-01 08:34:23 -0700 | [diff] [blame] | 746 | |
Nguyễn Thái Ngọc Duy | 941ba8d | 2012-01-14 19:19:53 +0700 | [diff] [blame] | 747 | static void clear_commit_marks_1(struct commit_list **plist, |
| 748 | struct commit *commit, unsigned int mark) |
Junio C Hamano | f8f9c73 | 2006-01-07 18:52:42 -0800 | [diff] [blame] | 749 | { |
Johannes Schindelin | 60fcc2e | 2007-10-10 23:14:35 +0100 | [diff] [blame] | 750 | while (commit) { |
| 751 | struct commit_list *parents; |
Junio C Hamano | f8f9c73 | 2006-01-07 18:52:42 -0800 | [diff] [blame] | 752 | |
Johannes Schindelin | 60fcc2e | 2007-10-10 23:14:35 +0100 | [diff] [blame] | 753 | if (!(mark & commit->object.flags)) |
| 754 | return; |
Junio C Hamano | 58ecf5c | 2006-07-04 17:45:22 -0700 | [diff] [blame] | 755 | |
Johannes Schindelin | 60fcc2e | 2007-10-10 23:14:35 +0100 | [diff] [blame] | 756 | commit->object.flags &= ~mark; |
| 757 | |
| 758 | parents = commit->parents; |
| 759 | if (!parents) |
| 760 | return; |
| 761 | |
René Scharfe | 4cb39fc | 2022-12-13 07:27:10 +0100 | [diff] [blame] | 762 | while ((parents = parents->next)) { |
| 763 | if (parents->item->object.flags & mark) |
| 764 | commit_list_insert(parents->item, plist); |
| 765 | } |
Johannes Schindelin | 60fcc2e | 2007-10-10 23:14:35 +0100 | [diff] [blame] | 766 | |
| 767 | commit = commit->parents->item; |
Junio C Hamano | f8f9c73 | 2006-01-07 18:52:42 -0800 | [diff] [blame] | 768 | } |
| 769 | } |
| 770 | |
Junio C Hamano | e895cb5 | 2013-03-05 11:42:20 -0800 | [diff] [blame] | 771 | void clear_commit_marks_many(int nr, struct commit **commit, unsigned int mark) |
Nguyễn Thái Ngọc Duy | 941ba8d | 2012-01-14 19:19:53 +0700 | [diff] [blame] | 772 | { |
| 773 | struct commit_list *list = NULL; |
Junio C Hamano | e895cb5 | 2013-03-05 11:42:20 -0800 | [diff] [blame] | 774 | |
| 775 | while (nr--) { |
René Scharfe | 07f7d55 | 2017-12-25 18:43:37 +0100 | [diff] [blame] | 776 | clear_commit_marks_1(&list, *commit, mark); |
Junio C Hamano | e895cb5 | 2013-03-05 11:42:20 -0800 | [diff] [blame] | 777 | commit++; |
| 778 | } |
Nguyễn Thái Ngọc Duy | 941ba8d | 2012-01-14 19:19:53 +0700 | [diff] [blame] | 779 | while (list) |
| 780 | clear_commit_marks_1(&list, pop_commit(&list), mark); |
| 781 | } |
| 782 | |
Junio C Hamano | e895cb5 | 2013-03-05 11:42:20 -0800 | [diff] [blame] | 783 | void clear_commit_marks(struct commit *commit, unsigned int mark) |
| 784 | { |
| 785 | clear_commit_marks_many(1, &commit, mark); |
| 786 | } |
| 787 | |
jon@blackcubes.dyndns.org | a3437b8 | 2005-06-06 15:39:40 +0000 | [diff] [blame] | 788 | struct commit *pop_commit(struct commit_list **stack) |
| 789 | { |
| 790 | struct commit_list *top = *stack; |
| 791 | struct commit *item = top ? top->item : NULL; |
| 792 | |
| 793 | if (top) { |
| 794 | *stack = top->next; |
| 795 | free(top); |
| 796 | } |
| 797 | return item; |
| 798 | } |
| 799 | |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 800 | /* |
Junio C Hamano | a84b794 | 2013-04-13 11:56:41 -0700 | [diff] [blame] | 801 | * Topological sort support |
| 802 | */ |
Junio C Hamano | 66eb375 | 2013-04-12 23:25:49 -0700 | [diff] [blame] | 803 | |
Junio C Hamano | a84b794 | 2013-04-13 11:56:41 -0700 | [diff] [blame] | 804 | /* count number of children that have not been emitted */ |
| 805 | define_commit_slab(indegree_slab, int); |
Jeff King | 96c4f4a | 2013-04-09 02:52:56 -0400 | [diff] [blame] | 806 | |
Derrick Stolee | 1820703 | 2018-08-21 20:54:12 +0000 | [diff] [blame] | 807 | define_commit_slab(author_date_slab, timestamp_t); |
Junio C Hamano | 81c6b38 | 2013-06-07 10:35:54 -0700 | [diff] [blame] | 808 | |
Derrick Stolee | 5284fc5 | 2018-11-01 13:46:21 +0000 | [diff] [blame] | 809 | void record_author_date(struct author_date_slab *author_date, |
| 810 | struct commit *commit) |
Junio C Hamano | 81c6b38 | 2013-06-07 10:35:54 -0700 | [diff] [blame] | 811 | { |
Ævar Arnfjörð Bjarmason | ecb5091 | 2023-03-28 15:58:48 +0200 | [diff] [blame] | 812 | const char *buffer = repo_get_commit_buffer(the_repository, commit, |
| 813 | NULL); |
Junio C Hamano | 81c6b38 | 2013-06-07 10:35:54 -0700 | [diff] [blame] | 814 | struct ident_split ident; |
Jeff King | ea5517f | 2014-08-27 03:56:55 -0400 | [diff] [blame] | 815 | const char *ident_line; |
| 816 | size_t ident_len; |
Junio C Hamano | 81c6b38 | 2013-06-07 10:35:54 -0700 | [diff] [blame] | 817 | char *date_end; |
Johannes Schindelin | dddbad7 | 2017-04-26 21:29:31 +0200 | [diff] [blame] | 818 | timestamp_t date; |
Junio C Hamano | 81c6b38 | 2013-06-07 10:35:54 -0700 | [diff] [blame] | 819 | |
Jeff King | ea5517f | 2014-08-27 03:56:55 -0400 | [diff] [blame] | 820 | ident_line = find_commit_header(buffer, "author", &ident_len); |
| 821 | if (!ident_line) |
| 822 | goto fail_exit; /* no author line */ |
| 823 | if (split_ident_line(&ident, ident_line, ident_len) || |
| 824 | !ident.date_begin || !ident.date_end) |
| 825 | goto fail_exit; /* malformed "author" line */ |
Junio C Hamano | 81c6b38 | 2013-06-07 10:35:54 -0700 | [diff] [blame] | 826 | |
Johannes Schindelin | 1aeb7e7 | 2017-04-21 12:45:44 +0200 | [diff] [blame] | 827 | date = parse_timestamp(ident.date_begin, &date_end, 10); |
Junio C Hamano | 81c6b38 | 2013-06-07 10:35:54 -0700 | [diff] [blame] | 828 | if (date_end != ident.date_end) |
| 829 | goto fail_exit; /* malformed date */ |
| 830 | *(author_date_slab_at(author_date, commit)) = date; |
| 831 | |
| 832 | fail_exit: |
Ævar Arnfjörð Bjarmason | ecb5091 | 2023-03-28 15:58:48 +0200 | [diff] [blame] | 833 | repo_unuse_commit_buffer(the_repository, commit, buffer); |
Junio C Hamano | 81c6b38 | 2013-06-07 10:35:54 -0700 | [diff] [blame] | 834 | } |
| 835 | |
Derrick Stolee | 5284fc5 | 2018-11-01 13:46:21 +0000 | [diff] [blame] | 836 | int compare_commits_by_author_date(const void *a_, const void *b_, |
| 837 | void *cb_data) |
Junio C Hamano | 81c6b38 | 2013-06-07 10:35:54 -0700 | [diff] [blame] | 838 | { |
| 839 | const struct commit *a = a_, *b = b_; |
| 840 | struct author_date_slab *author_date = cb_data; |
Johannes Schindelin | dddbad7 | 2017-04-26 21:29:31 +0200 | [diff] [blame] | 841 | timestamp_t a_date = *(author_date_slab_at(author_date, a)); |
| 842 | timestamp_t b_date = *(author_date_slab_at(author_date, b)); |
Junio C Hamano | 81c6b38 | 2013-06-07 10:35:54 -0700 | [diff] [blame] | 843 | |
| 844 | /* newer commits with larger date first */ |
| 845 | if (a_date < b_date) |
| 846 | return 1; |
| 847 | else if (a_date > b_date) |
| 848 | return -1; |
| 849 | return 0; |
| 850 | } |
| 851 | |
Jeff King | 1758712 | 2023-02-24 01:39:27 -0500 | [diff] [blame] | 852 | int compare_commits_by_gen_then_commit_date(const void *a_, const void *b_, |
| 853 | void *unused UNUSED) |
Derrick Stolee | 3afc679 | 2018-05-01 12:47:11 +0000 | [diff] [blame] | 854 | { |
| 855 | const struct commit *a = a_, *b = b_; |
Abhishek Kumar | d7f9278 | 2021-01-16 18:11:13 +0000 | [diff] [blame] | 856 | const timestamp_t generation_a = commit_graph_generation(a), |
| 857 | generation_b = commit_graph_generation(b); |
Derrick Stolee | 3afc679 | 2018-05-01 12:47:11 +0000 | [diff] [blame] | 858 | |
| 859 | /* newer commits first */ |
Abhishek Kumar | c752ad0 | 2020-06-17 14:44:11 +0530 | [diff] [blame] | 860 | if (generation_a < generation_b) |
Derrick Stolee | 3afc679 | 2018-05-01 12:47:11 +0000 | [diff] [blame] | 861 | return 1; |
Abhishek Kumar | c752ad0 | 2020-06-17 14:44:11 +0530 | [diff] [blame] | 862 | else if (generation_a > generation_b) |
Derrick Stolee | 3afc679 | 2018-05-01 12:47:11 +0000 | [diff] [blame] | 863 | return -1; |
| 864 | |
| 865 | /* use date as a heuristic when generations are equal */ |
| 866 | if (a->date < b->date) |
| 867 | return 1; |
| 868 | else if (a->date > b->date) |
| 869 | return -1; |
| 870 | return 0; |
| 871 | } |
| 872 | |
Jeff King | 1758712 | 2023-02-24 01:39:27 -0500 | [diff] [blame] | 873 | int compare_commits_by_commit_date(const void *a_, const void *b_, |
| 874 | void *unused UNUSED) |
Junio C Hamano | da24b10 | 2013-06-06 21:58:12 -0700 | [diff] [blame] | 875 | { |
| 876 | const struct commit *a = a_, *b = b_; |
| 877 | /* newer commits with larger date first */ |
| 878 | if (a->date < b->date) |
| 879 | return 1; |
| 880 | else if (a->date > b->date) |
| 881 | return -1; |
| 882 | return 0; |
| 883 | } |
| 884 | |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 885 | /* |
| 886 | * Performs an in-place topological sort on the list supplied. |
| 887 | */ |
Junio C Hamano | da24b10 | 2013-06-06 21:58:12 -0700 | [diff] [blame] | 888 | void sort_in_topological_order(struct commit_list **list, enum rev_sort_order sort_order) |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 889 | { |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 890 | struct commit_list *next, *orig = *list; |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 891 | struct commit_list **pptr; |
Junio C Hamano | a84b794 | 2013-04-13 11:56:41 -0700 | [diff] [blame] | 892 | struct indegree_slab indegree; |
Junio C Hamano | da24b10 | 2013-06-06 21:58:12 -0700 | [diff] [blame] | 893 | struct prio_queue queue; |
| 894 | struct commit *commit; |
Junio C Hamano | 81c6b38 | 2013-06-07 10:35:54 -0700 | [diff] [blame] | 895 | struct author_date_slab author_date; |
Fredrik Kuivinen | 6b6dcfc | 2006-03-10 10:21:37 +0100 | [diff] [blame] | 896 | |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 897 | if (!orig) |
Eric Wong | 7d6fb37 | 2005-12-24 04:12:43 -0800 | [diff] [blame] | 898 | return; |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 899 | *list = NULL; |
| 900 | |
Junio C Hamano | a84b794 | 2013-04-13 11:56:41 -0700 | [diff] [blame] | 901 | init_indegree_slab(&indegree); |
Junio C Hamano | da24b10 | 2013-06-06 21:58:12 -0700 | [diff] [blame] | 902 | memset(&queue, '\0', sizeof(queue)); |
Junio C Hamano | 81c6b38 | 2013-06-07 10:35:54 -0700 | [diff] [blame] | 903 | |
Junio C Hamano | da24b10 | 2013-06-06 21:58:12 -0700 | [diff] [blame] | 904 | switch (sort_order) { |
| 905 | default: /* REV_SORT_IN_GRAPH_ORDER */ |
| 906 | queue.compare = NULL; |
| 907 | break; |
| 908 | case REV_SORT_BY_COMMIT_DATE: |
| 909 | queue.compare = compare_commits_by_commit_date; |
| 910 | break; |
Junio C Hamano | 81c6b38 | 2013-06-07 10:35:54 -0700 | [diff] [blame] | 911 | case REV_SORT_BY_AUTHOR_DATE: |
| 912 | init_author_date_slab(&author_date); |
| 913 | queue.compare = compare_commits_by_author_date; |
| 914 | queue.cb_data = &author_date; |
| 915 | break; |
Junio C Hamano | da24b10 | 2013-06-06 21:58:12 -0700 | [diff] [blame] | 916 | } |
Jeff King | 96c4f4a | 2013-04-09 02:52:56 -0400 | [diff] [blame] | 917 | |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 918 | /* Mark them and clear the indegree */ |
| 919 | for (next = orig; next; next = next->next) { |
| 920 | struct commit *commit = next->item; |
Junio C Hamano | a84b794 | 2013-04-13 11:56:41 -0700 | [diff] [blame] | 921 | *(indegree_slab_at(&indegree, commit)) = 1; |
Junio C Hamano | 81c6b38 | 2013-06-07 10:35:54 -0700 | [diff] [blame] | 922 | /* also record the author dates, if needed */ |
| 923 | if (sort_order == REV_SORT_BY_AUTHOR_DATE) |
| 924 | record_author_date(&author_date, commit); |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 925 | } |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 926 | |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 927 | /* update the indegree */ |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 928 | for (next = orig; next; next = next->next) { |
Junio C Hamano | da24b10 | 2013-06-06 21:58:12 -0700 | [diff] [blame] | 929 | struct commit_list *parents = next->item->parents; |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 930 | while (parents) { |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 931 | struct commit *parent = parents->item; |
Junio C Hamano | a84b794 | 2013-04-13 11:56:41 -0700 | [diff] [blame] | 932 | int *pi = indegree_slab_at(&indegree, parent); |
Fredrik Kuivinen | 6b6dcfc | 2006-03-10 10:21:37 +0100 | [diff] [blame] | 933 | |
Jeff King | 96c4f4a | 2013-04-09 02:52:56 -0400 | [diff] [blame] | 934 | if (*pi) |
| 935 | (*pi)++; |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 936 | parents = parents->next; |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 937 | } |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 938 | } |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 939 | |
Junio C Hamano | a6080a0 | 2007-06-07 00:04:01 -0700 | [diff] [blame] | 940 | /* |
Pierre Habouzit | 674d172 | 2007-09-10 12:35:06 +0200 | [diff] [blame] | 941 | * find the tips |
| 942 | * |
| 943 | * tips are nodes not reachable from any other node in the list |
| 944 | * |
| 945 | * the tips serve as a starting set for the work queue. |
| 946 | */ |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 947 | for (next = orig; next; next = next->next) { |
| 948 | struct commit *commit = next->item; |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 949 | |
Junio C Hamano | a84b794 | 2013-04-13 11:56:41 -0700 | [diff] [blame] | 950 | if (*(indegree_slab_at(&indegree, commit)) == 1) |
Junio C Hamano | da24b10 | 2013-06-06 21:58:12 -0700 | [diff] [blame] | 951 | prio_queue_put(&queue, commit); |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 952 | } |
Junio C Hamano | 4c8725f | 2006-02-15 22:05:33 -0800 | [diff] [blame] | 953 | |
Junio C Hamano | da24b10 | 2013-06-06 21:58:12 -0700 | [diff] [blame] | 954 | /* |
| 955 | * This is unfortunate; the initial tips need to be shown |
| 956 | * in the order given from the revision traversal machinery. |
| 957 | */ |
| 958 | if (sort_order == REV_SORT_IN_GRAPH_ORDER) |
| 959 | prio_queue_reverse(&queue); |
| 960 | |
| 961 | /* We no longer need the commit list */ |
| 962 | free_commit_list(orig); |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 963 | |
| 964 | pptr = list; |
| 965 | *list = NULL; |
Junio C Hamano | da24b10 | 2013-06-06 21:58:12 -0700 | [diff] [blame] | 966 | while ((commit = prio_queue_get(&queue)) != NULL) { |
| 967 | struct commit_list *parents; |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 968 | |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 969 | for (parents = commit->parents; parents ; parents = parents->next) { |
Junio C Hamano | cd2b8ae | 2011-08-25 14:46:52 -0700 | [diff] [blame] | 970 | struct commit *parent = parents->item; |
Junio C Hamano | a84b794 | 2013-04-13 11:56:41 -0700 | [diff] [blame] | 971 | int *pi = indegree_slab_at(&indegree, parent); |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 972 | |
Jeff King | 96c4f4a | 2013-04-09 02:52:56 -0400 | [diff] [blame] | 973 | if (!*pi) |
Linus Torvalds | 23c17d4 | 2007-11-02 13:32:58 -0700 | [diff] [blame] | 974 | continue; |
| 975 | |
| 976 | /* |
| 977 | * parents are only enqueued for emission |
| 978 | * when all their children have been emitted thereby |
| 979 | * guaranteeing topological order. |
| 980 | */ |
Junio C Hamano | da24b10 | 2013-06-06 21:58:12 -0700 | [diff] [blame] | 981 | if (--(*pi) == 1) |
| 982 | prio_queue_put(&queue, parent); |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 983 | } |
| 984 | /* |
Junio C Hamano | da24b10 | 2013-06-06 21:58:12 -0700 | [diff] [blame] | 985 | * all children of commit have already been |
| 986 | * emitted. we can emit it now. |
Pierre Habouzit | 674d172 | 2007-09-10 12:35:06 +0200 | [diff] [blame] | 987 | */ |
Junio C Hamano | a84b794 | 2013-04-13 11:56:41 -0700 | [diff] [blame] | 988 | *(indegree_slab_at(&indegree, commit)) = 0; |
Junio C Hamano | da24b10 | 2013-06-06 21:58:12 -0700 | [diff] [blame] | 989 | |
| 990 | pptr = &commit_list_insert(commit, pptr)->next; |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 991 | } |
Jeff King | 96c4f4a | 2013-04-09 02:52:56 -0400 | [diff] [blame] | 992 | |
Junio C Hamano | a84b794 | 2013-04-13 11:56:41 -0700 | [diff] [blame] | 993 | clear_indegree_slab(&indegree); |
Junio C Hamano | da24b10 | 2013-06-06 21:58:12 -0700 | [diff] [blame] | 994 | clear_prio_queue(&queue); |
Junio C Hamano | 81c6b38 | 2013-06-07 10:35:54 -0700 | [diff] [blame] | 995 | if (sort_order == REV_SORT_BY_AUTHOR_DATE) |
| 996 | clear_author_date_slab(&author_date); |
Jon Seymour | ab580ac | 2005-07-07 02:39:34 +1000 | [diff] [blame] | 997 | } |
Johannes Schindelin | 7c6f8aa | 2006-06-29 15:17:32 +0200 | [diff] [blame] | 998 | |
Pratik Karki | 103148a | 2018-09-04 15:00:08 -0700 | [diff] [blame] | 999 | struct rev_collect { |
| 1000 | struct commit **commit; |
| 1001 | int nr; |
| 1002 | int alloc; |
| 1003 | unsigned int initial : 1; |
| 1004 | }; |
| 1005 | |
| 1006 | static void add_one_commit(struct object_id *oid, struct rev_collect *revs) |
| 1007 | { |
| 1008 | struct commit *commit; |
| 1009 | |
| 1010 | if (is_null_oid(oid)) |
| 1011 | return; |
| 1012 | |
| 1013 | commit = lookup_commit(the_repository, oid); |
| 1014 | if (!commit || |
| 1015 | (commit->object.flags & TMP_MARK) || |
Ævar Arnfjörð Bjarmason | ecb5091 | 2023-03-28 15:58:48 +0200 | [diff] [blame] | 1016 | repo_parse_commit(the_repository, commit)) |
Pratik Karki | 103148a | 2018-09-04 15:00:08 -0700 | [diff] [blame] | 1017 | return; |
| 1018 | |
| 1019 | ALLOC_GROW(revs->commit, revs->nr + 1, revs->alloc); |
| 1020 | revs->commit[revs->nr++] = commit; |
| 1021 | commit->object.flags |= TMP_MARK; |
| 1022 | } |
| 1023 | |
| 1024 | static int collect_one_reflog_ent(struct object_id *ooid, struct object_id *noid, |
Ævar Arnfjörð Bjarmason | 5cf88fd | 2022-08-25 19:09:48 +0200 | [diff] [blame] | 1025 | const char *ident UNUSED, |
| 1026 | timestamp_t timestamp UNUSED, int tz UNUSED, |
| 1027 | const char *message UNUSED, void *cbdata) |
Pratik Karki | 103148a | 2018-09-04 15:00:08 -0700 | [diff] [blame] | 1028 | { |
| 1029 | struct rev_collect *revs = cbdata; |
| 1030 | |
| 1031 | if (revs->initial) { |
| 1032 | revs->initial = 0; |
| 1033 | add_one_commit(ooid, revs); |
| 1034 | } |
| 1035 | add_one_commit(noid, revs); |
| 1036 | return 0; |
| 1037 | } |
| 1038 | |
| 1039 | struct commit *get_fork_point(const char *refname, struct commit *commit) |
| 1040 | { |
| 1041 | struct object_id oid; |
| 1042 | struct rev_collect revs; |
| 1043 | struct commit_list *bases; |
| 1044 | int i; |
| 1045 | struct commit *ret = NULL; |
Junio C Hamano | f08132f | 2019-12-09 10:51:47 -0800 | [diff] [blame] | 1046 | char *full_refname; |
| 1047 | |
Ævar Arnfjörð Bjarmason | 12cb1c1 | 2023-03-28 15:58:54 +0200 | [diff] [blame] | 1048 | switch (repo_dwim_ref(the_repository, refname, strlen(refname), &oid, |
| 1049 | &full_refname, 0)) { |
Junio C Hamano | f08132f | 2019-12-09 10:51:47 -0800 | [diff] [blame] | 1050 | case 0: |
| 1051 | die("No such ref: '%s'", refname); |
| 1052 | case 1: |
| 1053 | break; /* good */ |
| 1054 | default: |
| 1055 | die("Ambiguous refname: '%s'", refname); |
| 1056 | } |
Pratik Karki | 103148a | 2018-09-04 15:00:08 -0700 | [diff] [blame] | 1057 | |
| 1058 | memset(&revs, 0, sizeof(revs)); |
| 1059 | revs.initial = 1; |
Junio C Hamano | f08132f | 2019-12-09 10:51:47 -0800 | [diff] [blame] | 1060 | for_each_reflog_ent(full_refname, collect_one_reflog_ent, &revs); |
Pratik Karki | 103148a | 2018-09-04 15:00:08 -0700 | [diff] [blame] | 1061 | |
Junio C Hamano | f08132f | 2019-12-09 10:51:47 -0800 | [diff] [blame] | 1062 | if (!revs.nr) |
Pratik Karki | 103148a | 2018-09-04 15:00:08 -0700 | [diff] [blame] | 1063 | add_one_commit(&oid, &revs); |
| 1064 | |
| 1065 | for (i = 0; i < revs.nr; i++) |
| 1066 | revs.commit[i]->object.flags &= ~TMP_MARK; |
| 1067 | |
Ævar Arnfjörð Bjarmason | cb338c2 | 2023-03-28 15:58:47 +0200 | [diff] [blame] | 1068 | bases = repo_get_merge_bases_many(the_repository, commit, revs.nr, |
| 1069 | revs.commit); |
Pratik Karki | 103148a | 2018-09-04 15:00:08 -0700 | [diff] [blame] | 1070 | |
| 1071 | /* |
| 1072 | * There should be one and only one merge base, when we found |
| 1073 | * a common ancestor among reflog entries. |
| 1074 | */ |
| 1075 | if (!bases || bases->next) |
| 1076 | goto cleanup_return; |
| 1077 | |
| 1078 | /* And the found one must be one of the reflog entries */ |
| 1079 | for (i = 0; i < revs.nr; i++) |
| 1080 | if (&bases->item->object == &revs.commit[i]->object) |
| 1081 | break; /* found */ |
| 1082 | if (revs.nr <= i) |
| 1083 | goto cleanup_return; |
| 1084 | |
| 1085 | ret = bases->item; |
| 1086 | |
| 1087 | cleanup_return: |
Ævar Arnfjörð Bjarmason | 0c10ed1 | 2023-02-06 20:08:13 +0100 | [diff] [blame] | 1088 | free(revs.commit); |
Pratik Karki | 103148a | 2018-09-04 15:00:08 -0700 | [diff] [blame] | 1089 | free_commit_list(bases); |
Junio C Hamano | f08132f | 2019-12-09 10:51:47 -0800 | [diff] [blame] | 1090 | free(full_refname); |
Pratik Karki | 103148a | 2018-09-04 15:00:08 -0700 | [diff] [blame] | 1091 | return ret; |
| 1092 | } |
| 1093 | |
brian m. carlson | 42d4e1d | 2020-02-22 20:17:42 +0000 | [diff] [blame] | 1094 | /* |
| 1095 | * Indexed by hash algorithm identifier. |
| 1096 | */ |
| 1097 | static const char *gpg_sig_headers[] = { |
| 1098 | NULL, |
| 1099 | "gpgsig", |
| 1100 | "gpgsig-sha256", |
| 1101 | }; |
Junio C Hamano | ba3c69a | 2011-10-05 17:23:20 -0700 | [diff] [blame] | 1102 | |
brian m. carlson | 937032e | 2021-02-11 02:08:04 +0000 | [diff] [blame] | 1103 | int sign_with_header(struct strbuf *buf, const char *keyid) |
Junio C Hamano | ba3c69a | 2011-10-05 17:23:20 -0700 | [diff] [blame] | 1104 | { |
| 1105 | struct strbuf sig = STRBUF_INIT; |
| 1106 | int inspos, copypos; |
Johannes Schindelin | 3324dd8 | 2016-06-29 16:14:54 +0200 | [diff] [blame] | 1107 | const char *eoh; |
brian m. carlson | 42d4e1d | 2020-02-22 20:17:42 +0000 | [diff] [blame] | 1108 | const char *gpg_sig_header = gpg_sig_headers[hash_algo_by_ptr(the_hash_algo)]; |
| 1109 | int gpg_sig_header_len = strlen(gpg_sig_header); |
Junio C Hamano | ba3c69a | 2011-10-05 17:23:20 -0700 | [diff] [blame] | 1110 | |
| 1111 | /* find the end of the header */ |
Johannes Schindelin | 3324dd8 | 2016-06-29 16:14:54 +0200 | [diff] [blame] | 1112 | eoh = strstr(buf->buf, "\n\n"); |
| 1113 | if (!eoh) |
| 1114 | inspos = buf->len; |
| 1115 | else |
| 1116 | inspos = eoh - buf->buf + 1; |
Junio C Hamano | ba3c69a | 2011-10-05 17:23:20 -0700 | [diff] [blame] | 1117 | |
| 1118 | if (!keyid || !*keyid) |
| 1119 | keyid = get_signing_key(); |
| 1120 | if (sign_buffer(buf, &sig, keyid)) { |
| 1121 | strbuf_release(&sig); |
| 1122 | return -1; |
| 1123 | } |
| 1124 | |
| 1125 | for (copypos = 0; sig.buf[copypos]; ) { |
| 1126 | const char *bol = sig.buf + copypos; |
| 1127 | const char *eol = strchrnul(bol, '\n'); |
| 1128 | int len = (eol - bol) + !!*eol; |
| 1129 | |
| 1130 | if (!copypos) { |
| 1131 | strbuf_insert(buf, inspos, gpg_sig_header, gpg_sig_header_len); |
| 1132 | inspos += gpg_sig_header_len; |
| 1133 | } |
René Scharfe | a91cc7f | 2020-02-09 14:44:23 +0100 | [diff] [blame] | 1134 | strbuf_insertstr(buf, inspos++, " "); |
Junio C Hamano | ba3c69a | 2011-10-05 17:23:20 -0700 | [diff] [blame] | 1135 | strbuf_insert(buf, inspos, bol, len); |
| 1136 | inspos += len; |
| 1137 | copypos += len; |
| 1138 | } |
| 1139 | strbuf_release(&sig); |
| 1140 | return 0; |
| 1141 | } |
| 1142 | |
Junio C Hamano | 0c37f1f | 2011-10-18 15:53:23 -0700 | [diff] [blame] | 1143 | |
brian m. carlson | 937032e | 2021-02-11 02:08:04 +0000 | [diff] [blame] | 1144 | |
Junio C Hamano | 0c37f1f | 2011-10-18 15:53:23 -0700 | [diff] [blame] | 1145 | int parse_signed_commit(const struct commit *commit, |
brian m. carlson | 1fb5cf0 | 2021-01-18 23:49:11 +0000 | [diff] [blame] | 1146 | struct strbuf *payload, struct strbuf *signature, |
| 1147 | const struct git_hash_algo *algop) |
Junio C Hamano | 0c37f1f | 2011-10-18 15:53:23 -0700 | [diff] [blame] | 1148 | { |
Jeff King | 218aa3a | 2014-06-13 02:32:11 -0400 | [diff] [blame] | 1149 | unsigned long size; |
Ævar Arnfjörð Bjarmason | ecb5091 | 2023-03-28 15:58:48 +0200 | [diff] [blame] | 1150 | const char *buffer = repo_get_commit_buffer(the_repository, commit, |
| 1151 | &size); |
brian m. carlson | 937032e | 2021-02-11 02:08:04 +0000 | [diff] [blame] | 1152 | int ret = parse_buffer_signed_by_header(buffer, size, payload, signature, algop); |
| 1153 | |
Ævar Arnfjörð Bjarmason | ecb5091 | 2023-03-28 15:58:48 +0200 | [diff] [blame] | 1154 | repo_unuse_commit_buffer(the_repository, commit, buffer); |
brian m. carlson | 937032e | 2021-02-11 02:08:04 +0000 | [diff] [blame] | 1155 | return ret; |
| 1156 | } |
| 1157 | |
| 1158 | int parse_buffer_signed_by_header(const char *buffer, |
| 1159 | unsigned long size, |
| 1160 | struct strbuf *payload, |
| 1161 | struct strbuf *signature, |
| 1162 | const struct git_hash_algo *algop) |
| 1163 | { |
brian m. carlson | 1fb5cf0 | 2021-01-18 23:49:11 +0000 | [diff] [blame] | 1164 | int in_signature = 0, saw_signature = 0, other_signature = 0; |
| 1165 | const char *line, *tail, *p; |
| 1166 | const char *gpg_sig_header = gpg_sig_headers[hash_algo_by_ptr(algop)]; |
Junio C Hamano | 0c37f1f | 2011-10-18 15:53:23 -0700 | [diff] [blame] | 1167 | |
| 1168 | line = buffer; |
| 1169 | tail = buffer + size; |
Junio C Hamano | 0c37f1f | 2011-10-18 15:53:23 -0700 | [diff] [blame] | 1170 | while (line < tail) { |
| 1171 | const char *sig = NULL; |
Jeff King | 218aa3a | 2014-06-13 02:32:11 -0400 | [diff] [blame] | 1172 | const char *next = memchr(line, '\n', tail - line); |
Junio C Hamano | 0c37f1f | 2011-10-18 15:53:23 -0700 | [diff] [blame] | 1173 | |
| 1174 | next = next ? next + 1 : tail; |
| 1175 | if (in_signature && line[0] == ' ') |
| 1176 | sig = line + 1; |
brian m. carlson | 1fb5cf0 | 2021-01-18 23:49:11 +0000 | [diff] [blame] | 1177 | else if (skip_prefix(line, gpg_sig_header, &p) && |
| 1178 | *p == ' ') { |
| 1179 | sig = line + strlen(gpg_sig_header) + 1; |
| 1180 | other_signature = 0; |
| 1181 | } |
| 1182 | else if (starts_with(line, "gpgsig")) |
| 1183 | other_signature = 1; |
| 1184 | else if (other_signature && line[0] != ' ') |
| 1185 | other_signature = 0; |
Junio C Hamano | 0c37f1f | 2011-10-18 15:53:23 -0700 | [diff] [blame] | 1186 | if (sig) { |
| 1187 | strbuf_add(signature, sig, next - sig); |
| 1188 | saw_signature = 1; |
| 1189 | in_signature = 1; |
| 1190 | } else { |
| 1191 | if (*line == '\n') |
| 1192 | /* dump the whole remainder of the buffer */ |
| 1193 | next = tail; |
brian m. carlson | 1fb5cf0 | 2021-01-18 23:49:11 +0000 | [diff] [blame] | 1194 | if (!other_signature) |
| 1195 | strbuf_add(payload, line, next - line); |
Junio C Hamano | 0c37f1f | 2011-10-18 15:53:23 -0700 | [diff] [blame] | 1196 | in_signature = 0; |
| 1197 | } |
| 1198 | line = next; |
| 1199 | } |
Junio C Hamano | 0c37f1f | 2011-10-18 15:53:23 -0700 | [diff] [blame] | 1200 | return saw_signature; |
| 1201 | } |
| 1202 | |
Christian Couder | 0b05ab6 | 2014-07-19 17:01:12 +0200 | [diff] [blame] | 1203 | int remove_signature(struct strbuf *buf) |
| 1204 | { |
| 1205 | const char *line = buf->buf; |
| 1206 | const char *tail = buf->buf + buf->len; |
| 1207 | int in_signature = 0; |
brian m. carlson | 1fb5cf0 | 2021-01-18 23:49:11 +0000 | [diff] [blame] | 1208 | struct sigbuf { |
| 1209 | const char *start; |
| 1210 | const char *end; |
| 1211 | } sigs[2], *sigp = &sigs[0]; |
| 1212 | int i; |
| 1213 | const char *orig_buf = buf->buf; |
| 1214 | |
| 1215 | memset(sigs, 0, sizeof(sigs)); |
Christian Couder | 0b05ab6 | 2014-07-19 17:01:12 +0200 | [diff] [blame] | 1216 | |
| 1217 | while (line < tail) { |
| 1218 | const char *next = memchr(line, '\n', tail - line); |
| 1219 | next = next ? next + 1 : tail; |
| 1220 | |
| 1221 | if (in_signature && line[0] == ' ') |
brian m. carlson | 1fb5cf0 | 2021-01-18 23:49:11 +0000 | [diff] [blame] | 1222 | sigp->end = next; |
brian m. carlson | 42d4e1d | 2020-02-22 20:17:42 +0000 | [diff] [blame] | 1223 | else if (starts_with(line, "gpgsig")) { |
| 1224 | int i; |
| 1225 | for (i = 1; i < GIT_HASH_NALGOS; i++) { |
| 1226 | const char *p; |
| 1227 | if (skip_prefix(line, gpg_sig_headers[i], &p) && |
| 1228 | *p == ' ') { |
brian m. carlson | 1fb5cf0 | 2021-01-18 23:49:11 +0000 | [diff] [blame] | 1229 | sigp->start = line; |
| 1230 | sigp->end = next; |
brian m. carlson | 42d4e1d | 2020-02-22 20:17:42 +0000 | [diff] [blame] | 1231 | in_signature = 1; |
| 1232 | } |
| 1233 | } |
Christian Couder | 0b05ab6 | 2014-07-19 17:01:12 +0200 | [diff] [blame] | 1234 | } else { |
| 1235 | if (*line == '\n') |
| 1236 | /* dump the whole remainder of the buffer */ |
| 1237 | next = tail; |
brian m. carlson | 1fb5cf0 | 2021-01-18 23:49:11 +0000 | [diff] [blame] | 1238 | if (in_signature && sigp - sigs != ARRAY_SIZE(sigs)) |
| 1239 | sigp++; |
Christian Couder | 0b05ab6 | 2014-07-19 17:01:12 +0200 | [diff] [blame] | 1240 | in_signature = 0; |
| 1241 | } |
| 1242 | line = next; |
| 1243 | } |
| 1244 | |
brian m. carlson | 1fb5cf0 | 2021-01-18 23:49:11 +0000 | [diff] [blame] | 1245 | for (i = ARRAY_SIZE(sigs) - 1; i >= 0; i--) |
| 1246 | if (sigs[i].start) |
| 1247 | strbuf_remove(buf, sigs[i].start - orig_buf, sigs[i].end - sigs[i].start); |
Christian Couder | 0b05ab6 | 2014-07-19 17:01:12 +0200 | [diff] [blame] | 1248 | |
brian m. carlson | 1fb5cf0 | 2021-01-18 23:49:11 +0000 | [diff] [blame] | 1249 | return sigs[0].start != NULL; |
Christian Couder | 0b05ab6 | 2014-07-19 17:01:12 +0200 | [diff] [blame] | 1250 | } |
| 1251 | |
Junio C Hamano | 5231c63 | 2011-11-07 16:21:32 -0800 | [diff] [blame] | 1252 | static void handle_signed_tag(struct commit *parent, struct commit_extra_header ***tail) |
| 1253 | { |
| 1254 | struct merge_remote_desc *desc; |
| 1255 | struct commit_extra_header *mergetag; |
| 1256 | char *buf; |
brian m. carlson | 482c119 | 2021-02-11 02:08:03 +0000 | [diff] [blame] | 1257 | unsigned long size; |
Junio C Hamano | 5231c63 | 2011-11-07 16:21:32 -0800 | [diff] [blame] | 1258 | enum object_type type; |
brian m. carlson | 482c119 | 2021-02-11 02:08:03 +0000 | [diff] [blame] | 1259 | struct strbuf payload = STRBUF_INIT; |
| 1260 | struct strbuf signature = STRBUF_INIT; |
Junio C Hamano | 5231c63 | 2011-11-07 16:21:32 -0800 | [diff] [blame] | 1261 | |
| 1262 | desc = merge_remote_util(parent); |
| 1263 | if (!desc || !desc->obj) |
| 1264 | return; |
Ævar Arnfjörð Bjarmason | bc726bd | 2023-03-28 15:58:50 +0200 | [diff] [blame] | 1265 | buf = repo_read_object_file(the_repository, &desc->obj->oid, &type, |
| 1266 | &size); |
Junio C Hamano | 5231c63 | 2011-11-07 16:21:32 -0800 | [diff] [blame] | 1267 | if (!buf || type != OBJ_TAG) |
| 1268 | goto free_return; |
brian m. carlson | 482c119 | 2021-02-11 02:08:03 +0000 | [diff] [blame] | 1269 | if (!parse_signature(buf, size, &payload, &signature)) |
Junio C Hamano | 5231c63 | 2011-11-07 16:21:32 -0800 | [diff] [blame] | 1270 | goto free_return; |
| 1271 | /* |
| 1272 | * We could verify this signature and either omit the tag when |
| 1273 | * it does not validate, but the integrator may not have the |
Felipe Contreras | 0e20b22 | 2021-06-15 14:11:10 +0000 | [diff] [blame] | 1274 | * public key of the signer of the tag being merged, while a |
Junio C Hamano | 5231c63 | 2011-11-07 16:21:32 -0800 | [diff] [blame] | 1275 | * later auditor may have it while auditing, so let's not run |
| 1276 | * verify-signed-buffer here for now... |
| 1277 | * |
| 1278 | * if (verify_signed_buffer(buf, len, buf + len, size - len, ...)) |
| 1279 | * warn("warning: signed tag unverified."); |
| 1280 | */ |
René Scharfe | ca56dad | 2021-03-13 17:17:22 +0100 | [diff] [blame] | 1281 | CALLOC_ARRAY(mergetag, 1); |
Junio C Hamano | 5231c63 | 2011-11-07 16:21:32 -0800 | [diff] [blame] | 1282 | mergetag->key = xstrdup("mergetag"); |
| 1283 | mergetag->value = buf; |
| 1284 | mergetag->len = size; |
| 1285 | |
| 1286 | **tail = mergetag; |
| 1287 | *tail = &mergetag->next; |
brian m. carlson | 482c119 | 2021-02-11 02:08:03 +0000 | [diff] [blame] | 1288 | strbuf_release(&payload); |
| 1289 | strbuf_release(&signature); |
Junio C Hamano | 5231c63 | 2011-11-07 16:21:32 -0800 | [diff] [blame] | 1290 | return; |
| 1291 | |
| 1292 | free_return: |
| 1293 | free(buf); |
| 1294 | } |
| 1295 | |
brian m. carlson | 434060e | 2015-06-21 23:14:40 +0000 | [diff] [blame] | 1296 | int check_commit_signature(const struct commit *commit, struct signature_check *sigc) |
Sebastian Götte | ffb6d7d | 2013-03-31 18:00:14 +0200 | [diff] [blame] | 1297 | { |
| 1298 | struct strbuf payload = STRBUF_INIT; |
| 1299 | struct strbuf signature = STRBUF_INIT; |
brian m. carlson | 434060e | 2015-06-21 23:14:40 +0000 | [diff] [blame] | 1300 | int ret = 1; |
Sebastian Götte | ffb6d7d | 2013-03-31 18:00:14 +0200 | [diff] [blame] | 1301 | |
| 1302 | sigc->result = 'N'; |
| 1303 | |
brian m. carlson | 1fb5cf0 | 2021-01-18 23:49:11 +0000 | [diff] [blame] | 1304 | if (parse_signed_commit(commit, &payload, &signature, the_hash_algo) <= 0) |
Sebastian Götte | ffb6d7d | 2013-03-31 18:00:14 +0200 | [diff] [blame] | 1305 | goto out; |
Fabian Stelzer | 0276943 | 2021-12-09 09:52:43 +0100 | [diff] [blame] | 1306 | |
Fabian Stelzer | 6393c95 | 2021-12-09 09:52:45 +0100 | [diff] [blame] | 1307 | sigc->payload_type = SIGNATURE_PAYLOAD_COMMIT; |
Fabian Stelzer | 0276943 | 2021-12-09 09:52:43 +0100 | [diff] [blame] | 1308 | sigc->payload = strbuf_detach(&payload, &sigc->payload_len); |
| 1309 | ret = check_signature(sigc, signature.buf, signature.len); |
Sebastian Götte | ffb6d7d | 2013-03-31 18:00:14 +0200 | [diff] [blame] | 1310 | |
| 1311 | out: |
Sebastian Götte | ffb6d7d | 2013-03-31 18:00:14 +0200 | [diff] [blame] | 1312 | strbuf_release(&payload); |
| 1313 | strbuf_release(&signature); |
brian m. carlson | 434060e | 2015-06-21 23:14:40 +0000 | [diff] [blame] | 1314 | |
| 1315 | return ret; |
Sebastian Götte | ffb6d7d | 2013-03-31 18:00:14 +0200 | [diff] [blame] | 1316 | } |
| 1317 | |
Hans Jerry Illikainen | 54887b4 | 2019-12-27 13:55:57 +0000 | [diff] [blame] | 1318 | void verify_merge_signature(struct commit *commit, int verbosity, |
| 1319 | int check_trust) |
Jeff King | edc4d47 | 2018-11-06 02:50:17 -0500 | [diff] [blame] | 1320 | { |
| 1321 | char hex[GIT_MAX_HEXSZ + 1]; |
| 1322 | struct signature_check signature_check; |
Hans Jerry Illikainen | 54887b4 | 2019-12-27 13:55:57 +0000 | [diff] [blame] | 1323 | int ret; |
Jeff King | edc4d47 | 2018-11-06 02:50:17 -0500 | [diff] [blame] | 1324 | memset(&signature_check, 0, sizeof(signature_check)); |
Sebastian Götte | ffb6d7d | 2013-03-31 18:00:14 +0200 | [diff] [blame] | 1325 | |
Hans Jerry Illikainen | 54887b4 | 2019-12-27 13:55:57 +0000 | [diff] [blame] | 1326 | ret = check_commit_signature(commit, &signature_check); |
Jeff King | edc4d47 | 2018-11-06 02:50:17 -0500 | [diff] [blame] | 1327 | |
Ævar Arnfjörð Bjarmason | d850b7a | 2023-03-28 15:58:46 +0200 | [diff] [blame] | 1328 | repo_find_unique_abbrev_r(the_repository, hex, &commit->object.oid, |
| 1329 | DEFAULT_ABBREV); |
Jeff King | edc4d47 | 2018-11-06 02:50:17 -0500 | [diff] [blame] | 1330 | switch (signature_check.result) { |
| 1331 | case 'G': |
Hans Jerry Illikainen | 54887b4 | 2019-12-27 13:55:57 +0000 | [diff] [blame] | 1332 | if (ret || (check_trust && signature_check.trust_level < TRUST_MARGINAL)) |
| 1333 | die(_("Commit %s has an untrusted GPG signature, " |
| 1334 | "allegedly by %s."), hex, signature_check.signer); |
Jeff King | edc4d47 | 2018-11-06 02:50:17 -0500 | [diff] [blame] | 1335 | break; |
Jeff King | edc4d47 | 2018-11-06 02:50:17 -0500 | [diff] [blame] | 1336 | case 'B': |
| 1337 | die(_("Commit %s has a bad GPG signature " |
| 1338 | "allegedly by %s."), hex, signature_check.signer); |
| 1339 | default: /* 'N' */ |
| 1340 | die(_("Commit %s does not have a GPG signature."), hex); |
| 1341 | } |
| 1342 | if (verbosity >= 0 && signature_check.result == 'G') |
| 1343 | printf(_("Commit %s has a good GPG signature by %s\n"), |
| 1344 | hex, signature_check.signer); |
| 1345 | |
| 1346 | signature_check_clear(&signature_check); |
| 1347 | } |
Sebastian Götte | ffb6d7d | 2013-03-31 18:00:14 +0200 | [diff] [blame] | 1348 | |
Junio C Hamano | 5231c63 | 2011-11-07 16:21:32 -0800 | [diff] [blame] | 1349 | void append_merge_tag_headers(struct commit_list *parents, |
| 1350 | struct commit_extra_header ***tail) |
| 1351 | { |
| 1352 | while (parents) { |
| 1353 | struct commit *parent = parents->item; |
| 1354 | handle_signed_tag(parent, tail); |
| 1355 | parents = parents->next; |
| 1356 | } |
| 1357 | } |
| 1358 | |
| 1359 | static void add_extra_header(struct strbuf *buffer, |
| 1360 | struct commit_extra_header *extra) |
| 1361 | { |
| 1362 | strbuf_addstr(buffer, extra->key); |
Junio C Hamano | ed7a42a | 2011-11-08 15:38:07 -0800 | [diff] [blame] | 1363 | if (extra->len) |
| 1364 | strbuf_add_lines(buffer, " ", extra->value, extra->len); |
| 1365 | else |
| 1366 | strbuf_addch(buffer, '\n'); |
| 1367 | } |
| 1368 | |
Junio C Hamano | c871a1d | 2012-01-05 10:54:14 -0800 | [diff] [blame] | 1369 | struct commit_extra_header *read_commit_extra_headers(struct commit *commit, |
| 1370 | const char **exclude) |
Junio C Hamano | ed7a42a | 2011-11-08 15:38:07 -0800 | [diff] [blame] | 1371 | { |
| 1372 | struct commit_extra_header *extra = NULL; |
| 1373 | unsigned long size; |
Ævar Arnfjörð Bjarmason | ecb5091 | 2023-03-28 15:58:48 +0200 | [diff] [blame] | 1374 | const char *buffer = repo_get_commit_buffer(the_repository, commit, |
| 1375 | &size); |
Jeff King | 218aa3a | 2014-06-13 02:32:11 -0400 | [diff] [blame] | 1376 | extra = read_commit_extra_header_lines(buffer, size, exclude); |
Ævar Arnfjörð Bjarmason | ecb5091 | 2023-03-28 15:58:48 +0200 | [diff] [blame] | 1377 | repo_unuse_commit_buffer(the_repository, commit, buffer); |
Junio C Hamano | ed7a42a | 2011-11-08 15:38:07 -0800 | [diff] [blame] | 1378 | return extra; |
| 1379 | } |
| 1380 | |
Johannes Schindelin | fef461e | 2018-04-25 11:54:04 +0200 | [diff] [blame] | 1381 | int for_each_mergetag(each_mergetag_fn fn, struct commit *commit, void *data) |
Christian Couder | 063da62 | 2014-07-07 08:35:37 +0200 | [diff] [blame] | 1382 | { |
| 1383 | struct commit_extra_header *extra, *to_free; |
Johannes Schindelin | fef461e | 2018-04-25 11:54:04 +0200 | [diff] [blame] | 1384 | int res = 0; |
Christian Couder | 063da62 | 2014-07-07 08:35:37 +0200 | [diff] [blame] | 1385 | |
| 1386 | to_free = read_commit_extra_headers(commit, NULL); |
Johannes Schindelin | fef461e | 2018-04-25 11:54:04 +0200 | [diff] [blame] | 1387 | for (extra = to_free; !res && extra; extra = extra->next) { |
Christian Couder | 063da62 | 2014-07-07 08:35:37 +0200 | [diff] [blame] | 1388 | if (strcmp(extra->key, "mergetag")) |
| 1389 | continue; /* not a merge tag */ |
Johannes Schindelin | fef461e | 2018-04-25 11:54:04 +0200 | [diff] [blame] | 1390 | res = fn(commit, extra, data); |
Christian Couder | 063da62 | 2014-07-07 08:35:37 +0200 | [diff] [blame] | 1391 | } |
| 1392 | free_commit_extra_headers(to_free); |
Johannes Schindelin | fef461e | 2018-04-25 11:54:04 +0200 | [diff] [blame] | 1393 | return res; |
Christian Couder | 063da62 | 2014-07-07 08:35:37 +0200 | [diff] [blame] | 1394 | } |
| 1395 | |
Junio C Hamano | ed7a42a | 2011-11-08 15:38:07 -0800 | [diff] [blame] | 1396 | static inline int standard_header_field(const char *field, size_t len) |
| 1397 | { |
René Scharfe | b072504 | 2017-02-25 20:27:40 +0100 | [diff] [blame] | 1398 | return ((len == 4 && !memcmp(field, "tree", 4)) || |
| 1399 | (len == 6 && !memcmp(field, "parent", 6)) || |
| 1400 | (len == 6 && !memcmp(field, "author", 6)) || |
| 1401 | (len == 9 && !memcmp(field, "committer", 9)) || |
| 1402 | (len == 8 && !memcmp(field, "encoding", 8))); |
Junio C Hamano | ed7a42a | 2011-11-08 15:38:07 -0800 | [diff] [blame] | 1403 | } |
| 1404 | |
Junio C Hamano | c871a1d | 2012-01-05 10:54:14 -0800 | [diff] [blame] | 1405 | static int excluded_header_field(const char *field, size_t len, const char **exclude) |
| 1406 | { |
| 1407 | if (!exclude) |
| 1408 | return 0; |
| 1409 | |
| 1410 | while (*exclude) { |
| 1411 | size_t xlen = strlen(*exclude); |
René Scharfe | b072504 | 2017-02-25 20:27:40 +0100 | [diff] [blame] | 1412 | if (len == xlen && !memcmp(field, *exclude, xlen)) |
Junio C Hamano | c871a1d | 2012-01-05 10:54:14 -0800 | [diff] [blame] | 1413 | return 1; |
| 1414 | exclude++; |
| 1415 | } |
| 1416 | return 0; |
| 1417 | } |
| 1418 | |
Junio C Hamano | 82a7529 | 2012-09-15 13:58:15 -0700 | [diff] [blame] | 1419 | static struct commit_extra_header *read_commit_extra_header_lines( |
| 1420 | const char *buffer, size_t size, |
| 1421 | const char **exclude) |
Junio C Hamano | ed7a42a | 2011-11-08 15:38:07 -0800 | [diff] [blame] | 1422 | { |
| 1423 | struct commit_extra_header *extra = NULL, **tail = &extra, *it = NULL; |
| 1424 | const char *line, *next, *eof, *eob; |
| 1425 | struct strbuf buf = STRBUF_INIT; |
| 1426 | |
| 1427 | for (line = buffer, eob = line + size; |
| 1428 | line < eob && *line != '\n'; |
| 1429 | line = next) { |
| 1430 | next = memchr(line, '\n', eob - line); |
| 1431 | next = next ? next + 1 : eob; |
| 1432 | if (*line == ' ') { |
| 1433 | /* continuation */ |
| 1434 | if (it) |
| 1435 | strbuf_add(&buf, line + 1, next - (line + 1)); |
| 1436 | continue; |
| 1437 | } |
| 1438 | if (it) |
| 1439 | it->value = strbuf_detach(&buf, &it->len); |
| 1440 | strbuf_reset(&buf); |
| 1441 | it = NULL; |
| 1442 | |
René Scharfe | 50a01cc | 2017-02-25 20:21:52 +0100 | [diff] [blame] | 1443 | eof = memchr(line, ' ', next - line); |
| 1444 | if (!eof) |
Junio C Hamano | ed7a42a | 2011-11-08 15:38:07 -0800 | [diff] [blame] | 1445 | eof = next; |
René Scharfe | b072504 | 2017-02-25 20:27:40 +0100 | [diff] [blame] | 1446 | else if (standard_header_field(line, eof - line) || |
| 1447 | excluded_header_field(line, eof - line, exclude)) |
Junio C Hamano | ed7a42a | 2011-11-08 15:38:07 -0800 | [diff] [blame] | 1448 | continue; |
| 1449 | |
René Scharfe | ca56dad | 2021-03-13 17:17:22 +0100 | [diff] [blame] | 1450 | CALLOC_ARRAY(it, 1); |
Junio C Hamano | ed7a42a | 2011-11-08 15:38:07 -0800 | [diff] [blame] | 1451 | it->key = xmemdupz(line, eof-line); |
| 1452 | *tail = it; |
| 1453 | tail = &it->next; |
| 1454 | if (eof + 1 < next) |
| 1455 | strbuf_add(&buf, eof + 1, next - (eof + 1)); |
| 1456 | } |
| 1457 | if (it) |
| 1458 | it->value = strbuf_detach(&buf, &it->len); |
| 1459 | return extra; |
Junio C Hamano | 5231c63 | 2011-11-07 16:21:32 -0800 | [diff] [blame] | 1460 | } |
| 1461 | |
| 1462 | void free_commit_extra_headers(struct commit_extra_header *extra) |
| 1463 | { |
| 1464 | while (extra) { |
| 1465 | struct commit_extra_header *next = extra->next; |
| 1466 | free(extra->key); |
| 1467 | free(extra->value); |
| 1468 | free(extra); |
| 1469 | extra = next; |
| 1470 | } |
| 1471 | } |
| 1472 | |
Patryk Obara | 5078f34 | 2018-01-28 01:13:16 +0100 | [diff] [blame] | 1473 | int commit_tree(const char *msg, size_t msg_len, const struct object_id *tree, |
| 1474 | struct commit_list *parents, struct object_id *ret, |
Junio C Hamano | ba3c69a | 2011-10-05 17:23:20 -0700 | [diff] [blame] | 1475 | const char *author, const char *sign_commit) |
Junio C Hamano | 5231c63 | 2011-11-07 16:21:32 -0800 | [diff] [blame] | 1476 | { |
| 1477 | struct commit_extra_header *extra = NULL, **tail = &extra; |
| 1478 | int result; |
| 1479 | |
| 1480 | append_merge_tag_headers(parents, &tail); |
Phillip Wood | e8cbe21 | 2020-08-17 18:40:01 +0100 | [diff] [blame] | 1481 | result = commit_tree_extended(msg, msg_len, tree, parents, ret, author, |
| 1482 | NULL, sign_commit, extra); |
Junio C Hamano | 5231c63 | 2011-11-07 16:21:32 -0800 | [diff] [blame] | 1483 | free_commit_extra_headers(extra); |
| 1484 | return result; |
| 1485 | } |
| 1486 | |
Linus Torvalds | 08a94a1 | 2012-06-28 11:24:14 -0700 | [diff] [blame] | 1487 | static int find_invalid_utf8(const char *buf, int len) |
| 1488 | { |
| 1489 | int offset = 0; |
brian m. carlson | e82bd6c | 2013-07-04 17:20:34 +0000 | [diff] [blame] | 1490 | static const unsigned int max_codepoint[] = { |
| 1491 | 0x7f, 0x7ff, 0xffff, 0x10ffff |
| 1492 | }; |
Linus Torvalds | 08a94a1 | 2012-06-28 11:24:14 -0700 | [diff] [blame] | 1493 | |
| 1494 | while (len) { |
| 1495 | unsigned char c = *buf++; |
| 1496 | int bytes, bad_offset; |
brian m. carlson | 28110d4 | 2013-07-04 17:19:43 +0000 | [diff] [blame] | 1497 | unsigned int codepoint; |
brian m. carlson | e82bd6c | 2013-07-04 17:20:34 +0000 | [diff] [blame] | 1498 | unsigned int min_val, max_val; |
Linus Torvalds | 08a94a1 | 2012-06-28 11:24:14 -0700 | [diff] [blame] | 1499 | |
| 1500 | len--; |
| 1501 | offset++; |
| 1502 | |
| 1503 | /* Simple US-ASCII? No worries. */ |
| 1504 | if (c < 0x80) |
| 1505 | continue; |
| 1506 | |
| 1507 | bad_offset = offset-1; |
| 1508 | |
| 1509 | /* |
| 1510 | * Count how many more high bits set: that's how |
| 1511 | * many more bytes this sequence should have. |
| 1512 | */ |
| 1513 | bytes = 0; |
| 1514 | while (c & 0x40) { |
| 1515 | c <<= 1; |
| 1516 | bytes++; |
| 1517 | } |
| 1518 | |
brian m. carlson | 28110d4 | 2013-07-04 17:19:43 +0000 | [diff] [blame] | 1519 | /* |
| 1520 | * Must be between 1 and 3 more bytes. Longer sequences result in |
| 1521 | * codepoints beyond U+10FFFF, which are guaranteed never to exist. |
| 1522 | */ |
| 1523 | if (bytes < 1 || 3 < bytes) |
Linus Torvalds | 08a94a1 | 2012-06-28 11:24:14 -0700 | [diff] [blame] | 1524 | return bad_offset; |
| 1525 | |
| 1526 | /* Do we *have* that many bytes? */ |
| 1527 | if (len < bytes) |
| 1528 | return bad_offset; |
| 1529 | |
brian m. carlson | e82bd6c | 2013-07-04 17:20:34 +0000 | [diff] [blame] | 1530 | /* |
| 1531 | * Place the encoded bits at the bottom of the value and compute the |
| 1532 | * valid range. |
| 1533 | */ |
brian m. carlson | 28110d4 | 2013-07-04 17:19:43 +0000 | [diff] [blame] | 1534 | codepoint = (c & 0x7f) >> bytes; |
brian m. carlson | e82bd6c | 2013-07-04 17:20:34 +0000 | [diff] [blame] | 1535 | min_val = max_codepoint[bytes-1] + 1; |
| 1536 | max_val = max_codepoint[bytes]; |
brian m. carlson | 28110d4 | 2013-07-04 17:19:43 +0000 | [diff] [blame] | 1537 | |
Linus Torvalds | 08a94a1 | 2012-06-28 11:24:14 -0700 | [diff] [blame] | 1538 | offset += bytes; |
| 1539 | len -= bytes; |
| 1540 | |
| 1541 | /* And verify that they are good continuation bytes */ |
| 1542 | do { |
brian m. carlson | 28110d4 | 2013-07-04 17:19:43 +0000 | [diff] [blame] | 1543 | codepoint <<= 6; |
| 1544 | codepoint |= *buf & 0x3f; |
Linus Torvalds | 08a94a1 | 2012-06-28 11:24:14 -0700 | [diff] [blame] | 1545 | if ((*buf++ & 0xc0) != 0x80) |
| 1546 | return bad_offset; |
| 1547 | } while (--bytes); |
| 1548 | |
brian m. carlson | e82bd6c | 2013-07-04 17:20:34 +0000 | [diff] [blame] | 1549 | /* Reject codepoints that are out of range for the sequence length. */ |
| 1550 | if (codepoint < min_val || codepoint > max_val) |
brian m. carlson | 28110d4 | 2013-07-04 17:19:43 +0000 | [diff] [blame] | 1551 | return bad_offset; |
| 1552 | /* Surrogates are only for UTF-16 and cannot be encoded in UTF-8. */ |
| 1553 | if ((codepoint & 0x1ff800) == 0xd800) |
| 1554 | return bad_offset; |
Peter Krefting | 81050ac | 2013-07-09 12:16:33 +0100 | [diff] [blame] | 1555 | /* U+xxFFFE and U+xxFFFF are guaranteed non-characters. */ |
Junio C Hamano | dc773a6 | 2013-08-05 09:52:28 -0700 | [diff] [blame] | 1556 | if ((codepoint & 0xfffe) == 0xfffe) |
Peter Krefting | 81050ac | 2013-07-09 12:16:33 +0100 | [diff] [blame] | 1557 | return bad_offset; |
| 1558 | /* So are anything in the range U+FDD0..U+FDEF. */ |
| 1559 | if (codepoint >= 0xfdd0 && codepoint <= 0xfdef) |
brian m. carlson | 28110d4 | 2013-07-04 17:19:43 +0000 | [diff] [blame] | 1560 | return bad_offset; |
Linus Torvalds | 08a94a1 | 2012-06-28 11:24:14 -0700 | [diff] [blame] | 1561 | } |
| 1562 | return -1; |
| 1563 | } |
| 1564 | |
| 1565 | /* |
| 1566 | * This verifies that the buffer is in proper utf8 format. |
| 1567 | * |
| 1568 | * If it isn't, it assumes any non-utf8 characters are Latin1, |
| 1569 | * and does the conversion. |
Linus Torvalds | 08a94a1 | 2012-06-28 11:24:14 -0700 | [diff] [blame] | 1570 | */ |
| 1571 | static int verify_utf8(struct strbuf *buf) |
| 1572 | { |
| 1573 | int ok = 1; |
| 1574 | long pos = 0; |
| 1575 | |
| 1576 | for (;;) { |
| 1577 | int bad; |
| 1578 | unsigned char c; |
| 1579 | unsigned char replace[2]; |
| 1580 | |
| 1581 | bad = find_invalid_utf8(buf->buf + pos, buf->len - pos); |
| 1582 | if (bad < 0) |
| 1583 | return ok; |
| 1584 | pos += bad; |
| 1585 | ok = 0; |
| 1586 | c = buf->buf[pos]; |
| 1587 | strbuf_remove(buf, pos, 1); |
| 1588 | |
| 1589 | /* We know 'c' must be in the range 128-255 */ |
| 1590 | replace[0] = 0xc0 + (c >> 6); |
| 1591 | replace[1] = 0x80 + (c & 0x3f); |
| 1592 | strbuf_insert(buf, pos, replace, 2); |
| 1593 | pos += 2; |
| 1594 | } |
| 1595 | } |
| 1596 | |
Jeff King | 40d52ff | 2010-04-01 20:05:23 -0400 | [diff] [blame] | 1597 | static const char commit_utf8_warn[] = |
Vasco Almeida | 4fa4b31 | 2016-09-19 13:08:16 +0000 | [diff] [blame] | 1598 | N_("Warning: commit message did not conform to UTF-8.\n" |
| 1599 | "You may want to amend it after fixing the message, or set the config\n" |
Jiang Xin | b4eda05 | 2022-06-17 18:03:09 +0800 | [diff] [blame] | 1600 | "variable i18n.commitEncoding to the encoding your project uses.\n"); |
Jeff King | 40d52ff | 2010-04-01 20:05:23 -0400 | [diff] [blame] | 1601 | |
Jeff King | 3ffefb5 | 2014-06-10 17:36:52 -0400 | [diff] [blame] | 1602 | int commit_tree_extended(const char *msg, size_t msg_len, |
Patryk Obara | 5078f34 | 2018-01-28 01:13:16 +0100 | [diff] [blame] | 1603 | const struct object_id *tree, |
| 1604 | struct commit_list *parents, struct object_id *ret, |
Phillip Wood | e8cbe21 | 2020-08-17 18:40:01 +0100 | [diff] [blame] | 1605 | const char *author, const char *committer, |
| 1606 | const char *sign_commit, |
Junio C Hamano | ba3c69a | 2011-10-05 17:23:20 -0700 | [diff] [blame] | 1607 | struct commit_extra_header *extra) |
Jeff King | 40d52ff | 2010-04-01 20:05:23 -0400 | [diff] [blame] | 1608 | { |
| 1609 | int result; |
| 1610 | int encoding_is_utf8; |
| 1611 | struct strbuf buffer; |
| 1612 | |
brian m. carlson | e816caa | 2018-03-12 02:27:42 +0000 | [diff] [blame] | 1613 | assert_oid_type(tree, OBJ_TREE); |
Jeff King | 40d52ff | 2010-04-01 20:05:23 -0400 | [diff] [blame] | 1614 | |
Jeff King | 3ffefb5 | 2014-06-10 17:36:52 -0400 | [diff] [blame] | 1615 | if (memchr(msg, '\0', msg_len)) |
Nguyễn Thái Ngọc Duy | 37576c1 | 2011-12-15 20:47:23 +0700 | [diff] [blame] | 1616 | return error("a NUL byte in commit log message not allowed."); |
| 1617 | |
Jeff King | 40d52ff | 2010-04-01 20:05:23 -0400 | [diff] [blame] | 1618 | /* Not having i18n.commitencoding is the same as having utf-8 */ |
| 1619 | encoding_is_utf8 = is_encoding_utf8(git_commit_encoding); |
| 1620 | |
| 1621 | strbuf_init(&buffer, 8192); /* should avoid reallocs for the headers */ |
Patryk Obara | 5078f34 | 2018-01-28 01:13:16 +0100 | [diff] [blame] | 1622 | strbuf_addf(&buffer, "tree %s\n", oid_to_hex(tree)); |
Jeff King | 40d52ff | 2010-04-01 20:05:23 -0400 | [diff] [blame] | 1623 | |
| 1624 | /* |
| 1625 | * NOTE! This ordering means that the same exact tree merged with a |
| 1626 | * different order of parents will be a _different_ changeset even |
| 1627 | * if everything else stays the same. |
| 1628 | */ |
| 1629 | while (parents) { |
René Scharfe | e510ab8 | 2015-10-24 18:21:31 +0200 | [diff] [blame] | 1630 | struct commit *parent = pop_commit(&parents); |
Jeff King | 40d52ff | 2010-04-01 20:05:23 -0400 | [diff] [blame] | 1631 | strbuf_addf(&buffer, "parent %s\n", |
brian m. carlson | f2fd076 | 2015-11-10 02:22:28 +0000 | [diff] [blame] | 1632 | oid_to_hex(&parent->object.oid)); |
Jeff King | 40d52ff | 2010-04-01 20:05:23 -0400 | [diff] [blame] | 1633 | } |
| 1634 | |
| 1635 | /* Person/date information */ |
| 1636 | if (!author) |
Jeff King | f9bc573 | 2012-05-24 19:28:40 -0400 | [diff] [blame] | 1637 | author = git_author_info(IDENT_STRICT); |
Jeff King | 40d52ff | 2010-04-01 20:05:23 -0400 | [diff] [blame] | 1638 | strbuf_addf(&buffer, "author %s\n", author); |
Phillip Wood | e8cbe21 | 2020-08-17 18:40:01 +0100 | [diff] [blame] | 1639 | if (!committer) |
| 1640 | committer = git_committer_info(IDENT_STRICT); |
| 1641 | strbuf_addf(&buffer, "committer %s\n", committer); |
Jeff King | 40d52ff | 2010-04-01 20:05:23 -0400 | [diff] [blame] | 1642 | if (!encoding_is_utf8) |
| 1643 | strbuf_addf(&buffer, "encoding %s\n", git_commit_encoding); |
Junio C Hamano | 5231c63 | 2011-11-07 16:21:32 -0800 | [diff] [blame] | 1644 | |
| 1645 | while (extra) { |
| 1646 | add_extra_header(&buffer, extra); |
| 1647 | extra = extra->next; |
| 1648 | } |
Jeff King | 40d52ff | 2010-04-01 20:05:23 -0400 | [diff] [blame] | 1649 | strbuf_addch(&buffer, '\n'); |
| 1650 | |
| 1651 | /* And add the comment */ |
Jeff King | 3ffefb5 | 2014-06-10 17:36:52 -0400 | [diff] [blame] | 1652 | strbuf_add(&buffer, msg, msg_len); |
Jeff King | 40d52ff | 2010-04-01 20:05:23 -0400 | [diff] [blame] | 1653 | |
| 1654 | /* And check the encoding */ |
Linus Torvalds | 08a94a1 | 2012-06-28 11:24:14 -0700 | [diff] [blame] | 1655 | if (encoding_is_utf8 && !verify_utf8(&buffer)) |
Vasco Almeida | 4fa4b31 | 2016-09-19 13:08:16 +0000 | [diff] [blame] | 1656 | fprintf(stderr, _(commit_utf8_warn)); |
Jeff King | 40d52ff | 2010-04-01 20:05:23 -0400 | [diff] [blame] | 1657 | |
brian m. carlson | 937032e | 2021-02-11 02:08:04 +0000 | [diff] [blame] | 1658 | if (sign_commit && sign_with_header(&buffer, sign_commit)) { |
Rene Scharfe | e505146 | 2017-08-30 19:49:38 +0200 | [diff] [blame] | 1659 | result = -1; |
| 1660 | goto out; |
| 1661 | } |
Junio C Hamano | ba3c69a | 2011-10-05 17:23:20 -0700 | [diff] [blame] | 1662 | |
Ævar Arnfjörð Bjarmason | c80d226 | 2022-02-05 00:48:26 +0100 | [diff] [blame] | 1663 | result = write_object_file(buffer.buf, buffer.len, OBJ_COMMIT, ret); |
Rene Scharfe | e505146 | 2017-08-30 19:49:38 +0200 | [diff] [blame] | 1664 | out: |
Jeff King | 40d52ff | 2010-04-01 20:05:23 -0400 | [diff] [blame] | 1665 | strbuf_release(&buffer); |
| 1666 | return result; |
| 1667 | } |
Junio C Hamano | ae8e4c9 | 2011-11-07 13:26:22 -0800 | [diff] [blame] | 1668 | |
Nguyễn Thái Ngọc Duy | e2e5ac2 | 2018-05-19 07:28:30 +0200 | [diff] [blame] | 1669 | define_commit_slab(merge_desc_slab, struct merge_remote_desc *); |
| 1670 | static struct merge_desc_slab merge_desc_slab = COMMIT_SLAB_INIT(1, merge_desc_slab); |
| 1671 | |
| 1672 | struct merge_remote_desc *merge_remote_util(struct commit *commit) |
| 1673 | { |
| 1674 | return *merge_desc_slab_at(&merge_desc_slab, commit); |
| 1675 | } |
| 1676 | |
René Scharfe | beb518c | 2016-08-13 14:11:27 +0200 | [diff] [blame] | 1677 | void set_merge_remote_desc(struct commit *commit, |
| 1678 | const char *name, struct object *obj) |
| 1679 | { |
| 1680 | struct merge_remote_desc *desc; |
René Scharfe | 5447a76 | 2016-08-13 14:21:27 +0200 | [diff] [blame] | 1681 | FLEX_ALLOC_STR(desc, name, name); |
René Scharfe | beb518c | 2016-08-13 14:11:27 +0200 | [diff] [blame] | 1682 | desc->obj = obj; |
Nguyễn Thái Ngọc Duy | e2e5ac2 | 2018-05-19 07:28:30 +0200 | [diff] [blame] | 1683 | *merge_desc_slab_at(&merge_desc_slab, commit) = desc; |
René Scharfe | beb518c | 2016-08-13 14:11:27 +0200 | [diff] [blame] | 1684 | } |
| 1685 | |
Junio C Hamano | ae8e4c9 | 2011-11-07 13:26:22 -0800 | [diff] [blame] | 1686 | struct commit *get_merge_parent(const char *name) |
| 1687 | { |
| 1688 | struct object *obj; |
| 1689 | struct commit *commit; |
brian m. carlson | 7683e2e | 2015-03-13 23:39:34 +0000 | [diff] [blame] | 1690 | struct object_id oid; |
Ævar Arnfjörð Bjarmason | d850b7a | 2023-03-28 15:58:46 +0200 | [diff] [blame] | 1691 | if (repo_get_oid(the_repository, name, &oid)) |
Junio C Hamano | ae8e4c9 | 2011-11-07 13:26:22 -0800 | [diff] [blame] | 1692 | return NULL; |
Stefan Beller | 109cd76 | 2018-06-28 18:21:51 -0700 | [diff] [blame] | 1693 | obj = parse_object(the_repository, &oid); |
Ævar Arnfjörð Bjarmason | d850b7a | 2023-03-28 15:58:46 +0200 | [diff] [blame] | 1694 | commit = (struct commit *)repo_peel_to_type(the_repository, name, 0, |
| 1695 | obj, OBJ_COMMIT); |
Nguyễn Thái Ngọc Duy | e2e5ac2 | 2018-05-19 07:28:30 +0200 | [diff] [blame] | 1696 | if (commit && !merge_remote_util(commit)) |
René Scharfe | beb518c | 2016-08-13 14:11:27 +0200 | [diff] [blame] | 1697 | set_merge_remote_desc(commit, name, obj); |
Junio C Hamano | ae8e4c9 | 2011-11-07 13:26:22 -0800 | [diff] [blame] | 1698 | return commit; |
| 1699 | } |
René Scharfe | 89b5f1d | 2012-04-25 22:35:27 +0200 | [diff] [blame] | 1700 | |
| 1701 | /* |
| 1702 | * Append a commit to the end of the commit_list. |
| 1703 | * |
| 1704 | * next starts by pointing to the variable that holds the head of an |
| 1705 | * empty commit_list, and is updated to point to the "next" field of |
| 1706 | * the last item on the list as new commits are appended. |
| 1707 | * |
| 1708 | * Usage example: |
| 1709 | * |
| 1710 | * struct commit_list *list; |
| 1711 | * struct commit_list **next = &list; |
| 1712 | * |
| 1713 | * next = commit_list_append(c1, next); |
| 1714 | * next = commit_list_append(c2, next); |
| 1715 | * assert(commit_list_count(list) == 2); |
| 1716 | * return list; |
| 1717 | */ |
| 1718 | struct commit_list **commit_list_append(struct commit *commit, |
| 1719 | struct commit_list **next) |
| 1720 | { |
Brandon Williams | 258c03e | 2018-02-14 10:59:37 -0800 | [diff] [blame] | 1721 | struct commit_list *new_commit = xmalloc(sizeof(struct commit_list)); |
| 1722 | new_commit->item = commit; |
| 1723 | *next = new_commit; |
| 1724 | new_commit->next = NULL; |
| 1725 | return &new_commit->next; |
René Scharfe | 89b5f1d | 2012-04-25 22:35:27 +0200 | [diff] [blame] | 1726 | } |
Nguyễn Thái Ngọc Duy | efc7df4 | 2012-10-26 22:53:51 +0700 | [diff] [blame] | 1727 | |
John Cai | cfc5cf4 | 2022-01-06 20:07:35 +0000 | [diff] [blame] | 1728 | const char *find_header_mem(const char *msg, size_t len, |
| 1729 | const char *key, size_t *out_len) |
Jeff King | fe6eb7f | 2014-08-27 03:56:01 -0400 | [diff] [blame] | 1730 | { |
| 1731 | int key_len = strlen(key); |
| 1732 | const char *line = msg; |
| 1733 | |
John Cai | cfc5cf4 | 2022-01-06 20:07:35 +0000 | [diff] [blame] | 1734 | /* |
| 1735 | * NEEDSWORK: It's possible for strchrnul() to scan beyond the range |
| 1736 | * given by len. However, current callers are safe because they compute |
| 1737 | * len by scanning a NUL-terminated block of memory starting at msg. |
| 1738 | * Nonetheless, it would be better to ensure the function does not look |
| 1739 | * at msg beyond the len provided by the caller. |
| 1740 | */ |
| 1741 | while (line && line < msg + len) { |
Jeff King | fe6eb7f | 2014-08-27 03:56:01 -0400 | [diff] [blame] | 1742 | const char *eol = strchrnul(line, '\n'); |
| 1743 | |
| 1744 | if (line == eol) |
| 1745 | return NULL; |
| 1746 | |
| 1747 | if (eol - line > key_len && |
| 1748 | !strncmp(line, key, key_len) && |
| 1749 | line[key_len] == ' ') { |
| 1750 | *out_len = eol - line - key_len - 1; |
| 1751 | return line + key_len + 1; |
| 1752 | } |
| 1753 | line = *eol ? eol + 1 : NULL; |
| 1754 | } |
| 1755 | return NULL; |
| 1756 | } |
Junio C Hamano | 0ed8a4e | 2014-12-22 12:26:23 -0800 | [diff] [blame] | 1757 | |
John Cai | cfc5cf4 | 2022-01-06 20:07:35 +0000 | [diff] [blame] | 1758 | const char *find_commit_header(const char *msg, const char *key, size_t *out_len) |
| 1759 | { |
| 1760 | return find_header_mem(msg, strlen(msg), key, out_len); |
| 1761 | } |
Christian Couder | 8c38458 | 2014-11-09 10:23:41 +0100 | [diff] [blame] | 1762 | /* |
Jonathan Tan | 710714a | 2016-11-02 10:29:17 -0700 | [diff] [blame] | 1763 | * Inspect the given string and determine the true "end" of the log message, in |
Bradley M. Kuhn | 3abd4a6 | 2020-10-19 18:03:55 -0700 | [diff] [blame] | 1764 | * order to find where to put a new Signed-off-by trailer. Ignored are |
Brian Malehorn | d76650b | 2017-05-15 23:06:49 -0700 | [diff] [blame] | 1765 | * trailing comment lines and blank lines. To support "git commit -s |
| 1766 | * --amend" on an existing commit, we also ignore "Conflicts:". To |
| 1767 | * support "git commit -v", we truncate at cut lines. |
Christian Couder | 8c38458 | 2014-11-09 10:23:41 +0100 | [diff] [blame] | 1768 | * |
| 1769 | * Returns the number of bytes from the tail to ignore, to be fed as |
| 1770 | * the second parameter to append_signoff(). |
| 1771 | */ |
Jeff King | 66e83d9 | 2018-08-22 20:50:51 -0400 | [diff] [blame] | 1772 | size_t ignore_non_trailer(const char *buf, size_t len) |
Christian Couder | 8c38458 | 2014-11-09 10:23:41 +0100 | [diff] [blame] | 1773 | { |
Jeff King | 66e83d9 | 2018-08-22 20:50:51 -0400 | [diff] [blame] | 1774 | size_t boc = 0; |
| 1775 | size_t bol = 0; |
Christian Couder | 8c38458 | 2014-11-09 10:23:41 +0100 | [diff] [blame] | 1776 | int in_old_conflicts_block = 0; |
Brian Malehorn | d76650b | 2017-05-15 23:06:49 -0700 | [diff] [blame] | 1777 | size_t cutoff = wt_status_locate_end(buf, len); |
Christian Couder | 8c38458 | 2014-11-09 10:23:41 +0100 | [diff] [blame] | 1778 | |
Brian Malehorn | d76650b | 2017-05-15 23:06:49 -0700 | [diff] [blame] | 1779 | while (bol < cutoff) { |
Jonathan Tan | 710714a | 2016-11-02 10:29:17 -0700 | [diff] [blame] | 1780 | const char *next_line = memchr(buf + bol, '\n', len - bol); |
Christian Couder | 8c38458 | 2014-11-09 10:23:41 +0100 | [diff] [blame] | 1781 | |
Jonathan Tan | 710714a | 2016-11-02 10:29:17 -0700 | [diff] [blame] | 1782 | if (!next_line) |
| 1783 | next_line = buf + len; |
Christian Couder | 8c38458 | 2014-11-09 10:23:41 +0100 | [diff] [blame] | 1784 | else |
| 1785 | next_line++; |
| 1786 | |
Jonathan Tan | 710714a | 2016-11-02 10:29:17 -0700 | [diff] [blame] | 1787 | if (buf[bol] == comment_line_char || buf[bol] == '\n') { |
Christian Couder | 8c38458 | 2014-11-09 10:23:41 +0100 | [diff] [blame] | 1788 | /* is this the first of the run of comments? */ |
| 1789 | if (!boc) |
| 1790 | boc = bol; |
| 1791 | /* otherwise, it is just continuing */ |
Jonathan Tan | 710714a | 2016-11-02 10:29:17 -0700 | [diff] [blame] | 1792 | } else if (starts_with(buf + bol, "Conflicts:\n")) { |
Christian Couder | 8c38458 | 2014-11-09 10:23:41 +0100 | [diff] [blame] | 1793 | in_old_conflicts_block = 1; |
| 1794 | if (!boc) |
| 1795 | boc = bol; |
Jonathan Tan | 710714a | 2016-11-02 10:29:17 -0700 | [diff] [blame] | 1796 | } else if (in_old_conflicts_block && buf[bol] == '\t') { |
Christian Couder | 8c38458 | 2014-11-09 10:23:41 +0100 | [diff] [blame] | 1797 | ; /* a pathname in the conflicts block */ |
| 1798 | } else if (boc) { |
| 1799 | /* the previous was not trailing comment */ |
| 1800 | boc = 0; |
| 1801 | in_old_conflicts_block = 0; |
| 1802 | } |
Jonathan Tan | 710714a | 2016-11-02 10:29:17 -0700 | [diff] [blame] | 1803 | bol = next_line - buf; |
Christian Couder | 8c38458 | 2014-11-09 10:23:41 +0100 | [diff] [blame] | 1804 | } |
Brian Malehorn | d76650b | 2017-05-15 23:06:49 -0700 | [diff] [blame] | 1805 | return boc ? len - boc : len - cutoff; |
Christian Couder | 8c38458 | 2014-11-09 10:23:41 +0100 | [diff] [blame] | 1806 | } |
Phillip Wood | 49697cb | 2019-10-15 10:25:31 +0000 | [diff] [blame] | 1807 | |
| 1808 | int run_commit_hook(int editor_is_used, const char *index_file, |
Ævar Arnfjörð Bjarmason | a8cc594 | 2022-03-07 13:33:46 +0100 | [diff] [blame] | 1809 | int *invoked_hook, const char *name, ...) |
Phillip Wood | 49697cb | 2019-10-15 10:25:31 +0000 | [diff] [blame] | 1810 | { |
Emily Shaffer | f443246 | 2021-12-22 04:59:40 +0100 | [diff] [blame] | 1811 | struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT; |
Phillip Wood | 49697cb | 2019-10-15 10:25:31 +0000 | [diff] [blame] | 1812 | va_list args; |
Emily Shaffer | f443246 | 2021-12-22 04:59:40 +0100 | [diff] [blame] | 1813 | const char *arg; |
Phillip Wood | 49697cb | 2019-10-15 10:25:31 +0000 | [diff] [blame] | 1814 | |
Emily Shaffer | f443246 | 2021-12-22 04:59:40 +0100 | [diff] [blame] | 1815 | strvec_pushf(&opt.env, "GIT_INDEX_FILE=%s", index_file); |
Phillip Wood | 49697cb | 2019-10-15 10:25:31 +0000 | [diff] [blame] | 1816 | |
| 1817 | /* |
| 1818 | * Let the hook know that no editor will be launched. |
| 1819 | */ |
| 1820 | if (!editor_is_used) |
Emily Shaffer | f443246 | 2021-12-22 04:59:40 +0100 | [diff] [blame] | 1821 | strvec_push(&opt.env, "GIT_EDITOR=:"); |
Phillip Wood | 49697cb | 2019-10-15 10:25:31 +0000 | [diff] [blame] | 1822 | |
| 1823 | va_start(args, name); |
Emily Shaffer | f443246 | 2021-12-22 04:59:40 +0100 | [diff] [blame] | 1824 | while ((arg = va_arg(args, const char *))) |
| 1825 | strvec_push(&opt.args, arg); |
Phillip Wood | 49697cb | 2019-10-15 10:25:31 +0000 | [diff] [blame] | 1826 | va_end(args); |
Phillip Wood | 49697cb | 2019-10-15 10:25:31 +0000 | [diff] [blame] | 1827 | |
Ævar Arnfjörð Bjarmason | 4369e3a | 2022-03-22 00:15:13 +0100 | [diff] [blame] | 1828 | opt.invoked_hook = invoked_hook; |
Emily Shaffer | f443246 | 2021-12-22 04:59:40 +0100 | [diff] [blame] | 1829 | return run_hooks_opt(name, &opt); |
Phillip Wood | 49697cb | 2019-10-15 10:25:31 +0000 | [diff] [blame] | 1830 | } |