blob: b3223478bc2a3ac98751e41ba133a41d3ba34bc0 [file] [log] [blame]
Elijah Newrend812c3b2023-04-11 00:41:56 -07001#include "git-compat-util.h"
Linus Torvalds961784e2005-05-18 16:14:22 -07002#include "tag.h"
Daniel Barkalow175785e2005-04-18 11:39:48 -07003#include "commit.h"
Derrick Stolee177722b2018-04-10 08:56:05 -04004#include "commit-graph.h"
Elijah Newren7ee24e12023-03-21 06:25:57 +00005#include "environment.h"
Elijah Newrenf394e092023-03-21 06:25:54 +00006#include "gettext.h"
Elijah Newren41771fa2023-02-24 00:09:27 +00007#include "hex.h"
Jonathan Nieder6a1a79f2018-05-15 16:42:16 -07008#include "repository.h"
Elijah Newrendabab1d2023-04-11 00:41:49 -07009#include "object-name.h"
Elijah Newrena034e912023-05-16 06:34:06 +000010#include "object-store-ll.h"
Johannes Schindelined09aef2006-10-30 20:09:06 +010011#include "pkt-line.h"
Junio C Hamano52883fb2006-12-25 11:48:35 -080012#include "utf8.h"
Junio C Hamano199c45b2007-04-09 02:34:05 -070013#include "diff.h"
14#include "revision.h"
Johannes Schindelina97a7462009-10-09 12:21:57 +020015#include "notes.h"
Stefan Beller14ba97f2018-05-15 14:48:42 -070016#include "alloc.h"
Junio C Hamanoba3c69a2011-10-05 17:23:20 -070017#include "gpg-interface.h"
René Scharfe46905892012-04-01 00:10:39 +020018#include "mergesort.h"
Junio C Hamanoa84b7942013-04-13 11:56:41 -070019#include "commit-slab.h"
Junio C Hamanoda24b102013-06-06 21:58:12 -070020#include "prio-queue.h"
Martin Ågrenbc626922020-12-31 12:56:23 +010021#include "hash-lookup.h"
Brian Malehornd76650b2017-05-15 23:06:49 -070022#include "wt-status.h"
Johannes Schindelinf9f99b32018-04-29 00:44:44 +020023#include "advice.h"
Pratik Karki103148a2018-09-04 15:00:08 -070024#include "refs.h"
Junio C Hamano02931212018-11-02 11:04:55 +090025#include "commit-reach.h"
Phillip Wood49697cb2019-10-15 10:25:31 +000026#include "run-command.h"
Elijah Newrene38da482023-03-21 06:26:05 +000027#include "setup.h"
Taylor Blau120ad2b2020-04-30 13:48:50 -060028#include "shallow.h"
Elijah Newrend4a4f922023-04-22 20:17:26 +000029#include "tree.h"
Emily Shafferf4432462021-12-22 04:59:40 +010030#include "hook.h"
Daniel Barkalow175785e2005-04-18 11:39:48 -070031
Junio C Hamano82a75292012-09-15 13:58:15 -070032static struct commit_extra_header *read_commit_extra_header_lines(const char *buf, size_t len, const char **);
33
Linus Torvalds60ab26d2005-09-15 14:43:17 -070034int save_commit_buffer = 1;
Ævar Arnfjörð Bjarmasonab628582021-08-23 12:44:02 +020035int no_graft_file_deprecated_advice;
Linus Torvalds60ab26d2005-09-15 14:43:17 -070036
Daniel Barkalow175785e2005-04-18 11:39:48 -070037const char *commit_type = "commit";
38
Stefan Bellerd9a05e72018-06-28 18:22:21 -070039struct commit *lookup_commit_reference_gently(struct repository *r,
Stefan Beller21e1ee82018-06-28 18:21:57 -070040 const struct object_id *oid, int quiet)
Linus Torvalds961784e2005-05-18 16:14:22 -070041{
Stefan Bellerd9a05e72018-06-28 18:22:21 -070042 struct object *obj = deref_tag(r,
43 parse_object(r, oid),
Stefan Beller109cd762018-06-28 18:21:51 -070044 NULL, 0);
Linus Torvalds961784e2005-05-18 16:14:22 -070045
46 if (!obj)
47 return NULL;
Abhishek Kumar6da43d92020-06-17 14:44:08 +053048 return object_as_type(obj, OBJ_COMMIT, quiet);
Junio C Hamanof76412e2005-08-21 02:51:10 -070049}
50
Stefan Beller1f6c72f2018-06-28 18:22:22 -070051struct commit *lookup_commit_reference(struct repository *r, const struct object_id *oid)
Junio C Hamanof76412e2005-08-21 02:51:10 -070052{
Stefan Beller1f6c72f2018-06-28 18:22:22 -070053 return lookup_commit_reference_gently(r, oid, 0);
Linus Torvalds961784e2005-05-18 16:14:22 -070054}
55
brian m. carlsonbc832662017-05-06 22:10:10 +000056struct commit *lookup_commit_or_die(const struct object_id *oid, const char *ref_name)
Nguyễn Thái Ngọc Duybaf18fc2011-09-17 21:57:45 +100057{
Stefan Beller2122f672018-06-28 18:21:58 -070058 struct commit *c = lookup_commit_reference(the_repository, oid);
Nguyễn Thái Ngọc Duybaf18fc2011-09-17 21:57:45 +100059 if (!c)
60 die(_("could not parse %s"), ref_name);
Jeff King9001dc22018-08-28 17:22:48 -040061 if (!oideq(oid, &c->object.oid)) {
Nguyễn Thái Ngọc Duybaf18fc2011-09-17 21:57:45 +100062 warning(_("%s %s is not a commit!"),
brian m. carlsonbc832662017-05-06 22:10:10 +000063 ref_name, oid_to_hex(oid));
Nguyễn Thái Ngọc Duybaf18fc2011-09-17 21:57:45 +100064 }
65 return c;
66}
67
Phillip Woodb8dbfd02022-10-17 13:17:40 +000068struct 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 Bellerbacf1682018-06-28 18:22:10 -070076struct commit *lookup_commit(struct repository *r, const struct object_id *oid)
Daniel Barkalow175785e2005-04-18 11:39:48 -070077{
Jeff Kingd0229ab2019-06-20 03:41:14 -040078 struct object *obj = lookup_object(r, oid);
Jeff Kingd36f51c2014-07-13 02:41:55 -040079 if (!obj)
Jeff Kinga3785092019-06-20 03:41:21 -040080 return create_object(r, oid, alloc_commit_node(r));
Abhishek Kumar6da43d92020-06-17 14:44:08 +053081 return object_as_type(obj, OBJ_COMMIT, 0);
Daniel Barkalow175785e2005-04-18 11:39:48 -070082}
83
Pat Notza6fa5992010-11-02 13:59:07 -060084struct commit *lookup_commit_reference_by_name(const char *name)
85{
brian m. carlson7683e2e2015-03-13 23:39:34 +000086 struct object_id oid;
Pat Notza6fa5992010-11-02 13:59:07 -060087 struct commit *commit;
88
Ævar Arnfjörð Bjarmasond850b7a2023-03-28 15:58:46 +020089 if (repo_get_oid_committish(the_repository, name, &oid))
Pat Notza6fa5992010-11-02 13:59:07 -060090 return NULL;
Stefan Beller2122f672018-06-28 18:21:58 -070091 commit = lookup_commit_reference(the_repository, &oid);
Ævar Arnfjörð Bjarmasonecb50912023-03-28 15:58:48 +020092 if (repo_parse_commit(the_repository, commit))
Pat Notza6fa5992010-11-02 13:59:07 -060093 return NULL;
94 return commit;
95}
96
Johannes Schindelindddbad72017-04-26 21:29:31 +020097static timestamp_t parse_commit_date(const char *buf, const char *tail)
Daniel Barkalow175785e2005-04-18 11:39:48 -070098{
Martin Koegler0a617792008-01-19 18:35:23 +010099 const char *dateptr;
Jeff Kingea1615d2023-04-27 04:14:09 -0400100 const char *eol;
Daniel Barkalow175785e2005-04-18 11:39:48 -0700101
Martin Koegler0a617792008-01-19 18:35:23 +0100102 if (buf + 6 >= tail)
103 return 0;
Daniel Barkalow175785e2005-04-18 11:39:48 -0700104 if (memcmp(buf, "author", 6))
105 return 0;
Martin Koegler0a617792008-01-19 18:35:23 +0100106 while (buf < tail && *buf++ != '\n')
Daniel Barkalow175785e2005-04-18 11:39:48 -0700107 /* nada */;
Martin Koegler0a617792008-01-19 18:35:23 +0100108 if (buf + 9 >= tail)
109 return 0;
Daniel Barkalow175785e2005-04-18 11:39:48 -0700110 if (memcmp(buf, "committer", 9))
111 return 0;
Jeff Kingea1615d2023-04-27 04:14:09 -0400112
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 Koegler0a617792008-01-19 18:35:23 +0100121 return 0;
Jeff Kingea1615d2023-04-27 04:14:09 -0400122 dateptr = eol;
123 while (dateptr > buf && dateptr[-1] != '>')
124 dateptr--;
Jeff King089d9ad2023-04-27 04:17:15 -0400125 if (dateptr == buf)
Martin Koegler0a617792008-01-19 18:35:23 +0100126 return 0;
Jeff Kingea1615d2023-04-27 04:14:09 -0400127
Jeff King089d9ad2023-04-27 04:17:15 -0400128 /*
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 King90ef0f12023-04-27 04:17:24 -0400152 *
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 King089d9ad2023-04-27 04:17:15 -0400161 */
Johannes Schindelin1aeb7e72017-04-21 12:45:44 +0200162 return parse_timestamp(dateptr, NULL, 10);
Daniel Barkalow175785e2005-04-18 11:39:48 -0700163}
164
Jeff King8380dcd2021-01-28 01:20:23 -0500165static const struct object_id *commit_graft_oid_access(size_t index, const void *table)
Dmitry S. Dolzhenko0a9136f2014-02-26 22:49:22 +0400166{
Jeff King8380dcd2021-01-28 01:20:23 -0500167 const struct commit_graft * const *commit_graft_table = table;
Jeff King45ee13b2021-01-28 01:19:42 -0500168 return &commit_graft_table[index]->oid;
Dmitry S. Dolzhenko0a9136f2014-02-26 22:49:22 +0400169}
170
Jeff King98c431b2021-01-28 01:12:35 -0500171int commit_graft_pos(struct repository *r, const struct object_id *oid)
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700172{
Jeff King45ee13b2021-01-28 01:19:42 -0500173 return oid_pos(oid, r->parsed_objects->grafts,
174 r->parsed_objects->grafts_nr,
175 commit_graft_oid_access);
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700176}
177
Jonathan Tan4d4e49f2022-06-06 10:54:37 -0700178static 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 Williamsa3b78e82018-05-17 15:51:48 -0700189int register_commit_graft(struct repository *r, struct commit_graft *graft,
190 int ignore_dups)
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700191{
Jeff King98c431b2021-01-28 01:12:35 -0500192 int pos = commit_graft_pos(r, &graft->oid);
Junio C Hamanoa6080a02007-06-07 00:04:01 -0700193
Junio C Hamano5040f172006-04-06 23:58:51 -0700194 if (0 <= pos) {
195 if (ignore_dups)
196 free(graft);
197 else {
Brandon Williamsa3b78e82018-05-17 15:51:48 -0700198 free(r->parsed_objects->grafts[pos]);
199 r->parsed_objects->grafts[pos] = graft;
Junio C Hamano5040f172006-04-06 23:58:51 -0700200 }
201 return 1;
202 }
203 pos = -pos - 1;
Brandon Williamsa3b78e82018-05-17 15:51:48 -0700204 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 Tan4d4e49f2022-06-06 10:54:37 -0700214 unparse_commit(r, &graft->oid);
Junio C Hamano5040f172006-04-06 23:58:51 -0700215 return 0;
216}
217
Patryk Obara9a934032017-08-18 20:33:12 +0200218struct commit_graft *read_graft_line(struct strbuf *line)
Junio C Hamano5040f172006-04-06 23:58:51 -0700219{
220 /* The format is just "Commit Parent1 Parent2 ...\n" */
Patryk Obaracfa5bf12017-08-18 20:33:14 +0200221 int i, phase;
222 const char *tail = NULL;
Junio C Hamano5040f172006-04-06 23:58:51 -0700223 struct commit_graft *graft = NULL;
Patryk Obaracfa5bf12017-08-18 20:33:14 +0200224 struct object_id dummy_oid, *oid;
Junio C Hamano5040f172006-04-06 23:58:51 -0700225
Patryk Obara9a934032017-08-18 20:33:12 +0200226 strbuf_rtrim(line);
227 if (!line->len || line->buf[0] == '#')
Junio C Hamano5bc4ce52006-04-16 14:24:56 -0700228 return NULL;
Patryk Obaracfa5bf12017-08-18 20:33:14 +0200229 /*
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 Hamano5040f172006-04-06 23:58:51 -0700236 goto bad_graft_data;
Patryk Obaracfa5bf12017-08-18 20:33:14 +0200237 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 Hamano5040f172006-04-06 23:58:51 -0700247 }
248 return graft;
Ralf Thielowdf5d43b2010-12-01 20:15:59 +0100249
250bad_graft_data:
Patryk Obara9a934032017-08-18 20:33:12 +0200251 error("bad graft data: %s", line->buf);
Patryk Obaracfa5bf12017-08-18 20:33:14 +0200252 assert(!graft);
Ralf Thielowdf5d43b2010-12-01 20:15:59 +0100253 return NULL;
Junio C Hamano5040f172006-04-06 23:58:51 -0700254}
255
Brandon Williamsd0e5dd02018-05-17 15:51:49 -0700256static int read_graft_file(struct repository *r, const char *graft_file)
Junio C Hamano5040f172006-04-06 23:58:51 -0700257{
Nguyễn Thái Ngọc Duye9d983f2017-05-03 17:16:50 +0700258 FILE *fp = fopen_or_warn(graft_file, "r");
Johannes Schindeline228c172013-12-27 21:49:57 +0100259 struct strbuf buf = STRBUF_INIT;
Junio C Hamano5040f172006-04-06 23:58:51 -0700260 if (!fp)
261 return -1;
Ævar Arnfjörð Bjarmasonab628582021-08-23 12:44:02 +0200262 if (!no_graft_file_deprecated_advice &&
263 advice_enabled(ADVICE_GRAFT_FILE_DEPRECATED))
Johannes Schindelinf9f99b32018-04-29 00:44:44 +0200264 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 Schindeline228c172013-12-27 21:49:57 +0100272 while (!strbuf_getwholeline(&buf, fp, '\n')) {
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700273 /* The format is just "Commit Parent1 Parent2 ...\n" */
Patryk Obara9a934032017-08-18 20:33:12 +0200274 struct commit_graft *graft = read_graft_line(&buf);
Junio C Hamano5bc4ce52006-04-16 14:24:56 -0700275 if (!graft)
276 continue;
Brandon Williamsd0e5dd02018-05-17 15:51:49 -0700277 if (register_commit_graft(r, graft, 1))
Johannes Schindeline228c172013-12-27 21:49:57 +0100278 error("duplicate graft data: %s", buf.buf);
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700279 }
280 fclose(fp);
Johannes Schindeline228c172013-12-27 21:49:57 +0100281 strbuf_release(&buf);
Junio C Hamano5040f172006-04-06 23:58:51 -0700282 return 0;
283}
284
Derrick Stolee20fd6d52018-08-20 18:24:30 +0000285void prepare_commit_graft(struct repository *r)
Junio C Hamano5040f172006-04-06 23:58:51 -0700286{
Junio C Hamano5040f172006-04-06 23:58:51 -0700287 char *graft_file;
288
Stefan Beller2f6c7672018-05-17 15:51:53 -0700289 if (r->parsed_objects->commit_graft_prepared)
Junio C Hamano5040f172006-04-06 23:58:51 -0700290 return;
Jeff King14a9bd22018-05-31 18:42:53 -0400291 if (!startup_info->have_repository)
292 return;
293
Stefan Beller2f6c7672018-05-17 15:51:53 -0700294 graft_file = get_graft_file(r);
295 read_graft_file(r, graft_file);
Johannes Schindelined09aef2006-10-30 20:09:06 +0100296 /* make sure shallows are read */
Stefan Beller2f6c7672018-05-17 15:51:53 -0700297 is_repository_shallow(r);
298 r->parsed_objects->commit_graft_prepared = 1;
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700299}
300
Stefan Bellerb9dbddf2018-05-17 15:51:54 -0700301struct commit_graft *lookup_commit_graft(struct repository *r, const struct object_id *oid)
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700302{
303 int pos;
Stefan Bellerb9dbddf2018-05-17 15:51:54 -0700304 prepare_commit_graft(r);
Jeff King98c431b2021-01-28 01:12:35 -0500305 pos = commit_graft_pos(r, oid);
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700306 if (pos < 0)
307 return NULL;
Stefan Bellerb9dbddf2018-05-17 15:51:54 -0700308 return r->parsed_objects->grafts[pos];
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700309}
310
Nguyễn Thái Ngọc Duy09d46642011-08-18 19:29:35 +0700311int for_each_commit_graft(each_commit_graft_fn fn, void *cb_data)
Johannes Schindelined09aef2006-10-30 20:09:06 +0100312{
Nguyễn Thái Ngọc Duy09d46642011-08-18 19:29:35 +0700313 int i, ret;
Jonathan Nieder6a1a79f2018-05-15 16:42:16 -0700314 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 Duy09d46642011-08-18 19:29:35 +0700316 return ret;
Johannes Schindelined09aef2006-10-30 20:09:06 +0100317}
318
Jonathan Tan2a69ff02022-03-17 11:24:47 -0700319void reset_commit_grafts(struct repository *r)
320{
321 int i;
322
Jonathan Tan4d4e49f2022-06-06 10:54:37 -0700323 for (i = 0; i < r->parsed_objects->grafts_nr; i++) {
324 unparse_commit(r, &r->parsed_objects->grafts[i]->oid);
Jonathan Tan2a69ff02022-03-17 11:24:47 -0700325 free(r->parsed_objects->grafts[i]);
Jonathan Tan4d4e49f2022-06-06 10:54:37 -0700326 }
Jonathan Tan2a69ff02022-03-17 11:24:47 -0700327 r->parsed_objects->grafts_nr = 0;
328 r->parsed_objects->commit_graft_prepared = 0;
329}
330
Jeff King8597ea32014-06-10 17:44:13 -0400331struct commit_buffer {
332 void *buffer;
333 unsigned long size;
334};
335define_commit_slab(buffer_slab, struct commit_buffer);
Jeff Kingc1b3c712014-06-10 17:43:02 -0400336
Stefan Beller65ea9d42018-06-28 18:22:15 -0700337struct buffer_slab *allocate_commit_buffer_slab(void)
Jeff King66c28272014-06-10 17:40:14 -0400338{
Stefan Beller65ea9d42018-06-28 18:22:15 -0700339 struct buffer_slab *bs = xmalloc(sizeof(*bs));
340 init_buffer_slab(bs);
341 return bs;
342}
343
344void free_commit_buffer_slab(struct buffer_slab *bs)
345{
346 clear_buffer_slab(bs);
347 free(bs);
348}
Johannes Schindelinf53514b2006-10-30 20:09:53 +0100349
Stefan Beller1a40fc42018-06-28 18:22:16 -0700350void set_commit_buffer(struct repository *r, struct commit *commit, void *buffer, unsigned long size)
Jeff King66c28272014-06-10 17:40:14 -0400351{
Stefan Beller65ea9d42018-06-28 18:22:15 -0700352 struct commit_buffer *v = buffer_slab_at(
Stefan Beller1a40fc42018-06-28 18:22:16 -0700353 r->parsed_objects->buffer_slab, commit);
Jeff King8597ea32014-06-10 17:44:13 -0400354 v->buffer = buffer;
355 v->size = size;
Jeff King66c28272014-06-10 17:40:14 -0400356}
357
Stefan Beller4ff7e5c2018-06-28 18:22:17 -0700358const void *get_cached_commit_buffer(struct repository *r, const struct commit *commit, unsigned long *sizep)
Jeff King152ff1c2014-06-10 17:40:39 -0400359{
Stefan Beller65ea9d42018-06-28 18:22:15 -0700360 struct commit_buffer *v = buffer_slab_peek(
Stefan Beller4ff7e5c2018-06-28 18:22:17 -0700361 r->parsed_objects->buffer_slab, commit);
Junio C Hamano862e7302015-05-14 15:25:52 -0700362 if (!v) {
363 if (sizep)
364 *sizep = 0;
365 return NULL;
366 }
Jeff King8597ea32014-06-10 17:44:13 -0400367 if (sizep)
368 *sizep = v->size;
369 return v->buffer;
Jeff King152ff1c2014-06-10 17:40:39 -0400370}
371
Stefan Beller07de3fd2018-11-13 16:12:57 -0800372const void *repo_get_commit_buffer(struct repository *r,
373 const struct commit *commit,
374 unsigned long *sizep)
Jeff King152ff1c2014-06-10 17:40:39 -0400375{
Stefan Beller07de3fd2018-11-13 16:12:57 -0800376 const void *ret = get_cached_commit_buffer(r, commit, sizep);
Jeff King152ff1c2014-06-10 17:40:39 -0400377 if (!ret) {
378 enum object_type type;
379 unsigned long size;
Stefan Beller07de3fd2018-11-13 16:12:57 -0800380 ret = repo_read_object_file(r, &commit->object.oid, &type, &size);
Jeff King152ff1c2014-06-10 17:40:39 -0400381 if (!ret)
382 die("cannot read commit object %s",
brian m. carlsonf2fd0762015-11-10 02:22:28 +0000383 oid_to_hex(&commit->object.oid));
Jeff King152ff1c2014-06-10 17:40:39 -0400384 if (type != OBJ_COMMIT)
385 die("expected commit for %s, got %s",
Brandon Williamsdebca9d2018-02-14 10:59:24 -0800386 oid_to_hex(&commit->object.oid), type_name(type));
Jeff King8597ea32014-06-10 17:44:13 -0400387 if (sizep)
388 *sizep = size;
Jeff King152ff1c2014-06-10 17:40:39 -0400389 }
390 return ret;
391}
392
Stefan Beller70315372018-11-13 16:12:58 -0800393void repo_unuse_commit_buffer(struct repository *r,
394 const struct commit *commit,
395 const void *buffer)
Jeff King152ff1c2014-06-10 17:40:39 -0400396{
Stefan Beller65ea9d42018-06-28 18:22:15 -0700397 struct commit_buffer *v = buffer_slab_peek(
Stefan Beller70315372018-11-13 16:12:58 -0800398 r->parsed_objects->buffer_slab, commit);
Junio C Hamano862e7302015-05-14 15:25:52 -0700399 if (!(v && v->buffer == buffer))
Jeff King152ff1c2014-06-10 17:40:39 -0400400 free((void *)buffer);
401}
402
Stefan Beller6a7895f2018-12-14 16:09:40 -0800403void free_commit_buffer(struct parsed_object_pool *pool, struct commit *commit)
Jeff King0fb370d2014-06-12 18:05:37 -0400404{
Stefan Beller65ea9d42018-06-28 18:22:15 -0700405 struct commit_buffer *v = buffer_slab_peek(
Stefan Beller6a7895f2018-12-14 16:09:40 -0800406 pool->buffer_slab, commit);
Junio C Hamano862e7302015-05-14 15:25:52 -0700407 if (v) {
Ævar Arnfjörð Bjarmason6a83d902017-06-15 23:15:46 +0000408 FREE_AND_NULL(v->buffer);
Junio C Hamano862e7302015-05-14 15:25:52 -0700409 v->size = 0;
410 }
Jeff King0fb370d2014-06-12 18:05:37 -0400411}
412
Nguyễn Thái Ngọc Duya133c402019-04-16 16:33:18 +0700413static 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 Duy301b8c72019-04-16 16:33:19 +0700418struct tree *repo_get_commit_tree(struct repository *r,
419 const struct commit *commit)
Derrick Stolee5bb03de2018-04-06 19:09:34 +0000420{
Derrick Stolee7b8a21d2018-04-06 19:09:46 +0000421 if (commit->maybe_tree || !commit->object.parsed)
422 return commit->maybe_tree;
423
Abhishek Kumarc49c82a2020-06-17 14:44:10 +0530424 if (commit_graph_position(commit) != COMMIT_NOT_FROM_GRAPH)
Junio C Hamanoea2dab12019-05-09 00:37:25 +0900425 return get_commit_tree_in_graph(r, commit);
Derrick Stolee7b8a21d2018-04-06 19:09:46 +0000426
Jeff King83487662019-04-09 19:13:20 -0700427 return NULL;
Derrick Stolee5bb03de2018-04-06 19:09:34 +0000428}
429
430struct object_id *get_commit_tree_oid(const struct commit *commit)
431{
Ævar Arnfjörð Bjarmasonecb50912023-03-28 15:58:48 +0200432 struct tree *tree = repo_get_commit_tree(the_repository, commit);
Taylor Blau806278d2019-09-05 18:04:57 -0400433 return tree ? &tree->object.oid : NULL;
Derrick Stolee5bb03de2018-04-06 19:09:34 +0000434}
435
Stefan Beller6a7895f2018-12-14 16:09:40 -0800436void release_commit_memory(struct parsed_object_pool *pool, struct commit *c)
Stefan Beller14ba97f2018-05-15 14:48:42 -0700437{
Nguyễn Thái Ngọc Duya133c402019-04-16 16:33:18 +0700438 set_commit_tree(c, NULL);
Stefan Beller6a7895f2018-12-14 16:09:40 -0800439 free_commit_buffer(pool, c);
Mike Hommey9784f972019-08-26 11:01:37 +0900440 c->index = 0;
Stefan Beller14ba97f2018-05-15 14:48:42 -0700441 free_commit_list(c->parents);
Stefan Beller14ba97f2018-05-15 14:48:42 -0700442
443 c->object.parsed = 0;
444}
445
Jeff King8597ea32014-06-10 17:44:13 -0400446const void *detach_commit_buffer(struct commit *commit, unsigned long *sizep)
Jeff King0fb370d2014-06-12 18:05:37 -0400447{
Stefan Beller65ea9d42018-06-28 18:22:15 -0700448 struct commit_buffer *v = buffer_slab_peek(
449 the_repository->parsed_objects->buffer_slab, commit);
Jeff King8597ea32014-06-10 17:44:13 -0400450 void *ret;
451
Junio C Hamano862e7302015-05-14 15:25:52 -0700452 if (!v) {
453 if (sizep)
454 *sizep = 0;
455 return NULL;
456 }
Jeff King8597ea32014-06-10 17:44:13 -0400457 ret = v->buffer;
458 if (sizep)
459 *sizep = v->size;
460
461 v->buffer = NULL;
462 v->size = 0;
Jeff King0fb370d2014-06-12 18:05:37 -0400463 return ret;
464}
465
Stefan Bellerfd8030c2018-06-28 18:22:13 -0700466int parse_commit_buffer(struct repository *r, struct commit *item, const void *buffer, unsigned long size, int check_graph)
Daniel Barkalow175785e2005-04-18 11:39:48 -0700467{
Nguyễn Thái Ngọc Duycf7b1ca2011-02-05 17:52:20 +0700468 const char *tail = buffer;
469 const char *bufptr = buffer;
brian m. carlson7683e2e2015-03-13 23:39:34 +0000470 struct object_id parent;
Linus Torvalds6c88be12005-06-20 20:26:03 -0700471 struct commit_list **pptr;
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700472 struct commit_graft *graft;
brian m. carlson2770ccb2018-07-16 01:27:56 +0000473 const int tree_entry_len = the_hash_algo->hexsz + 5;
474 const int parent_entry_len = the_hash_algo->hexsz + 7;
Jeff King12736d22019-10-18 00:43:29 -0400475 struct tree *tree;
Nicolas Pitrebd2c39f2005-05-06 13:48:34 -0400476
Daniel Barkalow175785e2005-04-18 11:39:48 -0700477 if (item->object.parsed)
478 return 0;
Ævar Arnfjörð Bjarmasonbf20fe42022-04-13 22:01:34 +0200479 /*
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 King228c78f2019-10-25 17:20:20 -0400487
Junio C Hamano3b44f152006-06-28 03:51:00 -0700488 tail += size;
brian m. carlson7683e2e2015-03-13 23:39:34 +0000489 if (tail <= bufptr + tree_entry_len + 1 || memcmp(bufptr, "tree ", 5) ||
490 bufptr[tree_entry_len] != '\n')
brian m. carlsonf2fd0762015-11-10 02:22:28 +0000491 return error("bogus commit object %s", oid_to_hex(&item->object.oid));
brian m. carlson26ea3e72018-05-02 00:25:47 +0000492 if (get_oid_hex(bufptr + 5, &parent) < 0)
Junio C Hamanobd2afde2006-02-22 17:47:10 -0800493 return error("bad tree pointer in commit %s",
brian m. carlsonf2fd0762015-11-10 02:22:28 +0000494 oid_to_hex(&item->object.oid));
Jeff King12736d22019-10-18 00:43:29 -0400495 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. carlson7683e2e2015-03-13 23:39:34 +0000501 bufptr += tree_entry_len + 1; /* "tree " + "hex sha1" + "\n" */
Linus Torvalds6c88be12005-06-20 20:26:03 -0700502 pptr = &item->parents;
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700503
Stefan Bellerfd8030c2018-06-28 18:22:13 -0700504 graft = lookup_commit_graft(r, &item->object.oid);
Taylor Blauce163642020-07-08 17:10:53 -0400505 if (graft)
506 r->parsed_objects->substituted_parent = 1;
brian m. carlson7683e2e2015-03-13 23:39:34 +0000507 while (bufptr + parent_entry_len < tail && !memcmp(bufptr, "parent ", 7)) {
Linus Torvaldsf7cc77d2005-07-27 15:12:48 -0700508 struct commit *new_parent;
509
brian m. carlson7683e2e2015-03-13 23:39:34 +0000510 if (tail <= bufptr + parent_entry_len + 1 ||
brian m. carlson26ea3e72018-05-02 00:25:47 +0000511 get_oid_hex(bufptr + 7, &parent) ||
brian m. carlson7683e2e2015-03-13 23:39:34 +0000512 bufptr[parent_entry_len] != '\n')
brian m. carlsonf2fd0762015-11-10 02:22:28 +0000513 return error("bad parents in commit %s", oid_to_hex(&item->object.oid));
brian m. carlson7683e2e2015-03-13 23:39:34 +0000514 bufptr += parent_entry_len + 1;
Johannes Schindelin7f3140c2009-07-23 17:33:49 +0200515 /*
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é Scharfe3a5f3082023-07-21 14:41:56 +0200519 if (graft && (graft->nr_parent < 0 || !grafts_keep_true_parents))
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700520 continue;
Stefan Bellerfd8030c2018-06-28 18:22:13 -0700521 new_parent = lookup_commit(r, &parent);
Jeff Kingc78fe002019-10-18 00:42:13 -0400522 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 Hamano5da5c8f2005-07-30 00:58:28 -0700527 }
528 if (graft) {
529 int i;
530 struct commit *new_parent;
531 for (i = 0; i < graft->nr_parent; i++) {
Stefan Bellerfd8030c2018-06-28 18:22:13 -0700532 new_parent = lookup_commit(r,
Stefan Bellerc1f5eb42018-06-28 18:21:59 -0700533 &graft->parent[i]);
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700534 if (!new_parent)
Jeff Kingc78fe002019-10-18 00:42:13 -0400535 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 Hamano5da5c8f2005-07-30 00:58:28 -0700538 pptr = &commit_list_insert(new_parent, pptr)->next;
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700539 }
Daniel Barkalow175785e2005-04-18 11:39:48 -0700540 }
Martin Koegler0a617792008-01-19 18:35:23 +0100541 item->date = parse_commit_date(bufptr, tail);
Junio C Hamano27dedf02005-11-16 21:32:44 -0800542
Derrick Stoleee2838d82018-05-01 12:47:13 +0000543 if (check_graph)
Derrick Stoleec7944052019-05-09 07:22:31 -0700544 load_commit_graph_info(r, item);
Derrick Stoleee2838d82018-05-01 12:47:13 +0000545
Jeff King228c78f2019-10-25 17:20:20 -0400546 item->object.parsed = 1;
Daniel Barkalow175785e2005-04-18 11:39:48 -0700547 return 0;
548}
549
Stefan Beller9e5252a2018-11-13 16:12:50 -0800550int repo_parse_commit_internal(struct repository *r,
551 struct commit *item,
552 int quiet_on_missing,
553 int use_commit_graph)
Nicolas Pitrebd2c39f2005-05-06 13:48:34 -0400554{
Nicolas Pitre21666f12007-02-26 14:55:59 -0500555 enum object_type type;
Nicolas Pitrebd2c39f2005-05-06 13:48:34 -0400556 void *buffer;
557 unsigned long size;
Jonathan Tan7e2ad1c2022-12-14 11:17:43 -0800558 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 Pitrebd2c39f2005-05-06 13:48:34 -0400569 int ret;
570
Martin Koegler9786f682008-02-18 21:48:02 +0100571 if (!item)
572 return -1;
Nicolas Pitrebd2c39f2005-05-06 13:48:34 -0400573 if (item->object.parsed)
574 return 0;
Stefan Beller9e5252a2018-11-13 16:12:50 -0800575 if (use_commit_graph && parse_commit_in_graph(r, item))
Derrick Stolee177722b2018-04-10 08:56:05 -0400576 return 0;
Jonathan Tan7e2ad1c2022-12-14 11:17:43 -0800577
578 if (oid_object_info_extended(r, &item->object.oid, &oi, flags) < 0)
Jeff King9cc2b072015-06-01 05:56:26 -0400579 return quiet_on_missing ? -1 :
580 error("Could not read %s",
brian m. carlsonf2fd0762015-11-10 02:22:28 +0000581 oid_to_hex(&item->object.oid));
Nicolas Pitre21666f12007-02-26 14:55:59 -0500582 if (type != OBJ_COMMIT) {
Nicolas Pitrebd2c39f2005-05-06 13:48:34 -0400583 free(buffer);
584 return error("Object %s not a commit",
brian m. carlsonf2fd0762015-11-10 02:22:28 +0000585 oid_to_hex(&item->object.oid));
Nicolas Pitrebd2c39f2005-05-06 13:48:34 -0400586 }
Derrick Stolee9b19ada2018-06-27 09:24:30 -0400587
Stefan Beller9e5252a2018-11-13 16:12:50 -0800588 ret = parse_commit_buffer(r, item, buffer, size, 0);
Linus Torvalds60ab26d2005-09-15 14:43:17 -0700589 if (save_commit_buffer && !ret) {
Stefan Beller9e5252a2018-11-13 16:12:50 -0800590 set_commit_buffer(r, item, buffer, size);
Linus Torvalds3ff1fbb2005-05-25 18:27:14 -0700591 return 0;
592 }
Nicolas Pitrebd2c39f2005-05-06 13:48:34 -0400593 free(buffer);
594 return ret;
595}
596
Stefan Beller9e5252a2018-11-13 16:12:50 -0800597int repo_parse_commit_gently(struct repository *r,
598 struct commit *item, int quiet_on_missing)
Derrick Stolee9b19ada2018-06-27 09:24:30 -0400599{
Stefan Beller9e5252a2018-11-13 16:12:50 -0800600 return repo_parse_commit_internal(r, item, quiet_on_missing, 1);
Derrick Stolee9b19ada2018-06-27 09:24:30 -0400601}
602
Jeff King7059dcc2013-10-24 04:52:36 -0400603void parse_commit_or_die(struct commit *item)
604{
Ævar Arnfjörð Bjarmasonecb50912023-03-28 15:58:48 +0200605 if (repo_parse_commit(the_repository, item))
Jeff King7059dcc2013-10-24 04:52:36 -0400606 die("unable to parse commit %s",
brian m. carlsonf2fd0762015-11-10 02:22:28 +0000607 item ? oid_to_hex(&item->object.oid) : "(null)");
Jeff King7059dcc2013-10-24 04:52:36 -0400608}
609
Christian Couder11af2aa2010-07-22 15:18:30 +0200610int 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 Schindelin4e1b06d2016-06-22 22:20:20 +0200618 p = skip_blank_lines(p + 2);
Junio C Hamano9c9b03b2017-01-27 18:01:41 -0800619 eol = strchrnul(p, '\n');
Christian Couder11af2aa2010-07-22 15:18:30 +0200620 } else
621 eol = p;
622
623 *subject = p;
624
625 return eol - p;
626}
627
Charvi Mendiratta6e0e2882021-03-15 13:24:31 +0530628size_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 Torvaldsac5155e2005-05-30 18:44:02 -0700642struct commit_list *commit_list_insert(struct commit *item, struct commit_list **list_p)
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700643{
Christopher Li812666c2005-04-26 12:00:58 -0700644 struct commit_list *new_list = xmalloc(sizeof(struct commit_list));
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700645 new_list->item = item;
646 new_list->next = *list_p;
647 *list_p = new_list;
Linus Torvaldsac5155e2005-05-30 18:44:02 -0700648 return new_list;
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700649}
650
Derrick Stolee597b2c32020-12-08 17:04:13 -0500651int 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 Vajna65319472008-06-27 18:21:55 +0200662unsigned 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 Rast53d00b32013-07-31 22:13:20 +0200670struct 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é Scharfecb979db2014-07-10 11:47:47 +0200675 pp = commit_list_append(list->item, pp);
Thomas Rast53d00b32013-07-31 22:13:20 +0200676 list = list->next;
677 }
678 return head;
679}
680
Elijah Newrenb0ca1202020-12-16 22:27:59 +0000681struct 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 Barkalow175785e2005-04-18 11:39:48 -0700692void free_commit_list(struct commit_list *list)
693{
René Scharfee510ab82015-10-24 18:21:31 +0200694 while (list)
695 pop_commit(&list);
Daniel Barkalow175785e2005-04-18 11:39:48 -0700696}
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700697
Thiago Farina47e44ed2010-11-26 23:58:14 -0200698struct commit_list * commit_list_insert_by_date(struct commit *item, struct commit_list **list)
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700699{
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 Torvaldsf7554942005-07-06 09:31:17 -0700708 return commit_list_insert(item, pp);
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700709}
710
René Scharfec0fb5772022-07-16 18:59:05 +0200711static int commit_list_compare_by_date(const struct commit_list *a,
712 const struct commit_list *b)
René Scharfe46905892012-04-01 00:10:39 +0200713{
René Scharfec0fb5772022-07-16 18:59:05 +0200714 timestamp_t a_date = a->item->date;
715 timestamp_t b_date = b->item->date;
René Scharfe46905892012-04-01 00:10:39 +0200716 if (a_date < b_date)
717 return 1;
718 if (a_date > b_date)
719 return -1;
720 return 0;
721}
722
René Scharfec0fb5772022-07-16 18:59:05 +0200723DEFINE_LIST_SORT(static, commit_list_sort, struct commit_list, next);
Junio C Hamanoa6080a02007-06-07 00:04:01 -0700724
Thiago Farina47e44ed2010-11-26 23:58:14 -0200725void commit_list_sort_by_date(struct commit_list **list)
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700726{
René Scharfec0fb5772022-07-16 18:59:05 +0200727 commit_list_sort(list, commit_list_compare_by_date);
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700728}
729
Daniel Barkalow58e28af2005-04-23 20:29:22 -0700730struct commit *pop_most_recent_commit(struct commit_list **list,
731 unsigned int mark)
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700732{
René Scharfee510ab82015-10-24 18:21:31 +0200733 struct commit *ret = pop_commit(list);
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700734 struct commit_list *parents = ret->parents;
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700735
736 while (parents) {
Linus Torvalds4056c092005-04-23 19:21:28 -0700737 struct commit *commit = parents->item;
Ævar Arnfjörð Bjarmasonecb50912023-03-28 15:58:48 +0200738 if (!repo_parse_commit(the_repository, commit) && !(commit->object.flags & mark)) {
Daniel Barkalow58e28af2005-04-23 20:29:22 -0700739 commit->object.flags |= mark;
Thiago Farina47e44ed2010-11-26 23:58:14 -0200740 commit_list_insert_by_date(commit, list);
Linus Torvalds4056c092005-04-23 19:21:28 -0700741 }
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700742 parents = parents->next;
743 }
744 return ret;
745}
Linus Torvaldse3bc7a32005-06-01 08:34:23 -0700746
Nguyễn Thái Ngọc Duy941ba8d2012-01-14 19:19:53 +0700747static void clear_commit_marks_1(struct commit_list **plist,
748 struct commit *commit, unsigned int mark)
Junio C Hamanof8f9c732006-01-07 18:52:42 -0800749{
Johannes Schindelin60fcc2e2007-10-10 23:14:35 +0100750 while (commit) {
751 struct commit_list *parents;
Junio C Hamanof8f9c732006-01-07 18:52:42 -0800752
Johannes Schindelin60fcc2e2007-10-10 23:14:35 +0100753 if (!(mark & commit->object.flags))
754 return;
Junio C Hamano58ecf5c2006-07-04 17:45:22 -0700755
Johannes Schindelin60fcc2e2007-10-10 23:14:35 +0100756 commit->object.flags &= ~mark;
757
758 parents = commit->parents;
759 if (!parents)
760 return;
761
René Scharfe4cb39fc2022-12-13 07:27:10 +0100762 while ((parents = parents->next)) {
763 if (parents->item->object.flags & mark)
764 commit_list_insert(parents->item, plist);
765 }
Johannes Schindelin60fcc2e2007-10-10 23:14:35 +0100766
767 commit = commit->parents->item;
Junio C Hamanof8f9c732006-01-07 18:52:42 -0800768 }
769}
770
Junio C Hamanoe895cb52013-03-05 11:42:20 -0800771void clear_commit_marks_many(int nr, struct commit **commit, unsigned int mark)
Nguyễn Thái Ngọc Duy941ba8d2012-01-14 19:19:53 +0700772{
773 struct commit_list *list = NULL;
Junio C Hamanoe895cb52013-03-05 11:42:20 -0800774
775 while (nr--) {
René Scharfe07f7d552017-12-25 18:43:37 +0100776 clear_commit_marks_1(&list, *commit, mark);
Junio C Hamanoe895cb52013-03-05 11:42:20 -0800777 commit++;
778 }
Nguyễn Thái Ngọc Duy941ba8d2012-01-14 19:19:53 +0700779 while (list)
780 clear_commit_marks_1(&list, pop_commit(&list), mark);
781}
782
Junio C Hamanoe895cb52013-03-05 11:42:20 -0800783void clear_commit_marks(struct commit *commit, unsigned int mark)
784{
785 clear_commit_marks_many(1, &commit, mark);
786}
787
jon@blackcubes.dyndns.orga3437b82005-06-06 15:39:40 +0000788struct 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 Seymourab580ac2005-07-07 02:39:34 +1000800/*
Junio C Hamanoa84b7942013-04-13 11:56:41 -0700801 * Topological sort support
802 */
Junio C Hamano66eb3752013-04-12 23:25:49 -0700803
Junio C Hamanoa84b7942013-04-13 11:56:41 -0700804/* count number of children that have not been emitted */
805define_commit_slab(indegree_slab, int);
Jeff King96c4f4a2013-04-09 02:52:56 -0400806
Derrick Stolee18207032018-08-21 20:54:12 +0000807define_commit_slab(author_date_slab, timestamp_t);
Junio C Hamano81c6b382013-06-07 10:35:54 -0700808
Derrick Stolee5284fc52018-11-01 13:46:21 +0000809void record_author_date(struct author_date_slab *author_date,
810 struct commit *commit)
Junio C Hamano81c6b382013-06-07 10:35:54 -0700811{
Ævar Arnfjörð Bjarmasonecb50912023-03-28 15:58:48 +0200812 const char *buffer = repo_get_commit_buffer(the_repository, commit,
813 NULL);
Junio C Hamano81c6b382013-06-07 10:35:54 -0700814 struct ident_split ident;
Jeff Kingea5517f2014-08-27 03:56:55 -0400815 const char *ident_line;
816 size_t ident_len;
Junio C Hamano81c6b382013-06-07 10:35:54 -0700817 char *date_end;
Johannes Schindelindddbad72017-04-26 21:29:31 +0200818 timestamp_t date;
Junio C Hamano81c6b382013-06-07 10:35:54 -0700819
Jeff Kingea5517f2014-08-27 03:56:55 -0400820 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 Hamano81c6b382013-06-07 10:35:54 -0700826
Johannes Schindelin1aeb7e72017-04-21 12:45:44 +0200827 date = parse_timestamp(ident.date_begin, &date_end, 10);
Junio C Hamano81c6b382013-06-07 10:35:54 -0700828 if (date_end != ident.date_end)
829 goto fail_exit; /* malformed date */
830 *(author_date_slab_at(author_date, commit)) = date;
831
832fail_exit:
Ævar Arnfjörð Bjarmasonecb50912023-03-28 15:58:48 +0200833 repo_unuse_commit_buffer(the_repository, commit, buffer);
Junio C Hamano81c6b382013-06-07 10:35:54 -0700834}
835
Derrick Stolee5284fc52018-11-01 13:46:21 +0000836int compare_commits_by_author_date(const void *a_, const void *b_,
837 void *cb_data)
Junio C Hamano81c6b382013-06-07 10:35:54 -0700838{
839 const struct commit *a = a_, *b = b_;
840 struct author_date_slab *author_date = cb_data;
Johannes Schindelindddbad72017-04-26 21:29:31 +0200841 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 Hamano81c6b382013-06-07 10:35:54 -0700843
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 King17587122023-02-24 01:39:27 -0500852int compare_commits_by_gen_then_commit_date(const void *a_, const void *b_,
853 void *unused UNUSED)
Derrick Stolee3afc6792018-05-01 12:47:11 +0000854{
855 const struct commit *a = a_, *b = b_;
Abhishek Kumard7f92782021-01-16 18:11:13 +0000856 const timestamp_t generation_a = commit_graph_generation(a),
857 generation_b = commit_graph_generation(b);
Derrick Stolee3afc6792018-05-01 12:47:11 +0000858
859 /* newer commits first */
Abhishek Kumarc752ad02020-06-17 14:44:11 +0530860 if (generation_a < generation_b)
Derrick Stolee3afc6792018-05-01 12:47:11 +0000861 return 1;
Abhishek Kumarc752ad02020-06-17 14:44:11 +0530862 else if (generation_a > generation_b)
Derrick Stolee3afc6792018-05-01 12:47:11 +0000863 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 King17587122023-02-24 01:39:27 -0500873int compare_commits_by_commit_date(const void *a_, const void *b_,
874 void *unused UNUSED)
Junio C Hamanoda24b102013-06-06 21:58:12 -0700875{
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 Seymourab580ac2005-07-07 02:39:34 +1000885/*
886 * Performs an in-place topological sort on the list supplied.
887 */
Junio C Hamanoda24b102013-06-06 21:58:12 -0700888void sort_in_topological_order(struct commit_list **list, enum rev_sort_order sort_order)
Jon Seymourab580ac2005-07-07 02:39:34 +1000889{
Linus Torvalds23c17d42007-11-02 13:32:58 -0700890 struct commit_list *next, *orig = *list;
Linus Torvalds23c17d42007-11-02 13:32:58 -0700891 struct commit_list **pptr;
Junio C Hamanoa84b7942013-04-13 11:56:41 -0700892 struct indegree_slab indegree;
Junio C Hamanoda24b102013-06-06 21:58:12 -0700893 struct prio_queue queue;
894 struct commit *commit;
Junio C Hamano81c6b382013-06-07 10:35:54 -0700895 struct author_date_slab author_date;
Fredrik Kuivinen6b6dcfc2006-03-10 10:21:37 +0100896
Linus Torvalds23c17d42007-11-02 13:32:58 -0700897 if (!orig)
Eric Wong7d6fb372005-12-24 04:12:43 -0800898 return;
Linus Torvalds23c17d42007-11-02 13:32:58 -0700899 *list = NULL;
900
Junio C Hamanoa84b7942013-04-13 11:56:41 -0700901 init_indegree_slab(&indegree);
Junio C Hamanoda24b102013-06-06 21:58:12 -0700902 memset(&queue, '\0', sizeof(queue));
Junio C Hamano81c6b382013-06-07 10:35:54 -0700903
Junio C Hamanoda24b102013-06-06 21:58:12 -0700904 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 Hamano81c6b382013-06-07 10:35:54 -0700911 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 Hamanoda24b102013-06-06 21:58:12 -0700916 }
Jeff King96c4f4a2013-04-09 02:52:56 -0400917
Linus Torvalds23c17d42007-11-02 13:32:58 -0700918 /* Mark them and clear the indegree */
919 for (next = orig; next; next = next->next) {
920 struct commit *commit = next->item;
Junio C Hamanoa84b7942013-04-13 11:56:41 -0700921 *(indegree_slab_at(&indegree, commit)) = 1;
Junio C Hamano81c6b382013-06-07 10:35:54 -0700922 /* also record the author dates, if needed */
923 if (sort_order == REV_SORT_BY_AUTHOR_DATE)
924 record_author_date(&author_date, commit);
Jon Seymourab580ac2005-07-07 02:39:34 +1000925 }
Linus Torvalds23c17d42007-11-02 13:32:58 -0700926
Jon Seymourab580ac2005-07-07 02:39:34 +1000927 /* update the indegree */
Linus Torvalds23c17d42007-11-02 13:32:58 -0700928 for (next = orig; next; next = next->next) {
Junio C Hamanoda24b102013-06-06 21:58:12 -0700929 struct commit_list *parents = next->item->parents;
Jon Seymourab580ac2005-07-07 02:39:34 +1000930 while (parents) {
Linus Torvalds23c17d42007-11-02 13:32:58 -0700931 struct commit *parent = parents->item;
Junio C Hamanoa84b7942013-04-13 11:56:41 -0700932 int *pi = indegree_slab_at(&indegree, parent);
Fredrik Kuivinen6b6dcfc2006-03-10 10:21:37 +0100933
Jeff King96c4f4a2013-04-09 02:52:56 -0400934 if (*pi)
935 (*pi)++;
Linus Torvalds23c17d42007-11-02 13:32:58 -0700936 parents = parents->next;
Jon Seymourab580ac2005-07-07 02:39:34 +1000937 }
Jon Seymourab580ac2005-07-07 02:39:34 +1000938 }
Linus Torvalds23c17d42007-11-02 13:32:58 -0700939
Junio C Hamanoa6080a02007-06-07 00:04:01 -0700940 /*
Pierre Habouzit674d1722007-09-10 12:35:06 +0200941 * 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 Torvalds23c17d42007-11-02 13:32:58 -0700947 for (next = orig; next; next = next->next) {
948 struct commit *commit = next->item;
Jon Seymourab580ac2005-07-07 02:39:34 +1000949
Junio C Hamanoa84b7942013-04-13 11:56:41 -0700950 if (*(indegree_slab_at(&indegree, commit)) == 1)
Junio C Hamanoda24b102013-06-06 21:58:12 -0700951 prio_queue_put(&queue, commit);
Jon Seymourab580ac2005-07-07 02:39:34 +1000952 }
Junio C Hamano4c8725f2006-02-15 22:05:33 -0800953
Junio C Hamanoda24b102013-06-06 21:58:12 -0700954 /*
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 Torvalds23c17d42007-11-02 13:32:58 -0700963
964 pptr = list;
965 *list = NULL;
Junio C Hamanoda24b102013-06-06 21:58:12 -0700966 while ((commit = prio_queue_get(&queue)) != NULL) {
967 struct commit_list *parents;
Jon Seymourab580ac2005-07-07 02:39:34 +1000968
Linus Torvalds23c17d42007-11-02 13:32:58 -0700969 for (parents = commit->parents; parents ; parents = parents->next) {
Junio C Hamanocd2b8ae2011-08-25 14:46:52 -0700970 struct commit *parent = parents->item;
Junio C Hamanoa84b7942013-04-13 11:56:41 -0700971 int *pi = indegree_slab_at(&indegree, parent);
Linus Torvalds23c17d42007-11-02 13:32:58 -0700972
Jeff King96c4f4a2013-04-09 02:52:56 -0400973 if (!*pi)
Linus Torvalds23c17d42007-11-02 13:32:58 -0700974 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 Hamanoda24b102013-06-06 21:58:12 -0700981 if (--(*pi) == 1)
982 prio_queue_put(&queue, parent);
Jon Seymourab580ac2005-07-07 02:39:34 +1000983 }
984 /*
Junio C Hamanoda24b102013-06-06 21:58:12 -0700985 * all children of commit have already been
986 * emitted. we can emit it now.
Pierre Habouzit674d1722007-09-10 12:35:06 +0200987 */
Junio C Hamanoa84b7942013-04-13 11:56:41 -0700988 *(indegree_slab_at(&indegree, commit)) = 0;
Junio C Hamanoda24b102013-06-06 21:58:12 -0700989
990 pptr = &commit_list_insert(commit, pptr)->next;
Jon Seymourab580ac2005-07-07 02:39:34 +1000991 }
Jeff King96c4f4a2013-04-09 02:52:56 -0400992
Junio C Hamanoa84b7942013-04-13 11:56:41 -0700993 clear_indegree_slab(&indegree);
Junio C Hamanoda24b102013-06-06 21:58:12 -0700994 clear_prio_queue(&queue);
Junio C Hamano81c6b382013-06-07 10:35:54 -0700995 if (sort_order == REV_SORT_BY_AUTHOR_DATE)
996 clear_author_date_slab(&author_date);
Jon Seymourab580ac2005-07-07 02:39:34 +1000997}
Johannes Schindelin7c6f8aa2006-06-29 15:17:32 +0200998
Pratik Karki103148a2018-09-04 15:00:08 -0700999struct rev_collect {
1000 struct commit **commit;
1001 int nr;
1002 int alloc;
1003 unsigned int initial : 1;
1004};
1005
1006static 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ð Bjarmasonecb50912023-03-28 15:58:48 +02001016 repo_parse_commit(the_repository, commit))
Pratik Karki103148a2018-09-04 15:00:08 -07001017 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
1024static int collect_one_reflog_ent(struct object_id *ooid, struct object_id *noid,
Ævar Arnfjörð Bjarmason5cf88fd2022-08-25 19:09:48 +02001025 const char *ident UNUSED,
1026 timestamp_t timestamp UNUSED, int tz UNUSED,
1027 const char *message UNUSED, void *cbdata)
Pratik Karki103148a2018-09-04 15:00:08 -07001028{
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
1039struct 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 Hamanof08132f2019-12-09 10:51:47 -08001046 char *full_refname;
1047
Ævar Arnfjörð Bjarmason12cb1c12023-03-28 15:58:54 +02001048 switch (repo_dwim_ref(the_repository, refname, strlen(refname), &oid,
1049 &full_refname, 0)) {
Junio C Hamanof08132f2019-12-09 10:51:47 -08001050 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 Karki103148a2018-09-04 15:00:08 -07001057
1058 memset(&revs, 0, sizeof(revs));
1059 revs.initial = 1;
Junio C Hamanof08132f2019-12-09 10:51:47 -08001060 for_each_reflog_ent(full_refname, collect_one_reflog_ent, &revs);
Pratik Karki103148a2018-09-04 15:00:08 -07001061
Junio C Hamanof08132f2019-12-09 10:51:47 -08001062 if (!revs.nr)
Pratik Karki103148a2018-09-04 15:00:08 -07001063 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ð Bjarmasoncb338c22023-03-28 15:58:47 +02001068 bases = repo_get_merge_bases_many(the_repository, commit, revs.nr,
1069 revs.commit);
Pratik Karki103148a2018-09-04 15:00:08 -07001070
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
1087cleanup_return:
Ævar Arnfjörð Bjarmason0c10ed12023-02-06 20:08:13 +01001088 free(revs.commit);
Pratik Karki103148a2018-09-04 15:00:08 -07001089 free_commit_list(bases);
Junio C Hamanof08132f2019-12-09 10:51:47 -08001090 free(full_refname);
Pratik Karki103148a2018-09-04 15:00:08 -07001091 return ret;
1092}
1093
brian m. carlson42d4e1d2020-02-22 20:17:42 +00001094/*
1095 * Indexed by hash algorithm identifier.
1096 */
1097static const char *gpg_sig_headers[] = {
1098 NULL,
1099 "gpgsig",
1100 "gpgsig-sha256",
1101};
Junio C Hamanoba3c69a2011-10-05 17:23:20 -07001102
brian m. carlson937032e2021-02-11 02:08:04 +00001103int sign_with_header(struct strbuf *buf, const char *keyid)
Junio C Hamanoba3c69a2011-10-05 17:23:20 -07001104{
1105 struct strbuf sig = STRBUF_INIT;
1106 int inspos, copypos;
Johannes Schindelin3324dd82016-06-29 16:14:54 +02001107 const char *eoh;
brian m. carlson42d4e1d2020-02-22 20:17:42 +00001108 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 Hamanoba3c69a2011-10-05 17:23:20 -07001110
1111 /* find the end of the header */
Johannes Schindelin3324dd82016-06-29 16:14:54 +02001112 eoh = strstr(buf->buf, "\n\n");
1113 if (!eoh)
1114 inspos = buf->len;
1115 else
1116 inspos = eoh - buf->buf + 1;
Junio C Hamanoba3c69a2011-10-05 17:23:20 -07001117
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é Scharfea91cc7f2020-02-09 14:44:23 +01001134 strbuf_insertstr(buf, inspos++, " ");
Junio C Hamanoba3c69a2011-10-05 17:23:20 -07001135 strbuf_insert(buf, inspos, bol, len);
1136 inspos += len;
1137 copypos += len;
1138 }
1139 strbuf_release(&sig);
1140 return 0;
1141}
1142
Junio C Hamano0c37f1f2011-10-18 15:53:23 -07001143
brian m. carlson937032e2021-02-11 02:08:04 +00001144
Junio C Hamano0c37f1f2011-10-18 15:53:23 -07001145int parse_signed_commit(const struct commit *commit,
brian m. carlson1fb5cf02021-01-18 23:49:11 +00001146 struct strbuf *payload, struct strbuf *signature,
1147 const struct git_hash_algo *algop)
Junio C Hamano0c37f1f2011-10-18 15:53:23 -07001148{
Jeff King218aa3a2014-06-13 02:32:11 -04001149 unsigned long size;
Ævar Arnfjörð Bjarmasonecb50912023-03-28 15:58:48 +02001150 const char *buffer = repo_get_commit_buffer(the_repository, commit,
1151 &size);
brian m. carlson937032e2021-02-11 02:08:04 +00001152 int ret = parse_buffer_signed_by_header(buffer, size, payload, signature, algop);
1153
Ævar Arnfjörð Bjarmasonecb50912023-03-28 15:58:48 +02001154 repo_unuse_commit_buffer(the_repository, commit, buffer);
brian m. carlson937032e2021-02-11 02:08:04 +00001155 return ret;
1156}
1157
1158int 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. carlson1fb5cf02021-01-18 23:49:11 +00001164 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 Hamano0c37f1f2011-10-18 15:53:23 -07001167
1168 line = buffer;
1169 tail = buffer + size;
Junio C Hamano0c37f1f2011-10-18 15:53:23 -07001170 while (line < tail) {
1171 const char *sig = NULL;
Jeff King218aa3a2014-06-13 02:32:11 -04001172 const char *next = memchr(line, '\n', tail - line);
Junio C Hamano0c37f1f2011-10-18 15:53:23 -07001173
1174 next = next ? next + 1 : tail;
1175 if (in_signature && line[0] == ' ')
1176 sig = line + 1;
brian m. carlson1fb5cf02021-01-18 23:49:11 +00001177 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 Hamano0c37f1f2011-10-18 15:53:23 -07001186 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. carlson1fb5cf02021-01-18 23:49:11 +00001194 if (!other_signature)
1195 strbuf_add(payload, line, next - line);
Junio C Hamano0c37f1f2011-10-18 15:53:23 -07001196 in_signature = 0;
1197 }
1198 line = next;
1199 }
Junio C Hamano0c37f1f2011-10-18 15:53:23 -07001200 return saw_signature;
1201}
1202
Christian Couder0b05ab62014-07-19 17:01:12 +02001203int 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. carlson1fb5cf02021-01-18 23:49:11 +00001208 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 Couder0b05ab62014-07-19 17:01:12 +02001216
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. carlson1fb5cf02021-01-18 23:49:11 +00001222 sigp->end = next;
brian m. carlson42d4e1d2020-02-22 20:17:42 +00001223 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. carlson1fb5cf02021-01-18 23:49:11 +00001229 sigp->start = line;
1230 sigp->end = next;
brian m. carlson42d4e1d2020-02-22 20:17:42 +00001231 in_signature = 1;
1232 }
1233 }
Christian Couder0b05ab62014-07-19 17:01:12 +02001234 } else {
1235 if (*line == '\n')
1236 /* dump the whole remainder of the buffer */
1237 next = tail;
brian m. carlson1fb5cf02021-01-18 23:49:11 +00001238 if (in_signature && sigp - sigs != ARRAY_SIZE(sigs))
1239 sigp++;
Christian Couder0b05ab62014-07-19 17:01:12 +02001240 in_signature = 0;
1241 }
1242 line = next;
1243 }
1244
brian m. carlson1fb5cf02021-01-18 23:49:11 +00001245 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 Couder0b05ab62014-07-19 17:01:12 +02001248
brian m. carlson1fb5cf02021-01-18 23:49:11 +00001249 return sigs[0].start != NULL;
Christian Couder0b05ab62014-07-19 17:01:12 +02001250}
1251
Junio C Hamano5231c632011-11-07 16:21:32 -08001252static 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. carlson482c1192021-02-11 02:08:03 +00001257 unsigned long size;
Junio C Hamano5231c632011-11-07 16:21:32 -08001258 enum object_type type;
brian m. carlson482c1192021-02-11 02:08:03 +00001259 struct strbuf payload = STRBUF_INIT;
1260 struct strbuf signature = STRBUF_INIT;
Junio C Hamano5231c632011-11-07 16:21:32 -08001261
1262 desc = merge_remote_util(parent);
1263 if (!desc || !desc->obj)
1264 return;
Ævar Arnfjörð Bjarmasonbc726bd2023-03-28 15:58:50 +02001265 buf = repo_read_object_file(the_repository, &desc->obj->oid, &type,
1266 &size);
Junio C Hamano5231c632011-11-07 16:21:32 -08001267 if (!buf || type != OBJ_TAG)
1268 goto free_return;
brian m. carlson482c1192021-02-11 02:08:03 +00001269 if (!parse_signature(buf, size, &payload, &signature))
Junio C Hamano5231c632011-11-07 16:21:32 -08001270 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 Contreras0e20b222021-06-15 14:11:10 +00001274 * public key of the signer of the tag being merged, while a
Junio C Hamano5231c632011-11-07 16:21:32 -08001275 * 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é Scharfeca56dad2021-03-13 17:17:22 +01001281 CALLOC_ARRAY(mergetag, 1);
Junio C Hamano5231c632011-11-07 16:21:32 -08001282 mergetag->key = xstrdup("mergetag");
1283 mergetag->value = buf;
1284 mergetag->len = size;
1285
1286 **tail = mergetag;
1287 *tail = &mergetag->next;
brian m. carlson482c1192021-02-11 02:08:03 +00001288 strbuf_release(&payload);
1289 strbuf_release(&signature);
Junio C Hamano5231c632011-11-07 16:21:32 -08001290 return;
1291
1292free_return:
1293 free(buf);
1294}
1295
brian m. carlson434060e2015-06-21 23:14:40 +00001296int check_commit_signature(const struct commit *commit, struct signature_check *sigc)
Sebastian Götteffb6d7d2013-03-31 18:00:14 +02001297{
1298 struct strbuf payload = STRBUF_INIT;
1299 struct strbuf signature = STRBUF_INIT;
brian m. carlson434060e2015-06-21 23:14:40 +00001300 int ret = 1;
Sebastian Götteffb6d7d2013-03-31 18:00:14 +02001301
1302 sigc->result = 'N';
1303
brian m. carlson1fb5cf02021-01-18 23:49:11 +00001304 if (parse_signed_commit(commit, &payload, &signature, the_hash_algo) <= 0)
Sebastian Götteffb6d7d2013-03-31 18:00:14 +02001305 goto out;
Fabian Stelzer02769432021-12-09 09:52:43 +01001306
Fabian Stelzer6393c952021-12-09 09:52:45 +01001307 sigc->payload_type = SIGNATURE_PAYLOAD_COMMIT;
Fabian Stelzer02769432021-12-09 09:52:43 +01001308 sigc->payload = strbuf_detach(&payload, &sigc->payload_len);
1309 ret = check_signature(sigc, signature.buf, signature.len);
Sebastian Götteffb6d7d2013-03-31 18:00:14 +02001310
1311 out:
Sebastian Götteffb6d7d2013-03-31 18:00:14 +02001312 strbuf_release(&payload);
1313 strbuf_release(&signature);
brian m. carlson434060e2015-06-21 23:14:40 +00001314
1315 return ret;
Sebastian Götteffb6d7d2013-03-31 18:00:14 +02001316}
1317
Hans Jerry Illikainen54887b42019-12-27 13:55:57 +00001318void verify_merge_signature(struct commit *commit, int verbosity,
1319 int check_trust)
Jeff Kingedc4d472018-11-06 02:50:17 -05001320{
1321 char hex[GIT_MAX_HEXSZ + 1];
1322 struct signature_check signature_check;
Hans Jerry Illikainen54887b42019-12-27 13:55:57 +00001323 int ret;
Jeff Kingedc4d472018-11-06 02:50:17 -05001324 memset(&signature_check, 0, sizeof(signature_check));
Sebastian Götteffb6d7d2013-03-31 18:00:14 +02001325
Hans Jerry Illikainen54887b42019-12-27 13:55:57 +00001326 ret = check_commit_signature(commit, &signature_check);
Jeff Kingedc4d472018-11-06 02:50:17 -05001327
Ævar Arnfjörð Bjarmasond850b7a2023-03-28 15:58:46 +02001328 repo_find_unique_abbrev_r(the_repository, hex, &commit->object.oid,
1329 DEFAULT_ABBREV);
Jeff Kingedc4d472018-11-06 02:50:17 -05001330 switch (signature_check.result) {
1331 case 'G':
Hans Jerry Illikainen54887b42019-12-27 13:55:57 +00001332 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 Kingedc4d472018-11-06 02:50:17 -05001335 break;
Jeff Kingedc4d472018-11-06 02:50:17 -05001336 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ötteffb6d7d2013-03-31 18:00:14 +02001348
Junio C Hamano5231c632011-11-07 16:21:32 -08001349void 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
1359static void add_extra_header(struct strbuf *buffer,
1360 struct commit_extra_header *extra)
1361{
1362 strbuf_addstr(buffer, extra->key);
Junio C Hamanoed7a42a2011-11-08 15:38:07 -08001363 if (extra->len)
1364 strbuf_add_lines(buffer, " ", extra->value, extra->len);
1365 else
1366 strbuf_addch(buffer, '\n');
1367}
1368
Junio C Hamanoc871a1d2012-01-05 10:54:14 -08001369struct commit_extra_header *read_commit_extra_headers(struct commit *commit,
1370 const char **exclude)
Junio C Hamanoed7a42a2011-11-08 15:38:07 -08001371{
1372 struct commit_extra_header *extra = NULL;
1373 unsigned long size;
Ævar Arnfjörð Bjarmasonecb50912023-03-28 15:58:48 +02001374 const char *buffer = repo_get_commit_buffer(the_repository, commit,
1375 &size);
Jeff King218aa3a2014-06-13 02:32:11 -04001376 extra = read_commit_extra_header_lines(buffer, size, exclude);
Ævar Arnfjörð Bjarmasonecb50912023-03-28 15:58:48 +02001377 repo_unuse_commit_buffer(the_repository, commit, buffer);
Junio C Hamanoed7a42a2011-11-08 15:38:07 -08001378 return extra;
1379}
1380
Johannes Schindelinfef461e2018-04-25 11:54:04 +02001381int for_each_mergetag(each_mergetag_fn fn, struct commit *commit, void *data)
Christian Couder063da622014-07-07 08:35:37 +02001382{
1383 struct commit_extra_header *extra, *to_free;
Johannes Schindelinfef461e2018-04-25 11:54:04 +02001384 int res = 0;
Christian Couder063da622014-07-07 08:35:37 +02001385
1386 to_free = read_commit_extra_headers(commit, NULL);
Johannes Schindelinfef461e2018-04-25 11:54:04 +02001387 for (extra = to_free; !res && extra; extra = extra->next) {
Christian Couder063da622014-07-07 08:35:37 +02001388 if (strcmp(extra->key, "mergetag"))
1389 continue; /* not a merge tag */
Johannes Schindelinfef461e2018-04-25 11:54:04 +02001390 res = fn(commit, extra, data);
Christian Couder063da622014-07-07 08:35:37 +02001391 }
1392 free_commit_extra_headers(to_free);
Johannes Schindelinfef461e2018-04-25 11:54:04 +02001393 return res;
Christian Couder063da622014-07-07 08:35:37 +02001394}
1395
Junio C Hamanoed7a42a2011-11-08 15:38:07 -08001396static inline int standard_header_field(const char *field, size_t len)
1397{
René Scharfeb0725042017-02-25 20:27:40 +01001398 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 Hamanoed7a42a2011-11-08 15:38:07 -08001403}
1404
Junio C Hamanoc871a1d2012-01-05 10:54:14 -08001405static 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é Scharfeb0725042017-02-25 20:27:40 +01001412 if (len == xlen && !memcmp(field, *exclude, xlen))
Junio C Hamanoc871a1d2012-01-05 10:54:14 -08001413 return 1;
1414 exclude++;
1415 }
1416 return 0;
1417}
1418
Junio C Hamano82a75292012-09-15 13:58:15 -07001419static struct commit_extra_header *read_commit_extra_header_lines(
1420 const char *buffer, size_t size,
1421 const char **exclude)
Junio C Hamanoed7a42a2011-11-08 15:38:07 -08001422{
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é Scharfe50a01cc2017-02-25 20:21:52 +01001443 eof = memchr(line, ' ', next - line);
1444 if (!eof)
Junio C Hamanoed7a42a2011-11-08 15:38:07 -08001445 eof = next;
René Scharfeb0725042017-02-25 20:27:40 +01001446 else if (standard_header_field(line, eof - line) ||
1447 excluded_header_field(line, eof - line, exclude))
Junio C Hamanoed7a42a2011-11-08 15:38:07 -08001448 continue;
1449
René Scharfeca56dad2021-03-13 17:17:22 +01001450 CALLOC_ARRAY(it, 1);
Junio C Hamanoed7a42a2011-11-08 15:38:07 -08001451 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 Hamano5231c632011-11-07 16:21:32 -08001460}
1461
1462void 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 Obara5078f342018-01-28 01:13:16 +01001473int 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 Hamanoba3c69a2011-10-05 17:23:20 -07001475 const char *author, const char *sign_commit)
Junio C Hamano5231c632011-11-07 16:21:32 -08001476{
1477 struct commit_extra_header *extra = NULL, **tail = &extra;
1478 int result;
1479
1480 append_merge_tag_headers(parents, &tail);
Phillip Woode8cbe212020-08-17 18:40:01 +01001481 result = commit_tree_extended(msg, msg_len, tree, parents, ret, author,
1482 NULL, sign_commit, extra);
Junio C Hamano5231c632011-11-07 16:21:32 -08001483 free_commit_extra_headers(extra);
1484 return result;
1485}
1486
Linus Torvalds08a94a12012-06-28 11:24:14 -07001487static int find_invalid_utf8(const char *buf, int len)
1488{
1489 int offset = 0;
brian m. carlsone82bd6c2013-07-04 17:20:34 +00001490 static const unsigned int max_codepoint[] = {
1491 0x7f, 0x7ff, 0xffff, 0x10ffff
1492 };
Linus Torvalds08a94a12012-06-28 11:24:14 -07001493
1494 while (len) {
1495 unsigned char c = *buf++;
1496 int bytes, bad_offset;
brian m. carlson28110d42013-07-04 17:19:43 +00001497 unsigned int codepoint;
brian m. carlsone82bd6c2013-07-04 17:20:34 +00001498 unsigned int min_val, max_val;
Linus Torvalds08a94a12012-06-28 11:24:14 -07001499
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. carlson28110d42013-07-04 17:19:43 +00001519 /*
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 Torvalds08a94a12012-06-28 11:24:14 -07001524 return bad_offset;
1525
1526 /* Do we *have* that many bytes? */
1527 if (len < bytes)
1528 return bad_offset;
1529
brian m. carlsone82bd6c2013-07-04 17:20:34 +00001530 /*
1531 * Place the encoded bits at the bottom of the value and compute the
1532 * valid range.
1533 */
brian m. carlson28110d42013-07-04 17:19:43 +00001534 codepoint = (c & 0x7f) >> bytes;
brian m. carlsone82bd6c2013-07-04 17:20:34 +00001535 min_val = max_codepoint[bytes-1] + 1;
1536 max_val = max_codepoint[bytes];
brian m. carlson28110d42013-07-04 17:19:43 +00001537
Linus Torvalds08a94a12012-06-28 11:24:14 -07001538 offset += bytes;
1539 len -= bytes;
1540
1541 /* And verify that they are good continuation bytes */
1542 do {
brian m. carlson28110d42013-07-04 17:19:43 +00001543 codepoint <<= 6;
1544 codepoint |= *buf & 0x3f;
Linus Torvalds08a94a12012-06-28 11:24:14 -07001545 if ((*buf++ & 0xc0) != 0x80)
1546 return bad_offset;
1547 } while (--bytes);
1548
brian m. carlsone82bd6c2013-07-04 17:20:34 +00001549 /* Reject codepoints that are out of range for the sequence length. */
1550 if (codepoint < min_val || codepoint > max_val)
brian m. carlson28110d42013-07-04 17:19:43 +00001551 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 Krefting81050ac2013-07-09 12:16:33 +01001555 /* U+xxFFFE and U+xxFFFF are guaranteed non-characters. */
Junio C Hamanodc773a62013-08-05 09:52:28 -07001556 if ((codepoint & 0xfffe) == 0xfffe)
Peter Krefting81050ac2013-07-09 12:16:33 +01001557 return bad_offset;
1558 /* So are anything in the range U+FDD0..U+FDEF. */
1559 if (codepoint >= 0xfdd0 && codepoint <= 0xfdef)
brian m. carlson28110d42013-07-04 17:19:43 +00001560 return bad_offset;
Linus Torvalds08a94a12012-06-28 11:24:14 -07001561 }
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 Torvalds08a94a12012-06-28 11:24:14 -07001570 */
1571static 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 King40d52ff2010-04-01 20:05:23 -04001597static const char commit_utf8_warn[] =
Vasco Almeida4fa4b312016-09-19 13:08:16 +00001598N_("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 Xinb4eda052022-06-17 18:03:09 +08001600 "variable i18n.commitEncoding to the encoding your project uses.\n");
Jeff King40d52ff2010-04-01 20:05:23 -04001601
Jeff King3ffefb52014-06-10 17:36:52 -04001602int commit_tree_extended(const char *msg, size_t msg_len,
Patryk Obara5078f342018-01-28 01:13:16 +01001603 const struct object_id *tree,
1604 struct commit_list *parents, struct object_id *ret,
Phillip Woode8cbe212020-08-17 18:40:01 +01001605 const char *author, const char *committer,
1606 const char *sign_commit,
Junio C Hamanoba3c69a2011-10-05 17:23:20 -07001607 struct commit_extra_header *extra)
Jeff King40d52ff2010-04-01 20:05:23 -04001608{
1609 int result;
1610 int encoding_is_utf8;
1611 struct strbuf buffer;
1612
brian m. carlsone816caa2018-03-12 02:27:42 +00001613 assert_oid_type(tree, OBJ_TREE);
Jeff King40d52ff2010-04-01 20:05:23 -04001614
Jeff King3ffefb52014-06-10 17:36:52 -04001615 if (memchr(msg, '\0', msg_len))
Nguyễn Thái Ngọc Duy37576c12011-12-15 20:47:23 +07001616 return error("a NUL byte in commit log message not allowed.");
1617
Jeff King40d52ff2010-04-01 20:05:23 -04001618 /* 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 Obara5078f342018-01-28 01:13:16 +01001622 strbuf_addf(&buffer, "tree %s\n", oid_to_hex(tree));
Jeff King40d52ff2010-04-01 20:05:23 -04001623
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é Scharfee510ab82015-10-24 18:21:31 +02001630 struct commit *parent = pop_commit(&parents);
Jeff King40d52ff2010-04-01 20:05:23 -04001631 strbuf_addf(&buffer, "parent %s\n",
brian m. carlsonf2fd0762015-11-10 02:22:28 +00001632 oid_to_hex(&parent->object.oid));
Jeff King40d52ff2010-04-01 20:05:23 -04001633 }
1634
1635 /* Person/date information */
1636 if (!author)
Jeff Kingf9bc5732012-05-24 19:28:40 -04001637 author = git_author_info(IDENT_STRICT);
Jeff King40d52ff2010-04-01 20:05:23 -04001638 strbuf_addf(&buffer, "author %s\n", author);
Phillip Woode8cbe212020-08-17 18:40:01 +01001639 if (!committer)
1640 committer = git_committer_info(IDENT_STRICT);
1641 strbuf_addf(&buffer, "committer %s\n", committer);
Jeff King40d52ff2010-04-01 20:05:23 -04001642 if (!encoding_is_utf8)
1643 strbuf_addf(&buffer, "encoding %s\n", git_commit_encoding);
Junio C Hamano5231c632011-11-07 16:21:32 -08001644
1645 while (extra) {
1646 add_extra_header(&buffer, extra);
1647 extra = extra->next;
1648 }
Jeff King40d52ff2010-04-01 20:05:23 -04001649 strbuf_addch(&buffer, '\n');
1650
1651 /* And add the comment */
Jeff King3ffefb52014-06-10 17:36:52 -04001652 strbuf_add(&buffer, msg, msg_len);
Jeff King40d52ff2010-04-01 20:05:23 -04001653
1654 /* And check the encoding */
Linus Torvalds08a94a12012-06-28 11:24:14 -07001655 if (encoding_is_utf8 && !verify_utf8(&buffer))
Vasco Almeida4fa4b312016-09-19 13:08:16 +00001656 fprintf(stderr, _(commit_utf8_warn));
Jeff King40d52ff2010-04-01 20:05:23 -04001657
brian m. carlson937032e2021-02-11 02:08:04 +00001658 if (sign_commit && sign_with_header(&buffer, sign_commit)) {
Rene Scharfee5051462017-08-30 19:49:38 +02001659 result = -1;
1660 goto out;
1661 }
Junio C Hamanoba3c69a2011-10-05 17:23:20 -07001662
Ævar Arnfjörð Bjarmasonc80d2262022-02-05 00:48:26 +01001663 result = write_object_file(buffer.buf, buffer.len, OBJ_COMMIT, ret);
Rene Scharfee5051462017-08-30 19:49:38 +02001664out:
Jeff King40d52ff2010-04-01 20:05:23 -04001665 strbuf_release(&buffer);
1666 return result;
1667}
Junio C Hamanoae8e4c92011-11-07 13:26:22 -08001668
Nguyễn Thái Ngọc Duye2e5ac22018-05-19 07:28:30 +02001669define_commit_slab(merge_desc_slab, struct merge_remote_desc *);
1670static struct merge_desc_slab merge_desc_slab = COMMIT_SLAB_INIT(1, merge_desc_slab);
1671
1672struct merge_remote_desc *merge_remote_util(struct commit *commit)
1673{
1674 return *merge_desc_slab_at(&merge_desc_slab, commit);
1675}
1676
René Scharfebeb518c2016-08-13 14:11:27 +02001677void set_merge_remote_desc(struct commit *commit,
1678 const char *name, struct object *obj)
1679{
1680 struct merge_remote_desc *desc;
René Scharfe5447a762016-08-13 14:21:27 +02001681 FLEX_ALLOC_STR(desc, name, name);
René Scharfebeb518c2016-08-13 14:11:27 +02001682 desc->obj = obj;
Nguyễn Thái Ngọc Duye2e5ac22018-05-19 07:28:30 +02001683 *merge_desc_slab_at(&merge_desc_slab, commit) = desc;
René Scharfebeb518c2016-08-13 14:11:27 +02001684}
1685
Junio C Hamanoae8e4c92011-11-07 13:26:22 -08001686struct commit *get_merge_parent(const char *name)
1687{
1688 struct object *obj;
1689 struct commit *commit;
brian m. carlson7683e2e2015-03-13 23:39:34 +00001690 struct object_id oid;
Ævar Arnfjörð Bjarmasond850b7a2023-03-28 15:58:46 +02001691 if (repo_get_oid(the_repository, name, &oid))
Junio C Hamanoae8e4c92011-11-07 13:26:22 -08001692 return NULL;
Stefan Beller109cd762018-06-28 18:21:51 -07001693 obj = parse_object(the_repository, &oid);
Ævar Arnfjörð Bjarmasond850b7a2023-03-28 15:58:46 +02001694 commit = (struct commit *)repo_peel_to_type(the_repository, name, 0,
1695 obj, OBJ_COMMIT);
Nguyễn Thái Ngọc Duye2e5ac22018-05-19 07:28:30 +02001696 if (commit && !merge_remote_util(commit))
René Scharfebeb518c2016-08-13 14:11:27 +02001697 set_merge_remote_desc(commit, name, obj);
Junio C Hamanoae8e4c92011-11-07 13:26:22 -08001698 return commit;
1699}
René Scharfe89b5f1d2012-04-25 22:35:27 +02001700
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 */
1718struct commit_list **commit_list_append(struct commit *commit,
1719 struct commit_list **next)
1720{
Brandon Williams258c03e2018-02-14 10:59:37 -08001721 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é Scharfe89b5f1d2012-04-25 22:35:27 +02001726}
Nguyễn Thái Ngọc Duyefc7df42012-10-26 22:53:51 +07001727
John Caicfc5cf42022-01-06 20:07:35 +00001728const char *find_header_mem(const char *msg, size_t len,
1729 const char *key, size_t *out_len)
Jeff Kingfe6eb7f2014-08-27 03:56:01 -04001730{
1731 int key_len = strlen(key);
1732 const char *line = msg;
1733
John Caicfc5cf42022-01-06 20:07:35 +00001734 /*
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 Kingfe6eb7f2014-08-27 03:56:01 -04001742 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 Hamano0ed8a4e2014-12-22 12:26:23 -08001757
John Caicfc5cf42022-01-06 20:07:35 +00001758const 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 Couder8c384582014-11-09 10:23:41 +01001762/*
Jonathan Tan710714a2016-11-02 10:29:17 -07001763 * Inspect the given string and determine the true "end" of the log message, in
Bradley M. Kuhn3abd4a62020-10-19 18:03:55 -07001764 * order to find where to put a new Signed-off-by trailer. Ignored are
Brian Malehornd76650b2017-05-15 23:06:49 -07001765 * 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 Couder8c384582014-11-09 10:23:41 +01001768 *
1769 * Returns the number of bytes from the tail to ignore, to be fed as
1770 * the second parameter to append_signoff().
1771 */
Jeff King66e83d92018-08-22 20:50:51 -04001772size_t ignore_non_trailer(const char *buf, size_t len)
Christian Couder8c384582014-11-09 10:23:41 +01001773{
Jeff King66e83d92018-08-22 20:50:51 -04001774 size_t boc = 0;
1775 size_t bol = 0;
Christian Couder8c384582014-11-09 10:23:41 +01001776 int in_old_conflicts_block = 0;
Brian Malehornd76650b2017-05-15 23:06:49 -07001777 size_t cutoff = wt_status_locate_end(buf, len);
Christian Couder8c384582014-11-09 10:23:41 +01001778
Brian Malehornd76650b2017-05-15 23:06:49 -07001779 while (bol < cutoff) {
Jonathan Tan710714a2016-11-02 10:29:17 -07001780 const char *next_line = memchr(buf + bol, '\n', len - bol);
Christian Couder8c384582014-11-09 10:23:41 +01001781
Jonathan Tan710714a2016-11-02 10:29:17 -07001782 if (!next_line)
1783 next_line = buf + len;
Christian Couder8c384582014-11-09 10:23:41 +01001784 else
1785 next_line++;
1786
Jonathan Tan710714a2016-11-02 10:29:17 -07001787 if (buf[bol] == comment_line_char || buf[bol] == '\n') {
Christian Couder8c384582014-11-09 10:23:41 +01001788 /* is this the first of the run of comments? */
1789 if (!boc)
1790 boc = bol;
1791 /* otherwise, it is just continuing */
Jonathan Tan710714a2016-11-02 10:29:17 -07001792 } else if (starts_with(buf + bol, "Conflicts:\n")) {
Christian Couder8c384582014-11-09 10:23:41 +01001793 in_old_conflicts_block = 1;
1794 if (!boc)
1795 boc = bol;
Jonathan Tan710714a2016-11-02 10:29:17 -07001796 } else if (in_old_conflicts_block && buf[bol] == '\t') {
Christian Couder8c384582014-11-09 10:23:41 +01001797 ; /* 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 Tan710714a2016-11-02 10:29:17 -07001803 bol = next_line - buf;
Christian Couder8c384582014-11-09 10:23:41 +01001804 }
Brian Malehornd76650b2017-05-15 23:06:49 -07001805 return boc ? len - boc : len - cutoff;
Christian Couder8c384582014-11-09 10:23:41 +01001806}
Phillip Wood49697cb2019-10-15 10:25:31 +00001807
1808int run_commit_hook(int editor_is_used, const char *index_file,
Ævar Arnfjörð Bjarmasona8cc5942022-03-07 13:33:46 +01001809 int *invoked_hook, const char *name, ...)
Phillip Wood49697cb2019-10-15 10:25:31 +00001810{
Emily Shafferf4432462021-12-22 04:59:40 +01001811 struct run_hooks_opt opt = RUN_HOOKS_OPT_INIT;
Phillip Wood49697cb2019-10-15 10:25:31 +00001812 va_list args;
Emily Shafferf4432462021-12-22 04:59:40 +01001813 const char *arg;
Phillip Wood49697cb2019-10-15 10:25:31 +00001814
Emily Shafferf4432462021-12-22 04:59:40 +01001815 strvec_pushf(&opt.env, "GIT_INDEX_FILE=%s", index_file);
Phillip Wood49697cb2019-10-15 10:25:31 +00001816
1817 /*
1818 * Let the hook know that no editor will be launched.
1819 */
1820 if (!editor_is_used)
Emily Shafferf4432462021-12-22 04:59:40 +01001821 strvec_push(&opt.env, "GIT_EDITOR=:");
Phillip Wood49697cb2019-10-15 10:25:31 +00001822
1823 va_start(args, name);
Emily Shafferf4432462021-12-22 04:59:40 +01001824 while ((arg = va_arg(args, const char *)))
1825 strvec_push(&opt.args, arg);
Phillip Wood49697cb2019-10-15 10:25:31 +00001826 va_end(args);
Phillip Wood49697cb2019-10-15 10:25:31 +00001827
Ævar Arnfjörð Bjarmason4369e3a2022-03-22 00:15:13 +01001828 opt.invoked_hook = invoked_hook;
Emily Shafferf4432462021-12-22 04:59:40 +01001829 return run_hooks_opt(name, &opt);
Phillip Wood49697cb2019-10-15 10:25:31 +00001830}