blob: f53429c0ac34d933a06f6051cd6b5e519408e4be [file] [log] [blame]
Junio C Hamano8f1d2e62006-01-07 01:33:54 -08001#include "cache.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"
Jonathan Nieder6a1a79f2018-05-15 16:42:16 -07005#include "repository.h"
Stefan Bellercbd53a22018-05-15 16:42:15 -07006#include "object-store.h"
Johannes Schindelined09aef2006-10-30 20:09:06 +01007#include "pkt-line.h"
Junio C Hamano52883fb2006-12-25 11:48:35 -08008#include "utf8.h"
Junio C Hamano199c45b2007-04-09 02:34:05 -07009#include "diff.h"
10#include "revision.h"
Johannes Schindelina97a7462009-10-09 12:21:57 +020011#include "notes.h"
Stefan Beller14ba97f2018-05-15 14:48:42 -070012#include "alloc.h"
Junio C Hamanoba3c69a2011-10-05 17:23:20 -070013#include "gpg-interface.h"
René Scharfe46905892012-04-01 00:10:39 +020014#include "mergesort.h"
Junio C Hamanoa84b7942013-04-13 11:56:41 -070015#include "commit-slab.h"
Junio C Hamanoda24b102013-06-06 21:58:12 -070016#include "prio-queue.h"
Dmitry S. Dolzhenko0a9136f2014-02-26 22:49:22 +040017#include "sha1-lookup.h"
Brian Malehornd76650b2017-05-15 23:06:49 -070018#include "wt-status.h"
Johannes Schindelinf9f99b32018-04-29 00:44:44 +020019#include "advice.h"
Pratik Karki103148a2018-09-04 15:00:08 -070020#include "refs.h"
Junio C Hamano02931212018-11-02 11:04:55 +090021#include "commit-reach.h"
Phillip Wood49697cb2019-10-15 10:25:31 +000022#include "run-command.h"
Taylor Blau120ad2b2020-04-30 13:48:50 -060023#include "shallow.h"
Daniel Barkalow175785e2005-04-18 11:39:48 -070024
Junio C Hamano82a75292012-09-15 13:58:15 -070025static struct commit_extra_header *read_commit_extra_header_lines(const char *buf, size_t len, const char **);
26
Linus Torvalds60ab26d2005-09-15 14:43:17 -070027int save_commit_buffer = 1;
28
Daniel Barkalow175785e2005-04-18 11:39:48 -070029const char *commit_type = "commit";
30
Stefan Bellerd9a05e72018-06-28 18:22:21 -070031struct commit *lookup_commit_reference_gently(struct repository *r,
Stefan Beller21e1ee82018-06-28 18:21:57 -070032 const struct object_id *oid, int quiet)
Linus Torvalds961784e2005-05-18 16:14:22 -070033{
Stefan Bellerd9a05e72018-06-28 18:22:21 -070034 struct object *obj = deref_tag(r,
35 parse_object(r, oid),
Stefan Beller109cd762018-06-28 18:21:51 -070036 NULL, 0);
Linus Torvalds961784e2005-05-18 16:14:22 -070037
38 if (!obj)
39 return NULL;
Abhishek Kumar6da43d92020-06-17 14:44:08 +053040 return object_as_type(obj, OBJ_COMMIT, quiet);
Junio C Hamanof76412e2005-08-21 02:51:10 -070041}
42
Stefan Beller1f6c72f2018-06-28 18:22:22 -070043struct commit *lookup_commit_reference(struct repository *r, const struct object_id *oid)
Junio C Hamanof76412e2005-08-21 02:51:10 -070044{
Stefan Beller1f6c72f2018-06-28 18:22:22 -070045 return lookup_commit_reference_gently(r, oid, 0);
Linus Torvalds961784e2005-05-18 16:14:22 -070046}
47
brian m. carlsonbc832662017-05-06 22:10:10 +000048struct 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 +100049{
Stefan Beller2122f672018-06-28 18:21:58 -070050 struct commit *c = lookup_commit_reference(the_repository, oid);
Nguyễn Thái Ngọc Duybaf18fc2011-09-17 21:57:45 +100051 if (!c)
52 die(_("could not parse %s"), ref_name);
Jeff King9001dc22018-08-28 17:22:48 -040053 if (!oideq(oid, &c->object.oid)) {
Nguyễn Thái Ngọc Duybaf18fc2011-09-17 21:57:45 +100054 warning(_("%s %s is not a commit!"),
brian m. carlsonbc832662017-05-06 22:10:10 +000055 ref_name, oid_to_hex(oid));
Nguyễn Thái Ngọc Duybaf18fc2011-09-17 21:57:45 +100056 }
57 return c;
58}
59
Stefan Bellerbacf1682018-06-28 18:22:10 -070060struct commit *lookup_commit(struct repository *r, const struct object_id *oid)
Daniel Barkalow175785e2005-04-18 11:39:48 -070061{
Jeff Kingd0229ab2019-06-20 03:41:14 -040062 struct object *obj = lookup_object(r, oid);
Jeff Kingd36f51c2014-07-13 02:41:55 -040063 if (!obj)
Jeff Kinga3785092019-06-20 03:41:21 -040064 return create_object(r, oid, alloc_commit_node(r));
Abhishek Kumar6da43d92020-06-17 14:44:08 +053065 return object_as_type(obj, OBJ_COMMIT, 0);
Daniel Barkalow175785e2005-04-18 11:39:48 -070066}
67
Pat Notza6fa5992010-11-02 13:59:07 -060068struct commit *lookup_commit_reference_by_name(const char *name)
69{
brian m. carlson7683e2e2015-03-13 23:39:34 +000070 struct object_id oid;
Pat Notza6fa5992010-11-02 13:59:07 -060071 struct commit *commit;
72
brian m. carlsone82caf32017-07-13 23:49:28 +000073 if (get_oid_committish(name, &oid))
Pat Notza6fa5992010-11-02 13:59:07 -060074 return NULL;
Stefan Beller2122f672018-06-28 18:21:58 -070075 commit = lookup_commit_reference(the_repository, &oid);
Jeff King5e7d4d32013-10-24 04:53:19 -040076 if (parse_commit(commit))
Pat Notza6fa5992010-11-02 13:59:07 -060077 return NULL;
78 return commit;
79}
80
Johannes Schindelindddbad72017-04-26 21:29:31 +020081static timestamp_t parse_commit_date(const char *buf, const char *tail)
Daniel Barkalow175785e2005-04-18 11:39:48 -070082{
Martin Koegler0a617792008-01-19 18:35:23 +010083 const char *dateptr;
Daniel Barkalow175785e2005-04-18 11:39:48 -070084
Martin Koegler0a617792008-01-19 18:35:23 +010085 if (buf + 6 >= tail)
86 return 0;
Daniel Barkalow175785e2005-04-18 11:39:48 -070087 if (memcmp(buf, "author", 6))
88 return 0;
Martin Koegler0a617792008-01-19 18:35:23 +010089 while (buf < tail && *buf++ != '\n')
Daniel Barkalow175785e2005-04-18 11:39:48 -070090 /* nada */;
Martin Koegler0a617792008-01-19 18:35:23 +010091 if (buf + 9 >= tail)
92 return 0;
Daniel Barkalow175785e2005-04-18 11:39:48 -070093 if (memcmp(buf, "committer", 9))
94 return 0;
Martin Koegler0a617792008-01-19 18:35:23 +010095 while (buf < tail && *buf++ != '>')
Daniel Barkalow175785e2005-04-18 11:39:48 -070096 /* nada */;
Martin Koegler0a617792008-01-19 18:35:23 +010097 if (buf >= tail)
98 return 0;
99 dateptr = buf;
100 while (buf < tail && *buf++ != '\n')
101 /* nada */;
102 if (buf >= tail)
103 return 0;
Johannes Schindelin1aeb7e72017-04-21 12:45:44 +0200104 /* dateptr < buf && buf[-1] == '\n', so parsing will stop at buf-1 */
105 return parse_timestamp(dateptr, NULL, 10);
Daniel Barkalow175785e2005-04-18 11:39:48 -0700106}
107
Dmitry S. Dolzhenko0a9136f2014-02-26 22:49:22 +0400108static const unsigned char *commit_graft_sha1_access(size_t index, void *table)
109{
110 struct commit_graft **commit_graft_table = table;
brian m. carlson7683e2e2015-03-13 23:39:34 +0000111 return commit_graft_table[index]->oid.hash;
Dmitry S. Dolzhenko0a9136f2014-02-26 22:49:22 +0400112}
113
Taylor Blau183df642020-04-30 15:11:28 -0600114int commit_graft_pos(struct repository *r, const unsigned char *sha1)
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700115{
Brandon Williamse8086562018-05-17 15:51:47 -0700116 return sha1_pos(sha1, r->parsed_objects->grafts,
117 r->parsed_objects->grafts_nr,
Dmitry S. Dolzhenko0a9136f2014-02-26 22:49:22 +0400118 commit_graft_sha1_access);
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700119}
120
Brandon Williamsa3b78e82018-05-17 15:51:48 -0700121int register_commit_graft(struct repository *r, struct commit_graft *graft,
122 int ignore_dups)
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700123{
Brandon Williamsa3b78e82018-05-17 15:51:48 -0700124 int pos = commit_graft_pos(r, graft->oid.hash);
Junio C Hamanoa6080a02007-06-07 00:04:01 -0700125
Junio C Hamano5040f172006-04-06 23:58:51 -0700126 if (0 <= pos) {
127 if (ignore_dups)
128 free(graft);
129 else {
Brandon Williamsa3b78e82018-05-17 15:51:48 -0700130 free(r->parsed_objects->grafts[pos]);
131 r->parsed_objects->grafts[pos] = graft;
Junio C Hamano5040f172006-04-06 23:58:51 -0700132 }
133 return 1;
134 }
135 pos = -pos - 1;
Brandon Williamsa3b78e82018-05-17 15:51:48 -0700136 ALLOC_GROW(r->parsed_objects->grafts,
137 r->parsed_objects->grafts_nr + 1,
138 r->parsed_objects->grafts_alloc);
139 r->parsed_objects->grafts_nr++;
140 if (pos < r->parsed_objects->grafts_nr)
141 memmove(r->parsed_objects->grafts + pos + 1,
142 r->parsed_objects->grafts + pos,
143 (r->parsed_objects->grafts_nr - pos - 1) *
144 sizeof(*r->parsed_objects->grafts));
145 r->parsed_objects->grafts[pos] = graft;
Junio C Hamano5040f172006-04-06 23:58:51 -0700146 return 0;
147}
148
Patryk Obara9a934032017-08-18 20:33:12 +0200149struct commit_graft *read_graft_line(struct strbuf *line)
Junio C Hamano5040f172006-04-06 23:58:51 -0700150{
151 /* The format is just "Commit Parent1 Parent2 ...\n" */
Patryk Obaracfa5bf12017-08-18 20:33:14 +0200152 int i, phase;
153 const char *tail = NULL;
Junio C Hamano5040f172006-04-06 23:58:51 -0700154 struct commit_graft *graft = NULL;
Patryk Obaracfa5bf12017-08-18 20:33:14 +0200155 struct object_id dummy_oid, *oid;
Junio C Hamano5040f172006-04-06 23:58:51 -0700156
Patryk Obara9a934032017-08-18 20:33:12 +0200157 strbuf_rtrim(line);
158 if (!line->len || line->buf[0] == '#')
Junio C Hamano5bc4ce52006-04-16 14:24:56 -0700159 return NULL;
Patryk Obaracfa5bf12017-08-18 20:33:14 +0200160 /*
161 * phase 0 verifies line, counts hashes in line and allocates graft
162 * phase 1 fills graft
163 */
164 for (phase = 0; phase < 2; phase++) {
165 oid = graft ? &graft->oid : &dummy_oid;
166 if (parse_oid_hex(line->buf, oid, &tail))
Junio C Hamano5040f172006-04-06 23:58:51 -0700167 goto bad_graft_data;
Patryk Obaracfa5bf12017-08-18 20:33:14 +0200168 for (i = 0; *tail != '\0'; i++) {
169 oid = graft ? &graft->parent[i] : &dummy_oid;
170 if (!isspace(*tail++) || parse_oid_hex(tail, oid, &tail))
171 goto bad_graft_data;
172 }
173 if (!graft) {
174 graft = xmalloc(st_add(sizeof(*graft),
175 st_mult(sizeof(struct object_id), i)));
176 graft->nr_parent = i;
177 }
Junio C Hamano5040f172006-04-06 23:58:51 -0700178 }
179 return graft;
Ralf Thielowdf5d43b2010-12-01 20:15:59 +0100180
181bad_graft_data:
Patryk Obara9a934032017-08-18 20:33:12 +0200182 error("bad graft data: %s", line->buf);
Patryk Obaracfa5bf12017-08-18 20:33:14 +0200183 assert(!graft);
Ralf Thielowdf5d43b2010-12-01 20:15:59 +0100184 return NULL;
Junio C Hamano5040f172006-04-06 23:58:51 -0700185}
186
Brandon Williamsd0e5dd02018-05-17 15:51:49 -0700187static int read_graft_file(struct repository *r, const char *graft_file)
Junio C Hamano5040f172006-04-06 23:58:51 -0700188{
Nguyễn Thái Ngọc Duye9d983f2017-05-03 17:16:50 +0700189 FILE *fp = fopen_or_warn(graft_file, "r");
Johannes Schindeline228c172013-12-27 21:49:57 +0100190 struct strbuf buf = STRBUF_INIT;
Junio C Hamano5040f172006-04-06 23:58:51 -0700191 if (!fp)
192 return -1;
Johannes Schindelinf9f99b32018-04-29 00:44:44 +0200193 if (advice_graft_file_deprecated)
194 advise(_("Support for <GIT_DIR>/info/grafts is deprecated\n"
195 "and will be removed in a future Git version.\n"
196 "\n"
197 "Please use \"git replace --convert-graft-file\"\n"
198 "to convert the grafts into replace refs.\n"
199 "\n"
200 "Turn this message off by running\n"
201 "\"git config advice.graftFileDeprecated false\""));
Johannes Schindeline228c172013-12-27 21:49:57 +0100202 while (!strbuf_getwholeline(&buf, fp, '\n')) {
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700203 /* The format is just "Commit Parent1 Parent2 ...\n" */
Patryk Obara9a934032017-08-18 20:33:12 +0200204 struct commit_graft *graft = read_graft_line(&buf);
Junio C Hamano5bc4ce52006-04-16 14:24:56 -0700205 if (!graft)
206 continue;
Brandon Williamsd0e5dd02018-05-17 15:51:49 -0700207 if (register_commit_graft(r, graft, 1))
Johannes Schindeline228c172013-12-27 21:49:57 +0100208 error("duplicate graft data: %s", buf.buf);
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700209 }
210 fclose(fp);
Johannes Schindeline228c172013-12-27 21:49:57 +0100211 strbuf_release(&buf);
Junio C Hamano5040f172006-04-06 23:58:51 -0700212 return 0;
213}
214
Derrick Stolee20fd6d52018-08-20 18:24:30 +0000215void prepare_commit_graft(struct repository *r)
Junio C Hamano5040f172006-04-06 23:58:51 -0700216{
Junio C Hamano5040f172006-04-06 23:58:51 -0700217 char *graft_file;
218
Stefan Beller2f6c7672018-05-17 15:51:53 -0700219 if (r->parsed_objects->commit_graft_prepared)
Junio C Hamano5040f172006-04-06 23:58:51 -0700220 return;
Jeff King14a9bd22018-05-31 18:42:53 -0400221 if (!startup_info->have_repository)
222 return;
223
Stefan Beller2f6c7672018-05-17 15:51:53 -0700224 graft_file = get_graft_file(r);
225 read_graft_file(r, graft_file);
Johannes Schindelined09aef2006-10-30 20:09:06 +0100226 /* make sure shallows are read */
Stefan Beller2f6c7672018-05-17 15:51:53 -0700227 is_repository_shallow(r);
228 r->parsed_objects->commit_graft_prepared = 1;
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700229}
230
Stefan Bellerb9dbddf2018-05-17 15:51:54 -0700231struct commit_graft *lookup_commit_graft(struct repository *r, const struct object_id *oid)
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700232{
233 int pos;
Stefan Bellerb9dbddf2018-05-17 15:51:54 -0700234 prepare_commit_graft(r);
235 pos = commit_graft_pos(r, oid->hash);
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700236 if (pos < 0)
237 return NULL;
Stefan Bellerb9dbddf2018-05-17 15:51:54 -0700238 return r->parsed_objects->grafts[pos];
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700239}
240
Nguyễn Thái Ngọc Duy09d46642011-08-18 19:29:35 +0700241int for_each_commit_graft(each_commit_graft_fn fn, void *cb_data)
Johannes Schindelined09aef2006-10-30 20:09:06 +0100242{
Nguyễn Thái Ngọc Duy09d46642011-08-18 19:29:35 +0700243 int i, ret;
Jonathan Nieder6a1a79f2018-05-15 16:42:16 -0700244 for (i = ret = 0; i < the_repository->parsed_objects->grafts_nr && !ret; i++)
245 ret = fn(the_repository->parsed_objects->grafts[i], cb_data);
Nguyễn Thái Ngọc Duy09d46642011-08-18 19:29:35 +0700246 return ret;
Johannes Schindelined09aef2006-10-30 20:09:06 +0100247}
248
Jeff King8597ea32014-06-10 17:44:13 -0400249struct commit_buffer {
250 void *buffer;
251 unsigned long size;
252};
253define_commit_slab(buffer_slab, struct commit_buffer);
Jeff Kingc1b3c712014-06-10 17:43:02 -0400254
Stefan Beller65ea9d42018-06-28 18:22:15 -0700255struct buffer_slab *allocate_commit_buffer_slab(void)
Jeff King66c28272014-06-10 17:40:14 -0400256{
Stefan Beller65ea9d42018-06-28 18:22:15 -0700257 struct buffer_slab *bs = xmalloc(sizeof(*bs));
258 init_buffer_slab(bs);
259 return bs;
260}
261
262void free_commit_buffer_slab(struct buffer_slab *bs)
263{
264 clear_buffer_slab(bs);
265 free(bs);
266}
Johannes Schindelinf53514b2006-10-30 20:09:53 +0100267
Stefan Beller1a40fc42018-06-28 18:22:16 -0700268void set_commit_buffer(struct repository *r, struct commit *commit, void *buffer, unsigned long size)
Jeff King66c28272014-06-10 17:40:14 -0400269{
Stefan Beller65ea9d42018-06-28 18:22:15 -0700270 struct commit_buffer *v = buffer_slab_at(
Stefan Beller1a40fc42018-06-28 18:22:16 -0700271 r->parsed_objects->buffer_slab, commit);
Jeff King8597ea32014-06-10 17:44:13 -0400272 v->buffer = buffer;
273 v->size = size;
Jeff King66c28272014-06-10 17:40:14 -0400274}
275
Stefan Beller4ff7e5c2018-06-28 18:22:17 -0700276const void *get_cached_commit_buffer(struct repository *r, const struct commit *commit, unsigned long *sizep)
Jeff King152ff1c2014-06-10 17:40:39 -0400277{
Stefan Beller65ea9d42018-06-28 18:22:15 -0700278 struct commit_buffer *v = buffer_slab_peek(
Stefan Beller4ff7e5c2018-06-28 18:22:17 -0700279 r->parsed_objects->buffer_slab, commit);
Junio C Hamano862e7302015-05-14 15:25:52 -0700280 if (!v) {
281 if (sizep)
282 *sizep = 0;
283 return NULL;
284 }
Jeff King8597ea32014-06-10 17:44:13 -0400285 if (sizep)
286 *sizep = v->size;
287 return v->buffer;
Jeff King152ff1c2014-06-10 17:40:39 -0400288}
289
Stefan Beller07de3fd2018-11-13 16:12:57 -0800290const void *repo_get_commit_buffer(struct repository *r,
291 const struct commit *commit,
292 unsigned long *sizep)
Jeff King152ff1c2014-06-10 17:40:39 -0400293{
Stefan Beller07de3fd2018-11-13 16:12:57 -0800294 const void *ret = get_cached_commit_buffer(r, commit, sizep);
Jeff King152ff1c2014-06-10 17:40:39 -0400295 if (!ret) {
296 enum object_type type;
297 unsigned long size;
Stefan Beller07de3fd2018-11-13 16:12:57 -0800298 ret = repo_read_object_file(r, &commit->object.oid, &type, &size);
Jeff King152ff1c2014-06-10 17:40:39 -0400299 if (!ret)
300 die("cannot read commit object %s",
brian m. carlsonf2fd0762015-11-10 02:22:28 +0000301 oid_to_hex(&commit->object.oid));
Jeff King152ff1c2014-06-10 17:40:39 -0400302 if (type != OBJ_COMMIT)
303 die("expected commit for %s, got %s",
Brandon Williamsdebca9d2018-02-14 10:59:24 -0800304 oid_to_hex(&commit->object.oid), type_name(type));
Jeff King8597ea32014-06-10 17:44:13 -0400305 if (sizep)
306 *sizep = size;
Jeff King152ff1c2014-06-10 17:40:39 -0400307 }
308 return ret;
309}
310
Stefan Beller70315372018-11-13 16:12:58 -0800311void repo_unuse_commit_buffer(struct repository *r,
312 const struct commit *commit,
313 const void *buffer)
Jeff King152ff1c2014-06-10 17:40:39 -0400314{
Stefan Beller65ea9d42018-06-28 18:22:15 -0700315 struct commit_buffer *v = buffer_slab_peek(
Stefan Beller70315372018-11-13 16:12:58 -0800316 r->parsed_objects->buffer_slab, commit);
Junio C Hamano862e7302015-05-14 15:25:52 -0700317 if (!(v && v->buffer == buffer))
Jeff King152ff1c2014-06-10 17:40:39 -0400318 free((void *)buffer);
319}
320
Stefan Beller6a7895f2018-12-14 16:09:40 -0800321void free_commit_buffer(struct parsed_object_pool *pool, struct commit *commit)
Jeff King0fb370d2014-06-12 18:05:37 -0400322{
Stefan Beller65ea9d42018-06-28 18:22:15 -0700323 struct commit_buffer *v = buffer_slab_peek(
Stefan Beller6a7895f2018-12-14 16:09:40 -0800324 pool->buffer_slab, commit);
Junio C Hamano862e7302015-05-14 15:25:52 -0700325 if (v) {
Ævar Arnfjörð Bjarmason6a83d902017-06-15 23:15:46 +0000326 FREE_AND_NULL(v->buffer);
Junio C Hamano862e7302015-05-14 15:25:52 -0700327 v->size = 0;
328 }
Jeff King0fb370d2014-06-12 18:05:37 -0400329}
330
Nguyễn Thái Ngọc Duya133c402019-04-16 16:33:18 +0700331static inline void set_commit_tree(struct commit *c, struct tree *t)
332{
333 c->maybe_tree = t;
334}
335
Nguyễn Thái Ngọc Duy301b8c72019-04-16 16:33:19 +0700336struct tree *repo_get_commit_tree(struct repository *r,
337 const struct commit *commit)
Derrick Stolee5bb03de2018-04-06 19:09:34 +0000338{
Derrick Stolee7b8a21d2018-04-06 19:09:46 +0000339 if (commit->maybe_tree || !commit->object.parsed)
340 return commit->maybe_tree;
341
Abhishek Kumarc49c82a2020-06-17 14:44:10 +0530342 if (commit_graph_position(commit) != COMMIT_NOT_FROM_GRAPH)
Junio C Hamanoea2dab12019-05-09 00:37:25 +0900343 return get_commit_tree_in_graph(r, commit);
Derrick Stolee7b8a21d2018-04-06 19:09:46 +0000344
Jeff King83487662019-04-09 19:13:20 -0700345 return NULL;
Derrick Stolee5bb03de2018-04-06 19:09:34 +0000346}
347
348struct object_id *get_commit_tree_oid(const struct commit *commit)
349{
Taylor Blau806278d2019-09-05 18:04:57 -0400350 struct tree *tree = get_commit_tree(commit);
351 return tree ? &tree->object.oid : NULL;
Derrick Stolee5bb03de2018-04-06 19:09:34 +0000352}
353
Stefan Beller6a7895f2018-12-14 16:09:40 -0800354void release_commit_memory(struct parsed_object_pool *pool, struct commit *c)
Stefan Beller14ba97f2018-05-15 14:48:42 -0700355{
Nguyễn Thái Ngọc Duya133c402019-04-16 16:33:18 +0700356 set_commit_tree(c, NULL);
Stefan Beller6a7895f2018-12-14 16:09:40 -0800357 free_commit_buffer(pool, c);
Mike Hommey9784f972019-08-26 11:01:37 +0900358 c->index = 0;
Stefan Beller14ba97f2018-05-15 14:48:42 -0700359 free_commit_list(c->parents);
Stefan Beller14ba97f2018-05-15 14:48:42 -0700360
361 c->object.parsed = 0;
362}
363
Jeff King8597ea32014-06-10 17:44:13 -0400364const void *detach_commit_buffer(struct commit *commit, unsigned long *sizep)
Jeff King0fb370d2014-06-12 18:05:37 -0400365{
Stefan Beller65ea9d42018-06-28 18:22:15 -0700366 struct commit_buffer *v = buffer_slab_peek(
367 the_repository->parsed_objects->buffer_slab, commit);
Jeff King8597ea32014-06-10 17:44:13 -0400368 void *ret;
369
Junio C Hamano862e7302015-05-14 15:25:52 -0700370 if (!v) {
371 if (sizep)
372 *sizep = 0;
373 return NULL;
374 }
Jeff King8597ea32014-06-10 17:44:13 -0400375 ret = v->buffer;
376 if (sizep)
377 *sizep = v->size;
378
379 v->buffer = NULL;
380 v->size = 0;
Jeff King0fb370d2014-06-12 18:05:37 -0400381 return ret;
382}
383
Stefan Bellerfd8030c2018-06-28 18:22:13 -0700384int 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 -0700385{
Nguyễn Thái Ngọc Duycf7b1ca2011-02-05 17:52:20 +0700386 const char *tail = buffer;
387 const char *bufptr = buffer;
brian m. carlson7683e2e2015-03-13 23:39:34 +0000388 struct object_id parent;
Linus Torvalds6c88be12005-06-20 20:26:03 -0700389 struct commit_list **pptr;
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700390 struct commit_graft *graft;
brian m. carlson2770ccb2018-07-16 01:27:56 +0000391 const int tree_entry_len = the_hash_algo->hexsz + 5;
392 const int parent_entry_len = the_hash_algo->hexsz + 7;
Jeff King12736d22019-10-18 00:43:29 -0400393 struct tree *tree;
Nicolas Pitrebd2c39f2005-05-06 13:48:34 -0400394
Daniel Barkalow175785e2005-04-18 11:39:48 -0700395 if (item->object.parsed)
396 return 0;
Jeff King228c78f2019-10-25 17:20:20 -0400397
398 if (item->parents) {
399 /*
400 * Presumably this is leftover from an earlier failed parse;
401 * clear it out in preparation for us re-parsing (we'll hit the
402 * same error, but that's good, since it lets our caller know
403 * the result cannot be trusted.
404 */
405 free_commit_list(item->parents);
406 item->parents = NULL;
407 }
408
Junio C Hamano3b44f152006-06-28 03:51:00 -0700409 tail += size;
brian m. carlson7683e2e2015-03-13 23:39:34 +0000410 if (tail <= bufptr + tree_entry_len + 1 || memcmp(bufptr, "tree ", 5) ||
411 bufptr[tree_entry_len] != '\n')
brian m. carlsonf2fd0762015-11-10 02:22:28 +0000412 return error("bogus commit object %s", oid_to_hex(&item->object.oid));
brian m. carlson26ea3e72018-05-02 00:25:47 +0000413 if (get_oid_hex(bufptr + 5, &parent) < 0)
Junio C Hamanobd2afde2006-02-22 17:47:10 -0800414 return error("bad tree pointer in commit %s",
brian m. carlsonf2fd0762015-11-10 02:22:28 +0000415 oid_to_hex(&item->object.oid));
Jeff King12736d22019-10-18 00:43:29 -0400416 tree = lookup_tree(r, &parent);
417 if (!tree)
418 return error("bad tree pointer %s in commit %s",
419 oid_to_hex(&parent),
420 oid_to_hex(&item->object.oid));
421 set_commit_tree(item, tree);
brian m. carlson7683e2e2015-03-13 23:39:34 +0000422 bufptr += tree_entry_len + 1; /* "tree " + "hex sha1" + "\n" */
Linus Torvalds6c88be12005-06-20 20:26:03 -0700423 pptr = &item->parents;
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700424
Stefan Bellerfd8030c2018-06-28 18:22:13 -0700425 graft = lookup_commit_graft(r, &item->object.oid);
Taylor Blauce163642020-07-08 17:10:53 -0400426 if (graft)
427 r->parsed_objects->substituted_parent = 1;
brian m. carlson7683e2e2015-03-13 23:39:34 +0000428 while (bufptr + parent_entry_len < tail && !memcmp(bufptr, "parent ", 7)) {
Linus Torvaldsf7cc77d2005-07-27 15:12:48 -0700429 struct commit *new_parent;
430
brian m. carlson7683e2e2015-03-13 23:39:34 +0000431 if (tail <= bufptr + parent_entry_len + 1 ||
brian m. carlson26ea3e72018-05-02 00:25:47 +0000432 get_oid_hex(bufptr + 7, &parent) ||
brian m. carlson7683e2e2015-03-13 23:39:34 +0000433 bufptr[parent_entry_len] != '\n')
brian m. carlsonf2fd0762015-11-10 02:22:28 +0000434 return error("bad parents in commit %s", oid_to_hex(&item->object.oid));
brian m. carlson7683e2e2015-03-13 23:39:34 +0000435 bufptr += parent_entry_len + 1;
Johannes Schindelin7f3140c2009-07-23 17:33:49 +0200436 /*
437 * The clone is shallow if nr_parent < 0, and we must
438 * not traverse its real parents even when we unhide them.
439 */
440 if (graft && (graft->nr_parent < 0 || grafts_replace_parents))
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700441 continue;
Stefan Bellerfd8030c2018-06-28 18:22:13 -0700442 new_parent = lookup_commit(r, &parent);
Jeff Kingc78fe002019-10-18 00:42:13 -0400443 if (!new_parent)
444 return error("bad parent %s in commit %s",
445 oid_to_hex(&parent),
446 oid_to_hex(&item->object.oid));
447 pptr = &commit_list_insert(new_parent, pptr)->next;
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700448 }
449 if (graft) {
450 int i;
451 struct commit *new_parent;
452 for (i = 0; i < graft->nr_parent; i++) {
Stefan Bellerfd8030c2018-06-28 18:22:13 -0700453 new_parent = lookup_commit(r,
Stefan Bellerc1f5eb42018-06-28 18:21:59 -0700454 &graft->parent[i]);
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700455 if (!new_parent)
Jeff Kingc78fe002019-10-18 00:42:13 -0400456 return error("bad graft parent %s in commit %s",
457 oid_to_hex(&graft->parent[i]),
458 oid_to_hex(&item->object.oid));
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700459 pptr = &commit_list_insert(new_parent, pptr)->next;
Junio C Hamano5da5c8f2005-07-30 00:58:28 -0700460 }
Daniel Barkalow175785e2005-04-18 11:39:48 -0700461 }
Martin Koegler0a617792008-01-19 18:35:23 +0100462 item->date = parse_commit_date(bufptr, tail);
Junio C Hamano27dedf02005-11-16 21:32:44 -0800463
Derrick Stoleee2838d82018-05-01 12:47:13 +0000464 if (check_graph)
Derrick Stoleec7944052019-05-09 07:22:31 -0700465 load_commit_graph_info(r, item);
Derrick Stoleee2838d82018-05-01 12:47:13 +0000466
Jeff King228c78f2019-10-25 17:20:20 -0400467 item->object.parsed = 1;
Daniel Barkalow175785e2005-04-18 11:39:48 -0700468 return 0;
469}
470
Stefan Beller9e5252a2018-11-13 16:12:50 -0800471int repo_parse_commit_internal(struct repository *r,
472 struct commit *item,
473 int quiet_on_missing,
474 int use_commit_graph)
Nicolas Pitrebd2c39f2005-05-06 13:48:34 -0400475{
Nicolas Pitre21666f12007-02-26 14:55:59 -0500476 enum object_type type;
Nicolas Pitrebd2c39f2005-05-06 13:48:34 -0400477 void *buffer;
478 unsigned long size;
479 int ret;
480
Martin Koegler9786f682008-02-18 21:48:02 +0100481 if (!item)
482 return -1;
Nicolas Pitrebd2c39f2005-05-06 13:48:34 -0400483 if (item->object.parsed)
484 return 0;
Stefan Beller9e5252a2018-11-13 16:12:50 -0800485 if (use_commit_graph && parse_commit_in_graph(r, item))
Derrick Stolee177722b2018-04-10 08:56:05 -0400486 return 0;
Stefan Beller9e5252a2018-11-13 16:12:50 -0800487 buffer = repo_read_object_file(r, &item->object.oid, &type, &size);
Nicolas Pitrebd2c39f2005-05-06 13:48:34 -0400488 if (!buffer)
Jeff King9cc2b072015-06-01 05:56:26 -0400489 return quiet_on_missing ? -1 :
490 error("Could not read %s",
brian m. carlsonf2fd0762015-11-10 02:22:28 +0000491 oid_to_hex(&item->object.oid));
Nicolas Pitre21666f12007-02-26 14:55:59 -0500492 if (type != OBJ_COMMIT) {
Nicolas Pitrebd2c39f2005-05-06 13:48:34 -0400493 free(buffer);
494 return error("Object %s not a commit",
brian m. carlsonf2fd0762015-11-10 02:22:28 +0000495 oid_to_hex(&item->object.oid));
Nicolas Pitrebd2c39f2005-05-06 13:48:34 -0400496 }
Derrick Stolee9b19ada2018-06-27 09:24:30 -0400497
Stefan Beller9e5252a2018-11-13 16:12:50 -0800498 ret = parse_commit_buffer(r, item, buffer, size, 0);
Linus Torvalds60ab26d2005-09-15 14:43:17 -0700499 if (save_commit_buffer && !ret) {
Stefan Beller9e5252a2018-11-13 16:12:50 -0800500 set_commit_buffer(r, item, buffer, size);
Linus Torvalds3ff1fbb2005-05-25 18:27:14 -0700501 return 0;
502 }
Nicolas Pitrebd2c39f2005-05-06 13:48:34 -0400503 free(buffer);
504 return ret;
505}
506
Stefan Beller9e5252a2018-11-13 16:12:50 -0800507int repo_parse_commit_gently(struct repository *r,
508 struct commit *item, int quiet_on_missing)
Derrick Stolee9b19ada2018-06-27 09:24:30 -0400509{
Stefan Beller9e5252a2018-11-13 16:12:50 -0800510 return repo_parse_commit_internal(r, item, quiet_on_missing, 1);
Derrick Stolee9b19ada2018-06-27 09:24:30 -0400511}
512
Jeff King7059dcc2013-10-24 04:52:36 -0400513void parse_commit_or_die(struct commit *item)
514{
515 if (parse_commit(item))
516 die("unable to parse commit %s",
brian m. carlsonf2fd0762015-11-10 02:22:28 +0000517 item ? oid_to_hex(&item->object.oid) : "(null)");
Jeff King7059dcc2013-10-24 04:52:36 -0400518}
519
Christian Couder11af2aa2010-07-22 15:18:30 +0200520int find_commit_subject(const char *commit_buffer, const char **subject)
521{
522 const char *eol;
523 const char *p = commit_buffer;
524
525 while (*p && (*p != '\n' || p[1] != '\n'))
526 p++;
527 if (*p) {
Johannes Schindelin4e1b06d2016-06-22 22:20:20 +0200528 p = skip_blank_lines(p + 2);
Junio C Hamano9c9b03b2017-01-27 18:01:41 -0800529 eol = strchrnul(p, '\n');
Christian Couder11af2aa2010-07-22 15:18:30 +0200530 } else
531 eol = p;
532
533 *subject = p;
534
535 return eol - p;
536}
537
Linus Torvaldsac5155e2005-05-30 18:44:02 -0700538struct commit_list *commit_list_insert(struct commit *item, struct commit_list **list_p)
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700539{
Christopher Li812666c2005-04-26 12:00:58 -0700540 struct commit_list *new_list = xmalloc(sizeof(struct commit_list));
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700541 new_list->item = item;
542 new_list->next = *list_p;
543 *list_p = new_list;
Linus Torvaldsac5155e2005-05-30 18:44:02 -0700544 return new_list;
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700545}
546
Miklos Vajna65319472008-06-27 18:21:55 +0200547unsigned commit_list_count(const struct commit_list *l)
548{
549 unsigned c = 0;
550 for (; l; l = l->next )
551 c++;
552 return c;
553}
554
Thomas Rast53d00b32013-07-31 22:13:20 +0200555struct commit_list *copy_commit_list(struct commit_list *list)
556{
557 struct commit_list *head = NULL;
558 struct commit_list **pp = &head;
559 while (list) {
René Scharfecb979db2014-07-10 11:47:47 +0200560 pp = commit_list_append(list->item, pp);
Thomas Rast53d00b32013-07-31 22:13:20 +0200561 list = list->next;
562 }
563 return head;
564}
565
Daniel Barkalow175785e2005-04-18 11:39:48 -0700566void free_commit_list(struct commit_list *list)
567{
René Scharfee510ab82015-10-24 18:21:31 +0200568 while (list)
569 pop_commit(&list);
Daniel Barkalow175785e2005-04-18 11:39:48 -0700570}
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700571
Thiago Farina47e44ed2010-11-26 23:58:14 -0200572struct commit_list * commit_list_insert_by_date(struct commit *item, struct commit_list **list)
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700573{
574 struct commit_list **pp = list;
575 struct commit_list *p;
576 while ((p = *pp) != NULL) {
577 if (p->item->date < item->date) {
578 break;
579 }
580 pp = &p->next;
581 }
Linus Torvaldsf7554942005-07-06 09:31:17 -0700582 return commit_list_insert(item, pp);
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700583}
584
René Scharfe46905892012-04-01 00:10:39 +0200585static int commit_list_compare_by_date(const void *a, const void *b)
586{
Johannes Schindelindddbad72017-04-26 21:29:31 +0200587 timestamp_t a_date = ((const struct commit_list *)a)->item->date;
588 timestamp_t b_date = ((const struct commit_list *)b)->item->date;
René Scharfe46905892012-04-01 00:10:39 +0200589 if (a_date < b_date)
590 return 1;
591 if (a_date > b_date)
592 return -1;
593 return 0;
594}
595
596static void *commit_list_get_next(const void *a)
597{
598 return ((const struct commit_list *)a)->next;
599}
600
601static void commit_list_set_next(void *a, void *next)
602{
603 ((struct commit_list *)a)->next = next;
604}
Junio C Hamanoa6080a02007-06-07 00:04:01 -0700605
Thiago Farina47e44ed2010-11-26 23:58:14 -0200606void commit_list_sort_by_date(struct commit_list **list)
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700607{
Junio C Hamano7365c952012-04-17 11:07:01 -0700608 *list = llist_mergesort(*list, commit_list_get_next, commit_list_set_next,
609 commit_list_compare_by_date);
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700610}
611
Daniel Barkalow58e28af2005-04-23 20:29:22 -0700612struct commit *pop_most_recent_commit(struct commit_list **list,
613 unsigned int mark)
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700614{
René Scharfee510ab82015-10-24 18:21:31 +0200615 struct commit *ret = pop_commit(list);
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700616 struct commit_list *parents = ret->parents;
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700617
618 while (parents) {
Linus Torvalds4056c092005-04-23 19:21:28 -0700619 struct commit *commit = parents->item;
Martin Koeglerdec38c82008-02-18 21:48:03 +0100620 if (!parse_commit(commit) && !(commit->object.flags & mark)) {
Daniel Barkalow58e28af2005-04-23 20:29:22 -0700621 commit->object.flags |= mark;
Thiago Farina47e44ed2010-11-26 23:58:14 -0200622 commit_list_insert_by_date(commit, list);
Linus Torvalds4056c092005-04-23 19:21:28 -0700623 }
Daniel Barkalowdd97f852005-04-23 18:47:23 -0700624 parents = parents->next;
625 }
626 return ret;
627}
Linus Torvaldse3bc7a32005-06-01 08:34:23 -0700628
Nguyễn Thái Ngọc Duy941ba8d2012-01-14 19:19:53 +0700629static void clear_commit_marks_1(struct commit_list **plist,
630 struct commit *commit, unsigned int mark)
Junio C Hamanof8f9c732006-01-07 18:52:42 -0800631{
Johannes Schindelin60fcc2e2007-10-10 23:14:35 +0100632 while (commit) {
633 struct commit_list *parents;
Junio C Hamanof8f9c732006-01-07 18:52:42 -0800634
Johannes Schindelin60fcc2e2007-10-10 23:14:35 +0100635 if (!(mark & commit->object.flags))
636 return;
Junio C Hamano58ecf5c2006-07-04 17:45:22 -0700637
Johannes Schindelin60fcc2e2007-10-10 23:14:35 +0100638 commit->object.flags &= ~mark;
639
640 parents = commit->parents;
641 if (!parents)
642 return;
643
644 while ((parents = parents->next))
Nguyễn Thái Ngọc Duy941ba8d2012-01-14 19:19:53 +0700645 commit_list_insert(parents->item, plist);
Johannes Schindelin60fcc2e2007-10-10 23:14:35 +0100646
647 commit = commit->parents->item;
Junio C Hamanof8f9c732006-01-07 18:52:42 -0800648 }
649}
650
Junio C Hamanoe895cb52013-03-05 11:42:20 -0800651void clear_commit_marks_many(int nr, struct commit **commit, unsigned int mark)
Nguyễn Thái Ngọc Duy941ba8d2012-01-14 19:19:53 +0700652{
653 struct commit_list *list = NULL;
Junio C Hamanoe895cb52013-03-05 11:42:20 -0800654
655 while (nr--) {
René Scharfe07f7d552017-12-25 18:43:37 +0100656 clear_commit_marks_1(&list, *commit, mark);
Junio C Hamanoe895cb52013-03-05 11:42:20 -0800657 commit++;
658 }
Nguyễn Thái Ngọc Duy941ba8d2012-01-14 19:19:53 +0700659 while (list)
660 clear_commit_marks_1(&list, pop_commit(&list), mark);
661}
662
Junio C Hamanoe895cb52013-03-05 11:42:20 -0800663void clear_commit_marks(struct commit *commit, unsigned int mark)
664{
665 clear_commit_marks_many(1, &commit, mark);
666}
667
jon@blackcubes.dyndns.orga3437b82005-06-06 15:39:40 +0000668struct commit *pop_commit(struct commit_list **stack)
669{
670 struct commit_list *top = *stack;
671 struct commit *item = top ? top->item : NULL;
672
673 if (top) {
674 *stack = top->next;
675 free(top);
676 }
677 return item;
678}
679
Jon Seymourab580ac2005-07-07 02:39:34 +1000680/*
Junio C Hamanoa84b7942013-04-13 11:56:41 -0700681 * Topological sort support
682 */
Junio C Hamano66eb3752013-04-12 23:25:49 -0700683
Junio C Hamanoa84b7942013-04-13 11:56:41 -0700684/* count number of children that have not been emitted */
685define_commit_slab(indegree_slab, int);
Jeff King96c4f4a2013-04-09 02:52:56 -0400686
Derrick Stolee18207032018-08-21 20:54:12 +0000687define_commit_slab(author_date_slab, timestamp_t);
Junio C Hamano81c6b382013-06-07 10:35:54 -0700688
Derrick Stolee5284fc52018-11-01 13:46:21 +0000689void record_author_date(struct author_date_slab *author_date,
690 struct commit *commit)
Junio C Hamano81c6b382013-06-07 10:35:54 -0700691{
Jeff King8597ea32014-06-10 17:44:13 -0400692 const char *buffer = get_commit_buffer(commit, NULL);
Junio C Hamano81c6b382013-06-07 10:35:54 -0700693 struct ident_split ident;
Jeff Kingea5517f2014-08-27 03:56:55 -0400694 const char *ident_line;
695 size_t ident_len;
Junio C Hamano81c6b382013-06-07 10:35:54 -0700696 char *date_end;
Johannes Schindelindddbad72017-04-26 21:29:31 +0200697 timestamp_t date;
Junio C Hamano81c6b382013-06-07 10:35:54 -0700698
Jeff Kingea5517f2014-08-27 03:56:55 -0400699 ident_line = find_commit_header(buffer, "author", &ident_len);
700 if (!ident_line)
701 goto fail_exit; /* no author line */
702 if (split_ident_line(&ident, ident_line, ident_len) ||
703 !ident.date_begin || !ident.date_end)
704 goto fail_exit; /* malformed "author" line */
Junio C Hamano81c6b382013-06-07 10:35:54 -0700705
Johannes Schindelin1aeb7e72017-04-21 12:45:44 +0200706 date = parse_timestamp(ident.date_begin, &date_end, 10);
Junio C Hamano81c6b382013-06-07 10:35:54 -0700707 if (date_end != ident.date_end)
708 goto fail_exit; /* malformed date */
709 *(author_date_slab_at(author_date, commit)) = date;
710
711fail_exit:
Jeff Kingba41c1c2014-06-10 17:41:02 -0400712 unuse_commit_buffer(commit, buffer);
Junio C Hamano81c6b382013-06-07 10:35:54 -0700713}
714
Derrick Stolee5284fc52018-11-01 13:46:21 +0000715int compare_commits_by_author_date(const void *a_, const void *b_,
716 void *cb_data)
Junio C Hamano81c6b382013-06-07 10:35:54 -0700717{
718 const struct commit *a = a_, *b = b_;
719 struct author_date_slab *author_date = cb_data;
Johannes Schindelindddbad72017-04-26 21:29:31 +0200720 timestamp_t a_date = *(author_date_slab_at(author_date, a));
721 timestamp_t b_date = *(author_date_slab_at(author_date, b));
Junio C Hamano81c6b382013-06-07 10:35:54 -0700722
723 /* newer commits with larger date first */
724 if (a_date < b_date)
725 return 1;
726 else if (a_date > b_date)
727 return -1;
728 return 0;
729}
730
Derrick Stolee3afc6792018-05-01 12:47:11 +0000731int compare_commits_by_gen_then_commit_date(const void *a_, const void *b_, void *unused)
732{
733 const struct commit *a = a_, *b = b_;
Abhishek Kumarc752ad02020-06-17 14:44:11 +0530734 const uint32_t generation_a = commit_graph_generation(a),
735 generation_b = commit_graph_generation(b);
Derrick Stolee3afc6792018-05-01 12:47:11 +0000736
737 /* newer commits first */
Abhishek Kumarc752ad02020-06-17 14:44:11 +0530738 if (generation_a < generation_b)
Derrick Stolee3afc6792018-05-01 12:47:11 +0000739 return 1;
Abhishek Kumarc752ad02020-06-17 14:44:11 +0530740 else if (generation_a > generation_b)
Derrick Stolee3afc6792018-05-01 12:47:11 +0000741 return -1;
742
743 /* use date as a heuristic when generations are equal */
744 if (a->date < b->date)
745 return 1;
746 else if (a->date > b->date)
747 return -1;
748 return 0;
749}
750
Jeff King727377f2013-07-02 02:21:48 -0400751int compare_commits_by_commit_date(const void *a_, const void *b_, void *unused)
Junio C Hamanoda24b102013-06-06 21:58:12 -0700752{
753 const struct commit *a = a_, *b = b_;
754 /* newer commits with larger date first */
755 if (a->date < b->date)
756 return 1;
757 else if (a->date > b->date)
758 return -1;
759 return 0;
760}
761
Jon Seymourab580ac2005-07-07 02:39:34 +1000762/*
763 * Performs an in-place topological sort on the list supplied.
764 */
Junio C Hamanoda24b102013-06-06 21:58:12 -0700765void sort_in_topological_order(struct commit_list **list, enum rev_sort_order sort_order)
Jon Seymourab580ac2005-07-07 02:39:34 +1000766{
Linus Torvalds23c17d42007-11-02 13:32:58 -0700767 struct commit_list *next, *orig = *list;
Linus Torvalds23c17d42007-11-02 13:32:58 -0700768 struct commit_list **pptr;
Junio C Hamanoa84b7942013-04-13 11:56:41 -0700769 struct indegree_slab indegree;
Junio C Hamanoda24b102013-06-06 21:58:12 -0700770 struct prio_queue queue;
771 struct commit *commit;
Junio C Hamano81c6b382013-06-07 10:35:54 -0700772 struct author_date_slab author_date;
Fredrik Kuivinen6b6dcfc2006-03-10 10:21:37 +0100773
Linus Torvalds23c17d42007-11-02 13:32:58 -0700774 if (!orig)
Eric Wong7d6fb372005-12-24 04:12:43 -0800775 return;
Linus Torvalds23c17d42007-11-02 13:32:58 -0700776 *list = NULL;
777
Junio C Hamanoa84b7942013-04-13 11:56:41 -0700778 init_indegree_slab(&indegree);
Junio C Hamanoda24b102013-06-06 21:58:12 -0700779 memset(&queue, '\0', sizeof(queue));
Junio C Hamano81c6b382013-06-07 10:35:54 -0700780
Junio C Hamanoda24b102013-06-06 21:58:12 -0700781 switch (sort_order) {
782 default: /* REV_SORT_IN_GRAPH_ORDER */
783 queue.compare = NULL;
784 break;
785 case REV_SORT_BY_COMMIT_DATE:
786 queue.compare = compare_commits_by_commit_date;
787 break;
Junio C Hamano81c6b382013-06-07 10:35:54 -0700788 case REV_SORT_BY_AUTHOR_DATE:
789 init_author_date_slab(&author_date);
790 queue.compare = compare_commits_by_author_date;
791 queue.cb_data = &author_date;
792 break;
Junio C Hamanoda24b102013-06-06 21:58:12 -0700793 }
Jeff King96c4f4a2013-04-09 02:52:56 -0400794
Linus Torvalds23c17d42007-11-02 13:32:58 -0700795 /* Mark them and clear the indegree */
796 for (next = orig; next; next = next->next) {
797 struct commit *commit = next->item;
Junio C Hamanoa84b7942013-04-13 11:56:41 -0700798 *(indegree_slab_at(&indegree, commit)) = 1;
Junio C Hamano81c6b382013-06-07 10:35:54 -0700799 /* also record the author dates, if needed */
800 if (sort_order == REV_SORT_BY_AUTHOR_DATE)
801 record_author_date(&author_date, commit);
Jon Seymourab580ac2005-07-07 02:39:34 +1000802 }
Linus Torvalds23c17d42007-11-02 13:32:58 -0700803
Jon Seymourab580ac2005-07-07 02:39:34 +1000804 /* update the indegree */
Linus Torvalds23c17d42007-11-02 13:32:58 -0700805 for (next = orig; next; next = next->next) {
Junio C Hamanoda24b102013-06-06 21:58:12 -0700806 struct commit_list *parents = next->item->parents;
Jon Seymourab580ac2005-07-07 02:39:34 +1000807 while (parents) {
Linus Torvalds23c17d42007-11-02 13:32:58 -0700808 struct commit *parent = parents->item;
Junio C Hamanoa84b7942013-04-13 11:56:41 -0700809 int *pi = indegree_slab_at(&indegree, parent);
Fredrik Kuivinen6b6dcfc2006-03-10 10:21:37 +0100810
Jeff King96c4f4a2013-04-09 02:52:56 -0400811 if (*pi)
812 (*pi)++;
Linus Torvalds23c17d42007-11-02 13:32:58 -0700813 parents = parents->next;
Jon Seymourab580ac2005-07-07 02:39:34 +1000814 }
Jon Seymourab580ac2005-07-07 02:39:34 +1000815 }
Linus Torvalds23c17d42007-11-02 13:32:58 -0700816
Junio C Hamanoa6080a02007-06-07 00:04:01 -0700817 /*
Pierre Habouzit674d1722007-09-10 12:35:06 +0200818 * find the tips
819 *
820 * tips are nodes not reachable from any other node in the list
821 *
822 * the tips serve as a starting set for the work queue.
823 */
Linus Torvalds23c17d42007-11-02 13:32:58 -0700824 for (next = orig; next; next = next->next) {
825 struct commit *commit = next->item;
Jon Seymourab580ac2005-07-07 02:39:34 +1000826
Junio C Hamanoa84b7942013-04-13 11:56:41 -0700827 if (*(indegree_slab_at(&indegree, commit)) == 1)
Junio C Hamanoda24b102013-06-06 21:58:12 -0700828 prio_queue_put(&queue, commit);
Jon Seymourab580ac2005-07-07 02:39:34 +1000829 }
Junio C Hamano4c8725f2006-02-15 22:05:33 -0800830
Junio C Hamanoda24b102013-06-06 21:58:12 -0700831 /*
832 * This is unfortunate; the initial tips need to be shown
833 * in the order given from the revision traversal machinery.
834 */
835 if (sort_order == REV_SORT_IN_GRAPH_ORDER)
836 prio_queue_reverse(&queue);
837
838 /* We no longer need the commit list */
839 free_commit_list(orig);
Linus Torvalds23c17d42007-11-02 13:32:58 -0700840
841 pptr = list;
842 *list = NULL;
Junio C Hamanoda24b102013-06-06 21:58:12 -0700843 while ((commit = prio_queue_get(&queue)) != NULL) {
844 struct commit_list *parents;
Jon Seymourab580ac2005-07-07 02:39:34 +1000845
Linus Torvalds23c17d42007-11-02 13:32:58 -0700846 for (parents = commit->parents; parents ; parents = parents->next) {
Junio C Hamanocd2b8ae2011-08-25 14:46:52 -0700847 struct commit *parent = parents->item;
Junio C Hamanoa84b7942013-04-13 11:56:41 -0700848 int *pi = indegree_slab_at(&indegree, parent);
Linus Torvalds23c17d42007-11-02 13:32:58 -0700849
Jeff King96c4f4a2013-04-09 02:52:56 -0400850 if (!*pi)
Linus Torvalds23c17d42007-11-02 13:32:58 -0700851 continue;
852
853 /*
854 * parents are only enqueued for emission
855 * when all their children have been emitted thereby
856 * guaranteeing topological order.
857 */
Junio C Hamanoda24b102013-06-06 21:58:12 -0700858 if (--(*pi) == 1)
859 prio_queue_put(&queue, parent);
Jon Seymourab580ac2005-07-07 02:39:34 +1000860 }
861 /*
Junio C Hamanoda24b102013-06-06 21:58:12 -0700862 * all children of commit have already been
863 * emitted. we can emit it now.
Pierre Habouzit674d1722007-09-10 12:35:06 +0200864 */
Junio C Hamanoa84b7942013-04-13 11:56:41 -0700865 *(indegree_slab_at(&indegree, commit)) = 0;
Junio C Hamanoda24b102013-06-06 21:58:12 -0700866
867 pptr = &commit_list_insert(commit, pptr)->next;
Jon Seymourab580ac2005-07-07 02:39:34 +1000868 }
Jeff King96c4f4a2013-04-09 02:52:56 -0400869
Junio C Hamanoa84b7942013-04-13 11:56:41 -0700870 clear_indegree_slab(&indegree);
Junio C Hamanoda24b102013-06-06 21:58:12 -0700871 clear_prio_queue(&queue);
Junio C Hamano81c6b382013-06-07 10:35:54 -0700872 if (sort_order == REV_SORT_BY_AUTHOR_DATE)
873 clear_author_date_slab(&author_date);
Jon Seymourab580ac2005-07-07 02:39:34 +1000874}
Johannes Schindelin7c6f8aa2006-06-29 15:17:32 +0200875
Pratik Karki103148a2018-09-04 15:00:08 -0700876struct rev_collect {
877 struct commit **commit;
878 int nr;
879 int alloc;
880 unsigned int initial : 1;
881};
882
883static void add_one_commit(struct object_id *oid, struct rev_collect *revs)
884{
885 struct commit *commit;
886
887 if (is_null_oid(oid))
888 return;
889
890 commit = lookup_commit(the_repository, oid);
891 if (!commit ||
892 (commit->object.flags & TMP_MARK) ||
893 parse_commit(commit))
894 return;
895
896 ALLOC_GROW(revs->commit, revs->nr + 1, revs->alloc);
897 revs->commit[revs->nr++] = commit;
898 commit->object.flags |= TMP_MARK;
899}
900
901static int collect_one_reflog_ent(struct object_id *ooid, struct object_id *noid,
902 const char *ident, timestamp_t timestamp,
903 int tz, const char *message, void *cbdata)
904{
905 struct rev_collect *revs = cbdata;
906
907 if (revs->initial) {
908 revs->initial = 0;
909 add_one_commit(ooid, revs);
910 }
911 add_one_commit(noid, revs);
912 return 0;
913}
914
915struct commit *get_fork_point(const char *refname, struct commit *commit)
916{
917 struct object_id oid;
918 struct rev_collect revs;
919 struct commit_list *bases;
920 int i;
921 struct commit *ret = NULL;
Junio C Hamanof08132f2019-12-09 10:51:47 -0800922 char *full_refname;
923
Jonathan Tanf24c30e2020-09-01 15:28:09 -0700924 switch (dwim_ref(refname, strlen(refname), &oid, &full_refname, 0)) {
Junio C Hamanof08132f2019-12-09 10:51:47 -0800925 case 0:
926 die("No such ref: '%s'", refname);
927 case 1:
928 break; /* good */
929 default:
930 die("Ambiguous refname: '%s'", refname);
931 }
Pratik Karki103148a2018-09-04 15:00:08 -0700932
933 memset(&revs, 0, sizeof(revs));
934 revs.initial = 1;
Junio C Hamanof08132f2019-12-09 10:51:47 -0800935 for_each_reflog_ent(full_refname, collect_one_reflog_ent, &revs);
Pratik Karki103148a2018-09-04 15:00:08 -0700936
Junio C Hamanof08132f2019-12-09 10:51:47 -0800937 if (!revs.nr)
Pratik Karki103148a2018-09-04 15:00:08 -0700938 add_one_commit(&oid, &revs);
939
940 for (i = 0; i < revs.nr; i++)
941 revs.commit[i]->object.flags &= ~TMP_MARK;
942
943 bases = get_merge_bases_many(commit, revs.nr, revs.commit);
944
945 /*
946 * There should be one and only one merge base, when we found
947 * a common ancestor among reflog entries.
948 */
949 if (!bases || bases->next)
950 goto cleanup_return;
951
952 /* And the found one must be one of the reflog entries */
953 for (i = 0; i < revs.nr; i++)
954 if (&bases->item->object == &revs.commit[i]->object)
955 break; /* found */
956 if (revs.nr <= i)
957 goto cleanup_return;
958
959 ret = bases->item;
960
961cleanup_return:
962 free_commit_list(bases);
Junio C Hamanof08132f2019-12-09 10:51:47 -0800963 free(full_refname);
Pratik Karki103148a2018-09-04 15:00:08 -0700964 return ret;
965}
966
brian m. carlson42d4e1d2020-02-22 20:17:42 +0000967/*
968 * Indexed by hash algorithm identifier.
969 */
970static const char *gpg_sig_headers[] = {
971 NULL,
972 "gpgsig",
973 "gpgsig-sha256",
974};
Junio C Hamanoba3c69a2011-10-05 17:23:20 -0700975
976static int do_sign_commit(struct strbuf *buf, const char *keyid)
977{
978 struct strbuf sig = STRBUF_INIT;
979 int inspos, copypos;
Johannes Schindelin3324dd82016-06-29 16:14:54 +0200980 const char *eoh;
brian m. carlson42d4e1d2020-02-22 20:17:42 +0000981 const char *gpg_sig_header = gpg_sig_headers[hash_algo_by_ptr(the_hash_algo)];
982 int gpg_sig_header_len = strlen(gpg_sig_header);
Junio C Hamanoba3c69a2011-10-05 17:23:20 -0700983
984 /* find the end of the header */
Johannes Schindelin3324dd82016-06-29 16:14:54 +0200985 eoh = strstr(buf->buf, "\n\n");
986 if (!eoh)
987 inspos = buf->len;
988 else
989 inspos = eoh - buf->buf + 1;
Junio C Hamanoba3c69a2011-10-05 17:23:20 -0700990
991 if (!keyid || !*keyid)
992 keyid = get_signing_key();
993 if (sign_buffer(buf, &sig, keyid)) {
994 strbuf_release(&sig);
995 return -1;
996 }
997
998 for (copypos = 0; sig.buf[copypos]; ) {
999 const char *bol = sig.buf + copypos;
1000 const char *eol = strchrnul(bol, '\n');
1001 int len = (eol - bol) + !!*eol;
1002
1003 if (!copypos) {
1004 strbuf_insert(buf, inspos, gpg_sig_header, gpg_sig_header_len);
1005 inspos += gpg_sig_header_len;
1006 }
René Scharfea91cc7f2020-02-09 14:44:23 +01001007 strbuf_insertstr(buf, inspos++, " ");
Junio C Hamanoba3c69a2011-10-05 17:23:20 -07001008 strbuf_insert(buf, inspos, bol, len);
1009 inspos += len;
1010 copypos += len;
1011 }
1012 strbuf_release(&sig);
1013 return 0;
1014}
1015
Jeff King218aa3a2014-06-13 02:32:11 -04001016int parse_signed_commit(const struct commit *commit,
Junio C Hamano0c37f1f2011-10-18 15:53:23 -07001017 struct strbuf *payload, struct strbuf *signature)
1018{
Junio C Hamano0c37f1f2011-10-18 15:53:23 -07001019
Jeff King218aa3a2014-06-13 02:32:11 -04001020 unsigned long size;
1021 const char *buffer = get_commit_buffer(commit, &size);
1022 int in_signature, saw_signature = -1;
1023 const char *line, *tail;
brian m. carlson42d4e1d2020-02-22 20:17:42 +00001024 const char *gpg_sig_header = gpg_sig_headers[hash_algo_by_ptr(the_hash_algo)];
1025 int gpg_sig_header_len = strlen(gpg_sig_header);
Junio C Hamano0c37f1f2011-10-18 15:53:23 -07001026
1027 line = buffer;
1028 tail = buffer + size;
1029 in_signature = 0;
1030 saw_signature = 0;
1031 while (line < tail) {
1032 const char *sig = NULL;
Jeff King218aa3a2014-06-13 02:32:11 -04001033 const char *next = memchr(line, '\n', tail - line);
Junio C Hamano0c37f1f2011-10-18 15:53:23 -07001034
1035 next = next ? next + 1 : tail;
1036 if (in_signature && line[0] == ' ')
1037 sig = line + 1;
Christian Couder59556542013-11-30 21:55:40 +01001038 else if (starts_with(line, gpg_sig_header) &&
Junio C Hamano0c37f1f2011-10-18 15:53:23 -07001039 line[gpg_sig_header_len] == ' ')
1040 sig = line + gpg_sig_header_len + 1;
1041 if (sig) {
1042 strbuf_add(signature, sig, next - sig);
1043 saw_signature = 1;
1044 in_signature = 1;
1045 } else {
1046 if (*line == '\n')
1047 /* dump the whole remainder of the buffer */
1048 next = tail;
1049 strbuf_add(payload, line, next - line);
1050 in_signature = 0;
1051 }
1052 line = next;
1053 }
Jeff King218aa3a2014-06-13 02:32:11 -04001054 unuse_commit_buffer(commit, buffer);
Junio C Hamano0c37f1f2011-10-18 15:53:23 -07001055 return saw_signature;
1056}
1057
Christian Couder0b05ab62014-07-19 17:01:12 +02001058int remove_signature(struct strbuf *buf)
1059{
1060 const char *line = buf->buf;
1061 const char *tail = buf->buf + buf->len;
1062 int in_signature = 0;
1063 const char *sig_start = NULL;
1064 const char *sig_end = NULL;
1065
1066 while (line < tail) {
1067 const char *next = memchr(line, '\n', tail - line);
1068 next = next ? next + 1 : tail;
1069
1070 if (in_signature && line[0] == ' ')
1071 sig_end = next;
brian m. carlson42d4e1d2020-02-22 20:17:42 +00001072 else if (starts_with(line, "gpgsig")) {
1073 int i;
1074 for (i = 1; i < GIT_HASH_NALGOS; i++) {
1075 const char *p;
1076 if (skip_prefix(line, gpg_sig_headers[i], &p) &&
1077 *p == ' ') {
1078 sig_start = line;
1079 sig_end = next;
1080 in_signature = 1;
1081 }
1082 }
Christian Couder0b05ab62014-07-19 17:01:12 +02001083 } else {
1084 if (*line == '\n')
1085 /* dump the whole remainder of the buffer */
1086 next = tail;
1087 in_signature = 0;
1088 }
1089 line = next;
1090 }
1091
1092 if (sig_start)
1093 strbuf_remove(buf, sig_start - buf->buf, sig_end - sig_start);
1094
1095 return sig_start != NULL;
1096}
1097
Junio C Hamano5231c632011-11-07 16:21:32 -08001098static void handle_signed_tag(struct commit *parent, struct commit_extra_header ***tail)
1099{
1100 struct merge_remote_desc *desc;
1101 struct commit_extra_header *mergetag;
1102 char *buf;
1103 unsigned long size, len;
1104 enum object_type type;
1105
1106 desc = merge_remote_util(parent);
1107 if (!desc || !desc->obj)
1108 return;
brian m. carlsonb4f5aca2018-03-12 02:27:53 +00001109 buf = read_object_file(&desc->obj->oid, &type, &size);
Junio C Hamano5231c632011-11-07 16:21:32 -08001110 if (!buf || type != OBJ_TAG)
1111 goto free_return;
1112 len = parse_signature(buf, size);
1113 if (size == len)
1114 goto free_return;
1115 /*
1116 * We could verify this signature and either omit the tag when
1117 * it does not validate, but the integrator may not have the
1118 * public key of the signer of the tag he is merging, while a
1119 * later auditor may have it while auditing, so let's not run
1120 * verify-signed-buffer here for now...
1121 *
1122 * if (verify_signed_buffer(buf, len, buf + len, size - len, ...))
1123 * warn("warning: signed tag unverified.");
1124 */
1125 mergetag = xcalloc(1, sizeof(*mergetag));
1126 mergetag->key = xstrdup("mergetag");
1127 mergetag->value = buf;
1128 mergetag->len = size;
1129
1130 **tail = mergetag;
1131 *tail = &mergetag->next;
1132 return;
1133
1134free_return:
1135 free(buf);
1136}
1137
brian m. carlson434060e2015-06-21 23:14:40 +00001138int check_commit_signature(const struct commit *commit, struct signature_check *sigc)
Sebastian Götteffb6d7d2013-03-31 18:00:14 +02001139{
1140 struct strbuf payload = STRBUF_INIT;
1141 struct strbuf signature = STRBUF_INIT;
brian m. carlson434060e2015-06-21 23:14:40 +00001142 int ret = 1;
Sebastian Götteffb6d7d2013-03-31 18:00:14 +02001143
1144 sigc->result = 'N';
1145
Jeff King218aa3a2014-06-13 02:32:11 -04001146 if (parse_signed_commit(commit, &payload, &signature) <= 0)
Sebastian Götteffb6d7d2013-03-31 18:00:14 +02001147 goto out;
brian m. carlson434060e2015-06-21 23:14:40 +00001148 ret = check_signature(payload.buf, payload.len, signature.buf,
1149 signature.len, sigc);
Sebastian Götteffb6d7d2013-03-31 18:00:14 +02001150
1151 out:
Sebastian Götteffb6d7d2013-03-31 18:00:14 +02001152 strbuf_release(&payload);
1153 strbuf_release(&signature);
brian m. carlson434060e2015-06-21 23:14:40 +00001154
1155 return ret;
Sebastian Götteffb6d7d2013-03-31 18:00:14 +02001156}
1157
Hans Jerry Illikainen54887b42019-12-27 13:55:57 +00001158void verify_merge_signature(struct commit *commit, int verbosity,
1159 int check_trust)
Jeff Kingedc4d472018-11-06 02:50:17 -05001160{
1161 char hex[GIT_MAX_HEXSZ + 1];
1162 struct signature_check signature_check;
Hans Jerry Illikainen54887b42019-12-27 13:55:57 +00001163 int ret;
Jeff Kingedc4d472018-11-06 02:50:17 -05001164 memset(&signature_check, 0, sizeof(signature_check));
Sebastian Götteffb6d7d2013-03-31 18:00:14 +02001165
Hans Jerry Illikainen54887b42019-12-27 13:55:57 +00001166 ret = check_commit_signature(commit, &signature_check);
Jeff Kingedc4d472018-11-06 02:50:17 -05001167
1168 find_unique_abbrev_r(hex, &commit->object.oid, DEFAULT_ABBREV);
1169 switch (signature_check.result) {
1170 case 'G':
Hans Jerry Illikainen54887b42019-12-27 13:55:57 +00001171 if (ret || (check_trust && signature_check.trust_level < TRUST_MARGINAL))
1172 die(_("Commit %s has an untrusted GPG signature, "
1173 "allegedly by %s."), hex, signature_check.signer);
Jeff Kingedc4d472018-11-06 02:50:17 -05001174 break;
Jeff Kingedc4d472018-11-06 02:50:17 -05001175 case 'B':
1176 die(_("Commit %s has a bad GPG signature "
1177 "allegedly by %s."), hex, signature_check.signer);
1178 default: /* 'N' */
1179 die(_("Commit %s does not have a GPG signature."), hex);
1180 }
1181 if (verbosity >= 0 && signature_check.result == 'G')
1182 printf(_("Commit %s has a good GPG signature by %s\n"),
1183 hex, signature_check.signer);
1184
1185 signature_check_clear(&signature_check);
1186}
Sebastian Götteffb6d7d2013-03-31 18:00:14 +02001187
Junio C Hamano5231c632011-11-07 16:21:32 -08001188void append_merge_tag_headers(struct commit_list *parents,
1189 struct commit_extra_header ***tail)
1190{
1191 while (parents) {
1192 struct commit *parent = parents->item;
1193 handle_signed_tag(parent, tail);
1194 parents = parents->next;
1195 }
1196}
1197
1198static void add_extra_header(struct strbuf *buffer,
1199 struct commit_extra_header *extra)
1200{
1201 strbuf_addstr(buffer, extra->key);
Junio C Hamanoed7a42a2011-11-08 15:38:07 -08001202 if (extra->len)
1203 strbuf_add_lines(buffer, " ", extra->value, extra->len);
1204 else
1205 strbuf_addch(buffer, '\n');
1206}
1207
Junio C Hamanoc871a1d2012-01-05 10:54:14 -08001208struct commit_extra_header *read_commit_extra_headers(struct commit *commit,
1209 const char **exclude)
Junio C Hamanoed7a42a2011-11-08 15:38:07 -08001210{
1211 struct commit_extra_header *extra = NULL;
1212 unsigned long size;
Jeff King218aa3a2014-06-13 02:32:11 -04001213 const char *buffer = get_commit_buffer(commit, &size);
1214 extra = read_commit_extra_header_lines(buffer, size, exclude);
1215 unuse_commit_buffer(commit, buffer);
Junio C Hamanoed7a42a2011-11-08 15:38:07 -08001216 return extra;
1217}
1218
Johannes Schindelinfef461e2018-04-25 11:54:04 +02001219int for_each_mergetag(each_mergetag_fn fn, struct commit *commit, void *data)
Christian Couder063da622014-07-07 08:35:37 +02001220{
1221 struct commit_extra_header *extra, *to_free;
Johannes Schindelinfef461e2018-04-25 11:54:04 +02001222 int res = 0;
Christian Couder063da622014-07-07 08:35:37 +02001223
1224 to_free = read_commit_extra_headers(commit, NULL);
Johannes Schindelinfef461e2018-04-25 11:54:04 +02001225 for (extra = to_free; !res && extra; extra = extra->next) {
Christian Couder063da622014-07-07 08:35:37 +02001226 if (strcmp(extra->key, "mergetag"))
1227 continue; /* not a merge tag */
Johannes Schindelinfef461e2018-04-25 11:54:04 +02001228 res = fn(commit, extra, data);
Christian Couder063da622014-07-07 08:35:37 +02001229 }
1230 free_commit_extra_headers(to_free);
Johannes Schindelinfef461e2018-04-25 11:54:04 +02001231 return res;
Christian Couder063da622014-07-07 08:35:37 +02001232}
1233
Junio C Hamanoed7a42a2011-11-08 15:38:07 -08001234static inline int standard_header_field(const char *field, size_t len)
1235{
René Scharfeb0725042017-02-25 20:27:40 +01001236 return ((len == 4 && !memcmp(field, "tree", 4)) ||
1237 (len == 6 && !memcmp(field, "parent", 6)) ||
1238 (len == 6 && !memcmp(field, "author", 6)) ||
1239 (len == 9 && !memcmp(field, "committer", 9)) ||
1240 (len == 8 && !memcmp(field, "encoding", 8)));
Junio C Hamanoed7a42a2011-11-08 15:38:07 -08001241}
1242
Junio C Hamanoc871a1d2012-01-05 10:54:14 -08001243static int excluded_header_field(const char *field, size_t len, const char **exclude)
1244{
1245 if (!exclude)
1246 return 0;
1247
1248 while (*exclude) {
1249 size_t xlen = strlen(*exclude);
René Scharfeb0725042017-02-25 20:27:40 +01001250 if (len == xlen && !memcmp(field, *exclude, xlen))
Junio C Hamanoc871a1d2012-01-05 10:54:14 -08001251 return 1;
1252 exclude++;
1253 }
1254 return 0;
1255}
1256
Junio C Hamano82a75292012-09-15 13:58:15 -07001257static struct commit_extra_header *read_commit_extra_header_lines(
1258 const char *buffer, size_t size,
1259 const char **exclude)
Junio C Hamanoed7a42a2011-11-08 15:38:07 -08001260{
1261 struct commit_extra_header *extra = NULL, **tail = &extra, *it = NULL;
1262 const char *line, *next, *eof, *eob;
1263 struct strbuf buf = STRBUF_INIT;
1264
1265 for (line = buffer, eob = line + size;
1266 line < eob && *line != '\n';
1267 line = next) {
1268 next = memchr(line, '\n', eob - line);
1269 next = next ? next + 1 : eob;
1270 if (*line == ' ') {
1271 /* continuation */
1272 if (it)
1273 strbuf_add(&buf, line + 1, next - (line + 1));
1274 continue;
1275 }
1276 if (it)
1277 it->value = strbuf_detach(&buf, &it->len);
1278 strbuf_reset(&buf);
1279 it = NULL;
1280
René Scharfe50a01cc2017-02-25 20:21:52 +01001281 eof = memchr(line, ' ', next - line);
1282 if (!eof)
Junio C Hamanoed7a42a2011-11-08 15:38:07 -08001283 eof = next;
René Scharfeb0725042017-02-25 20:27:40 +01001284 else if (standard_header_field(line, eof - line) ||
1285 excluded_header_field(line, eof - line, exclude))
Junio C Hamanoed7a42a2011-11-08 15:38:07 -08001286 continue;
1287
1288 it = xcalloc(1, sizeof(*it));
1289 it->key = xmemdupz(line, eof-line);
1290 *tail = it;
1291 tail = &it->next;
1292 if (eof + 1 < next)
1293 strbuf_add(&buf, eof + 1, next - (eof + 1));
1294 }
1295 if (it)
1296 it->value = strbuf_detach(&buf, &it->len);
1297 return extra;
Junio C Hamano5231c632011-11-07 16:21:32 -08001298}
1299
1300void free_commit_extra_headers(struct commit_extra_header *extra)
1301{
1302 while (extra) {
1303 struct commit_extra_header *next = extra->next;
1304 free(extra->key);
1305 free(extra->value);
1306 free(extra);
1307 extra = next;
1308 }
1309}
1310
Patryk Obara5078f342018-01-28 01:13:16 +01001311int commit_tree(const char *msg, size_t msg_len, const struct object_id *tree,
1312 struct commit_list *parents, struct object_id *ret,
Junio C Hamanoba3c69a2011-10-05 17:23:20 -07001313 const char *author, const char *sign_commit)
Junio C Hamano5231c632011-11-07 16:21:32 -08001314{
1315 struct commit_extra_header *extra = NULL, **tail = &extra;
1316 int result;
1317
1318 append_merge_tag_headers(parents, &tail);
Phillip Woode8cbe212020-08-17 18:40:01 +01001319 result = commit_tree_extended(msg, msg_len, tree, parents, ret, author,
1320 NULL, sign_commit, extra);
Junio C Hamano5231c632011-11-07 16:21:32 -08001321 free_commit_extra_headers(extra);
1322 return result;
1323}
1324
Linus Torvalds08a94a12012-06-28 11:24:14 -07001325static int find_invalid_utf8(const char *buf, int len)
1326{
1327 int offset = 0;
brian m. carlsone82bd6c2013-07-04 17:20:34 +00001328 static const unsigned int max_codepoint[] = {
1329 0x7f, 0x7ff, 0xffff, 0x10ffff
1330 };
Linus Torvalds08a94a12012-06-28 11:24:14 -07001331
1332 while (len) {
1333 unsigned char c = *buf++;
1334 int bytes, bad_offset;
brian m. carlson28110d42013-07-04 17:19:43 +00001335 unsigned int codepoint;
brian m. carlsone82bd6c2013-07-04 17:20:34 +00001336 unsigned int min_val, max_val;
Linus Torvalds08a94a12012-06-28 11:24:14 -07001337
1338 len--;
1339 offset++;
1340
1341 /* Simple US-ASCII? No worries. */
1342 if (c < 0x80)
1343 continue;
1344
1345 bad_offset = offset-1;
1346
1347 /*
1348 * Count how many more high bits set: that's how
1349 * many more bytes this sequence should have.
1350 */
1351 bytes = 0;
1352 while (c & 0x40) {
1353 c <<= 1;
1354 bytes++;
1355 }
1356
brian m. carlson28110d42013-07-04 17:19:43 +00001357 /*
1358 * Must be between 1 and 3 more bytes. Longer sequences result in
1359 * codepoints beyond U+10FFFF, which are guaranteed never to exist.
1360 */
1361 if (bytes < 1 || 3 < bytes)
Linus Torvalds08a94a12012-06-28 11:24:14 -07001362 return bad_offset;
1363
1364 /* Do we *have* that many bytes? */
1365 if (len < bytes)
1366 return bad_offset;
1367
brian m. carlsone82bd6c2013-07-04 17:20:34 +00001368 /*
1369 * Place the encoded bits at the bottom of the value and compute the
1370 * valid range.
1371 */
brian m. carlson28110d42013-07-04 17:19:43 +00001372 codepoint = (c & 0x7f) >> bytes;
brian m. carlsone82bd6c2013-07-04 17:20:34 +00001373 min_val = max_codepoint[bytes-1] + 1;
1374 max_val = max_codepoint[bytes];
brian m. carlson28110d42013-07-04 17:19:43 +00001375
Linus Torvalds08a94a12012-06-28 11:24:14 -07001376 offset += bytes;
1377 len -= bytes;
1378
1379 /* And verify that they are good continuation bytes */
1380 do {
brian m. carlson28110d42013-07-04 17:19:43 +00001381 codepoint <<= 6;
1382 codepoint |= *buf & 0x3f;
Linus Torvalds08a94a12012-06-28 11:24:14 -07001383 if ((*buf++ & 0xc0) != 0x80)
1384 return bad_offset;
1385 } while (--bytes);
1386
brian m. carlsone82bd6c2013-07-04 17:20:34 +00001387 /* Reject codepoints that are out of range for the sequence length. */
1388 if (codepoint < min_val || codepoint > max_val)
brian m. carlson28110d42013-07-04 17:19:43 +00001389 return bad_offset;
1390 /* Surrogates are only for UTF-16 and cannot be encoded in UTF-8. */
1391 if ((codepoint & 0x1ff800) == 0xd800)
1392 return bad_offset;
Peter Krefting81050ac2013-07-09 12:16:33 +01001393 /* U+xxFFFE and U+xxFFFF are guaranteed non-characters. */
Junio C Hamanodc773a62013-08-05 09:52:28 -07001394 if ((codepoint & 0xfffe) == 0xfffe)
Peter Krefting81050ac2013-07-09 12:16:33 +01001395 return bad_offset;
1396 /* So are anything in the range U+FDD0..U+FDEF. */
1397 if (codepoint >= 0xfdd0 && codepoint <= 0xfdef)
brian m. carlson28110d42013-07-04 17:19:43 +00001398 return bad_offset;
Linus Torvalds08a94a12012-06-28 11:24:14 -07001399 }
1400 return -1;
1401}
1402
1403/*
1404 * This verifies that the buffer is in proper utf8 format.
1405 *
1406 * If it isn't, it assumes any non-utf8 characters are Latin1,
1407 * and does the conversion.
Linus Torvalds08a94a12012-06-28 11:24:14 -07001408 */
1409static int verify_utf8(struct strbuf *buf)
1410{
1411 int ok = 1;
1412 long pos = 0;
1413
1414 for (;;) {
1415 int bad;
1416 unsigned char c;
1417 unsigned char replace[2];
1418
1419 bad = find_invalid_utf8(buf->buf + pos, buf->len - pos);
1420 if (bad < 0)
1421 return ok;
1422 pos += bad;
1423 ok = 0;
1424 c = buf->buf[pos];
1425 strbuf_remove(buf, pos, 1);
1426
1427 /* We know 'c' must be in the range 128-255 */
1428 replace[0] = 0xc0 + (c >> 6);
1429 replace[1] = 0x80 + (c & 0x3f);
1430 strbuf_insert(buf, pos, replace, 2);
1431 pos += 2;
1432 }
1433}
1434
Jeff King40d52ff2010-04-01 20:05:23 -04001435static const char commit_utf8_warn[] =
Vasco Almeida4fa4b312016-09-19 13:08:16 +00001436N_("Warning: commit message did not conform to UTF-8.\n"
1437 "You may want to amend it after fixing the message, or set the config\n"
1438 "variable i18n.commitencoding to the encoding your project uses.\n");
Jeff King40d52ff2010-04-01 20:05:23 -04001439
Jeff King3ffefb52014-06-10 17:36:52 -04001440int commit_tree_extended(const char *msg, size_t msg_len,
Patryk Obara5078f342018-01-28 01:13:16 +01001441 const struct object_id *tree,
1442 struct commit_list *parents, struct object_id *ret,
Phillip Woode8cbe212020-08-17 18:40:01 +01001443 const char *author, const char *committer,
1444 const char *sign_commit,
Junio C Hamanoba3c69a2011-10-05 17:23:20 -07001445 struct commit_extra_header *extra)
Jeff King40d52ff2010-04-01 20:05:23 -04001446{
1447 int result;
1448 int encoding_is_utf8;
1449 struct strbuf buffer;
1450
brian m. carlsone816caa2018-03-12 02:27:42 +00001451 assert_oid_type(tree, OBJ_TREE);
Jeff King40d52ff2010-04-01 20:05:23 -04001452
Jeff King3ffefb52014-06-10 17:36:52 -04001453 if (memchr(msg, '\0', msg_len))
Nguyễn Thái Ngọc Duy37576c12011-12-15 20:47:23 +07001454 return error("a NUL byte in commit log message not allowed.");
1455
Jeff King40d52ff2010-04-01 20:05:23 -04001456 /* Not having i18n.commitencoding is the same as having utf-8 */
1457 encoding_is_utf8 = is_encoding_utf8(git_commit_encoding);
1458
1459 strbuf_init(&buffer, 8192); /* should avoid reallocs for the headers */
Patryk Obara5078f342018-01-28 01:13:16 +01001460 strbuf_addf(&buffer, "tree %s\n", oid_to_hex(tree));
Jeff King40d52ff2010-04-01 20:05:23 -04001461
1462 /*
1463 * NOTE! This ordering means that the same exact tree merged with a
1464 * different order of parents will be a _different_ changeset even
1465 * if everything else stays the same.
1466 */
1467 while (parents) {
René Scharfee510ab82015-10-24 18:21:31 +02001468 struct commit *parent = pop_commit(&parents);
Jeff King40d52ff2010-04-01 20:05:23 -04001469 strbuf_addf(&buffer, "parent %s\n",
brian m. carlsonf2fd0762015-11-10 02:22:28 +00001470 oid_to_hex(&parent->object.oid));
Jeff King40d52ff2010-04-01 20:05:23 -04001471 }
1472
1473 /* Person/date information */
1474 if (!author)
Jeff Kingf9bc5732012-05-24 19:28:40 -04001475 author = git_author_info(IDENT_STRICT);
Jeff King40d52ff2010-04-01 20:05:23 -04001476 strbuf_addf(&buffer, "author %s\n", author);
Phillip Woode8cbe212020-08-17 18:40:01 +01001477 if (!committer)
1478 committer = git_committer_info(IDENT_STRICT);
1479 strbuf_addf(&buffer, "committer %s\n", committer);
Jeff King40d52ff2010-04-01 20:05:23 -04001480 if (!encoding_is_utf8)
1481 strbuf_addf(&buffer, "encoding %s\n", git_commit_encoding);
Junio C Hamano5231c632011-11-07 16:21:32 -08001482
1483 while (extra) {
1484 add_extra_header(&buffer, extra);
1485 extra = extra->next;
1486 }
Jeff King40d52ff2010-04-01 20:05:23 -04001487 strbuf_addch(&buffer, '\n');
1488
1489 /* And add the comment */
Jeff King3ffefb52014-06-10 17:36:52 -04001490 strbuf_add(&buffer, msg, msg_len);
Jeff King40d52ff2010-04-01 20:05:23 -04001491
1492 /* And check the encoding */
Linus Torvalds08a94a12012-06-28 11:24:14 -07001493 if (encoding_is_utf8 && !verify_utf8(&buffer))
Vasco Almeida4fa4b312016-09-19 13:08:16 +00001494 fprintf(stderr, _(commit_utf8_warn));
Jeff King40d52ff2010-04-01 20:05:23 -04001495
Rene Scharfee5051462017-08-30 19:49:38 +02001496 if (sign_commit && do_sign_commit(&buffer, sign_commit)) {
1497 result = -1;
1498 goto out;
1499 }
Junio C Hamanoba3c69a2011-10-05 17:23:20 -07001500
Patryk Obaraa09c9852018-01-28 01:13:19 +01001501 result = write_object_file(buffer.buf, buffer.len, commit_type, ret);
Rene Scharfee5051462017-08-30 19:49:38 +02001502out:
Jeff King40d52ff2010-04-01 20:05:23 -04001503 strbuf_release(&buffer);
1504 return result;
1505}
Junio C Hamanoae8e4c92011-11-07 13:26:22 -08001506
Nguyễn Thái Ngọc Duye2e5ac22018-05-19 07:28:30 +02001507define_commit_slab(merge_desc_slab, struct merge_remote_desc *);
1508static struct merge_desc_slab merge_desc_slab = COMMIT_SLAB_INIT(1, merge_desc_slab);
1509
1510struct merge_remote_desc *merge_remote_util(struct commit *commit)
1511{
1512 return *merge_desc_slab_at(&merge_desc_slab, commit);
1513}
1514
René Scharfebeb518c2016-08-13 14:11:27 +02001515void set_merge_remote_desc(struct commit *commit,
1516 const char *name, struct object *obj)
1517{
1518 struct merge_remote_desc *desc;
René Scharfe5447a762016-08-13 14:21:27 +02001519 FLEX_ALLOC_STR(desc, name, name);
René Scharfebeb518c2016-08-13 14:11:27 +02001520 desc->obj = obj;
Nguyễn Thái Ngọc Duye2e5ac22018-05-19 07:28:30 +02001521 *merge_desc_slab_at(&merge_desc_slab, commit) = desc;
René Scharfebeb518c2016-08-13 14:11:27 +02001522}
1523
Junio C Hamanoae8e4c92011-11-07 13:26:22 -08001524struct commit *get_merge_parent(const char *name)
1525{
1526 struct object *obj;
1527 struct commit *commit;
brian m. carlson7683e2e2015-03-13 23:39:34 +00001528 struct object_id oid;
brian m. carlsone82caf32017-07-13 23:49:28 +00001529 if (get_oid(name, &oid))
Junio C Hamanoae8e4c92011-11-07 13:26:22 -08001530 return NULL;
Stefan Beller109cd762018-06-28 18:21:51 -07001531 obj = parse_object(the_repository, &oid);
Junio C Hamanoae8e4c92011-11-07 13:26:22 -08001532 commit = (struct commit *)peel_to_type(name, 0, obj, OBJ_COMMIT);
Nguyễn Thái Ngọc Duye2e5ac22018-05-19 07:28:30 +02001533 if (commit && !merge_remote_util(commit))
René Scharfebeb518c2016-08-13 14:11:27 +02001534 set_merge_remote_desc(commit, name, obj);
Junio C Hamanoae8e4c92011-11-07 13:26:22 -08001535 return commit;
1536}
René Scharfe89b5f1d2012-04-25 22:35:27 +02001537
1538/*
1539 * Append a commit to the end of the commit_list.
1540 *
1541 * next starts by pointing to the variable that holds the head of an
1542 * empty commit_list, and is updated to point to the "next" field of
1543 * the last item on the list as new commits are appended.
1544 *
1545 * Usage example:
1546 *
1547 * struct commit_list *list;
1548 * struct commit_list **next = &list;
1549 *
1550 * next = commit_list_append(c1, next);
1551 * next = commit_list_append(c2, next);
1552 * assert(commit_list_count(list) == 2);
1553 * return list;
1554 */
1555struct commit_list **commit_list_append(struct commit *commit,
1556 struct commit_list **next)
1557{
Brandon Williams258c03e2018-02-14 10:59:37 -08001558 struct commit_list *new_commit = xmalloc(sizeof(struct commit_list));
1559 new_commit->item = commit;
1560 *next = new_commit;
1561 new_commit->next = NULL;
1562 return &new_commit->next;
René Scharfe89b5f1d2012-04-25 22:35:27 +02001563}
Nguyễn Thái Ngọc Duyefc7df42012-10-26 22:53:51 +07001564
Jeff Kingfe6eb7f2014-08-27 03:56:01 -04001565const char *find_commit_header(const char *msg, const char *key, size_t *out_len)
1566{
1567 int key_len = strlen(key);
1568 const char *line = msg;
1569
1570 while (line) {
1571 const char *eol = strchrnul(line, '\n');
1572
1573 if (line == eol)
1574 return NULL;
1575
1576 if (eol - line > key_len &&
1577 !strncmp(line, key, key_len) &&
1578 line[key_len] == ' ') {
1579 *out_len = eol - line - key_len - 1;
1580 return line + key_len + 1;
1581 }
1582 line = *eol ? eol + 1 : NULL;
1583 }
1584 return NULL;
1585}
Junio C Hamano0ed8a4e2014-12-22 12:26:23 -08001586
Christian Couder8c384582014-11-09 10:23:41 +01001587/*
Jonathan Tan710714a2016-11-02 10:29:17 -07001588 * Inspect the given string and determine the true "end" of the log message, in
Christian Couder8c384582014-11-09 10:23:41 +01001589 * order to find where to put a new Signed-off-by: line. Ignored are
Brian Malehornd76650b2017-05-15 23:06:49 -07001590 * trailing comment lines and blank lines. To support "git commit -s
1591 * --amend" on an existing commit, we also ignore "Conflicts:". To
1592 * support "git commit -v", we truncate at cut lines.
Christian Couder8c384582014-11-09 10:23:41 +01001593 *
1594 * Returns the number of bytes from the tail to ignore, to be fed as
1595 * the second parameter to append_signoff().
1596 */
Jeff King66e83d92018-08-22 20:50:51 -04001597size_t ignore_non_trailer(const char *buf, size_t len)
Christian Couder8c384582014-11-09 10:23:41 +01001598{
Jeff King66e83d92018-08-22 20:50:51 -04001599 size_t boc = 0;
1600 size_t bol = 0;
Christian Couder8c384582014-11-09 10:23:41 +01001601 int in_old_conflicts_block = 0;
Brian Malehornd76650b2017-05-15 23:06:49 -07001602 size_t cutoff = wt_status_locate_end(buf, len);
Christian Couder8c384582014-11-09 10:23:41 +01001603
Brian Malehornd76650b2017-05-15 23:06:49 -07001604 while (bol < cutoff) {
Jonathan Tan710714a2016-11-02 10:29:17 -07001605 const char *next_line = memchr(buf + bol, '\n', len - bol);
Christian Couder8c384582014-11-09 10:23:41 +01001606
Jonathan Tan710714a2016-11-02 10:29:17 -07001607 if (!next_line)
1608 next_line = buf + len;
Christian Couder8c384582014-11-09 10:23:41 +01001609 else
1610 next_line++;
1611
Jonathan Tan710714a2016-11-02 10:29:17 -07001612 if (buf[bol] == comment_line_char || buf[bol] == '\n') {
Christian Couder8c384582014-11-09 10:23:41 +01001613 /* is this the first of the run of comments? */
1614 if (!boc)
1615 boc = bol;
1616 /* otherwise, it is just continuing */
Jonathan Tan710714a2016-11-02 10:29:17 -07001617 } else if (starts_with(buf + bol, "Conflicts:\n")) {
Christian Couder8c384582014-11-09 10:23:41 +01001618 in_old_conflicts_block = 1;
1619 if (!boc)
1620 boc = bol;
Jonathan Tan710714a2016-11-02 10:29:17 -07001621 } else if (in_old_conflicts_block && buf[bol] == '\t') {
Christian Couder8c384582014-11-09 10:23:41 +01001622 ; /* a pathname in the conflicts block */
1623 } else if (boc) {
1624 /* the previous was not trailing comment */
1625 boc = 0;
1626 in_old_conflicts_block = 0;
1627 }
Jonathan Tan710714a2016-11-02 10:29:17 -07001628 bol = next_line - buf;
Christian Couder8c384582014-11-09 10:23:41 +01001629 }
Brian Malehornd76650b2017-05-15 23:06:49 -07001630 return boc ? len - boc : len - cutoff;
Christian Couder8c384582014-11-09 10:23:41 +01001631}
Phillip Wood49697cb2019-10-15 10:25:31 +00001632
1633int run_commit_hook(int editor_is_used, const char *index_file,
1634 const char *name, ...)
1635{
Jeff Kingef8d7ac2020-07-28 16:24:53 -04001636 struct strvec hook_env = STRVEC_INIT;
Phillip Wood49697cb2019-10-15 10:25:31 +00001637 va_list args;
1638 int ret;
1639
Jeff Kingef8d7ac2020-07-28 16:24:53 -04001640 strvec_pushf(&hook_env, "GIT_INDEX_FILE=%s", index_file);
Phillip Wood49697cb2019-10-15 10:25:31 +00001641
1642 /*
1643 * Let the hook know that no editor will be launched.
1644 */
1645 if (!editor_is_used)
Jeff Kingef8d7ac2020-07-28 16:24:53 -04001646 strvec_push(&hook_env, "GIT_EDITOR=:");
Phillip Wood49697cb2019-10-15 10:25:31 +00001647
1648 va_start(args, name);
Jeff Kingd70a9eb2020-07-28 20:37:20 -04001649 ret = run_hook_ve(hook_env.v, name, args);
Phillip Wood49697cb2019-10-15 10:25:31 +00001650 va_end(args);
Jeff Kingef8d7ac2020-07-28 16:24:53 -04001651 strvec_clear(&hook_env);
Phillip Wood49697cb2019-10-15 10:25:31 +00001652
1653 return ret;
1654}