| 1 | #ifndef COMMIT_H |
| 2 | #define COMMIT_H |
| 3 | |
| 4 | #include "object.h" |
| 5 | #include "add-interactive.h" |
| 6 | |
| 7 | struct signature_check; |
| 8 | struct strbuf; |
| 9 | struct tree; |
| 10 | |
| 11 | #define COMMIT_NOT_FROM_GRAPH 0xFFFFFFFF |
| 12 | #define GENERATION_NUMBER_INFINITY ((1ULL << 63) - 1) |
| 13 | #define GENERATION_NUMBER_V1_MAX 0x3FFFFFFF |
| 14 | #define GENERATION_NUMBER_ZERO 0 |
| 15 | #define GENERATION_NUMBER_V2_OFFSET_MAX ((1ULL << 31) - 1) |
| 16 | |
| 17 | struct commit_list { |
| 18 | struct commit *item; |
| 19 | struct commit_list *next; |
| 20 | }; |
| 21 | |
| 22 | /* |
| 23 | * The size of this struct matters in full repo walk operations like |
| 24 | * 'git clone' or 'git gc'. Consider using commit-slab to attach data |
| 25 | * to a commit instead of adding new fields here. |
| 26 | */ |
| 27 | struct commit { |
| 28 | struct object object; |
| 29 | timestamp_t date; |
| 30 | struct commit_list *parents; |
| 31 | |
| 32 | /* |
| 33 | * If the commit is loaded from the commit-graph file, then this |
| 34 | * member may be NULL. Only access it through repo_get_commit_tree() |
| 35 | * or get_commit_tree_oid(). |
| 36 | */ |
| 37 | struct tree *maybe_tree; |
| 38 | unsigned int index; |
| 39 | }; |
| 40 | |
| 41 | extern int save_commit_buffer; |
| 42 | extern int no_graft_file_deprecated_advice; |
| 43 | extern const char *commit_type; |
| 44 | |
| 45 | /* While we can decorate any object with a name, it's only used for commits.. */ |
| 46 | struct name_decoration { |
| 47 | struct name_decoration *next; |
| 48 | int type; |
| 49 | char name[FLEX_ARRAY]; |
| 50 | }; |
| 51 | |
| 52 | enum decoration_type { |
| 53 | DECORATION_NONE = 0, |
| 54 | DECORATION_REF_LOCAL, |
| 55 | DECORATION_REF_REMOTE, |
| 56 | DECORATION_REF_TAG, |
| 57 | DECORATION_REF_STASH, |
| 58 | DECORATION_REF_HEAD, |
| 59 | DECORATION_GRAFTED, |
| 60 | }; |
| 61 | |
| 62 | void add_name_decoration(enum decoration_type type, const char *name, struct object *obj); |
| 63 | const struct name_decoration *get_name_decoration(const struct object *obj); |
| 64 | |
| 65 | /* |
| 66 | * Look up commit named by "oid" respecting replacement objects. |
| 67 | * Returns NULL if "oid" is not a commit or does not exist. |
| 68 | */ |
| 69 | struct commit *lookup_commit_object(struct repository *r, const struct object_id *oid); |
| 70 | |
| 71 | /* |
| 72 | * Look up commit named by "oid" without replacement objects or |
| 73 | * checking for object existence. Returns the requested commit if it |
| 74 | * is found in the object cache, NULL if "oid" is in the object cache |
| 75 | * but is not a commit and a newly allocated unparsed commit object if |
| 76 | * "oid" is not in the object cache. |
| 77 | */ |
| 78 | struct commit *lookup_commit(struct repository *r, const struct object_id *oid); |
| 79 | struct commit *lookup_commit_reference(struct repository *r, |
| 80 | const struct object_id *oid); |
| 81 | struct commit *lookup_commit_reference_gently(struct repository *r, |
| 82 | const struct object_id *oid, |
| 83 | int quiet); |
| 84 | struct commit *lookup_commit_reference_by_name(const char *name); |
| 85 | struct commit *lookup_commit_reference_by_name_gently(const char *name, |
| 86 | int quiet); |
| 87 | |
| 88 | /* |
| 89 | * Look up object named by "oid", dereference tag as necessary, |
| 90 | * get a commit and return it. If "oid" does not dereference to |
| 91 | * a commit, use ref_name to report an error and die. |
| 92 | */ |
| 93 | struct commit *lookup_commit_or_die(const struct object_id *oid, const char *ref_name); |
| 94 | |
| 95 | int parse_commit_buffer(struct repository *r, struct commit *item, const void *buffer, unsigned long size, int check_graph); |
| 96 | int repo_parse_commit_internal(struct repository *r, struct commit *item, |
| 97 | int quiet_on_missing, int use_commit_graph); |
| 98 | int repo_parse_commit_gently(struct repository *r, |
| 99 | struct commit *item, |
| 100 | int quiet_on_missing); |
| 101 | static inline int repo_parse_commit(struct repository *r, struct commit *item) |
| 102 | { |
| 103 | return repo_parse_commit_gently(r, item, 0); |
| 104 | } |
| 105 | |
| 106 | void unparse_commit(struct repository *r, const struct object_id *oid); |
| 107 | |
| 108 | static inline int repo_parse_commit_no_graph(struct repository *r, |
| 109 | struct commit *commit) |
| 110 | { |
| 111 | /* |
| 112 | * When the commit has been parsed but its tree wasn't populated then |
| 113 | * this is an indicator that it has been parsed via the commit-graph. |
| 114 | * We cannot read the tree via the commit-graph, as we're explicitly |
| 115 | * told not to use it. We thus have to first un-parse the object so |
| 116 | * that we can re-parse it without the graph. |
| 117 | */ |
| 118 | if (commit->object.parsed && !commit->maybe_tree) |
| 119 | unparse_commit(r, &commit->object.oid); |
| 120 | |
| 121 | return repo_parse_commit_internal(r, commit, 0, 0); |
| 122 | } |
| 123 | |
| 124 | void parse_commit_or_die(struct commit *item); |
| 125 | |
| 126 | struct buffer_slab; |
| 127 | struct buffer_slab *allocate_commit_buffer_slab(void); |
| 128 | void free_commit_buffer_slab(struct buffer_slab *bs); |
| 129 | |
| 130 | /* |
| 131 | * Associate an object buffer with the commit. The ownership of the |
| 132 | * memory is handed over to the commit, and must be free()-able. |
| 133 | */ |
| 134 | void set_commit_buffer(struct repository *r, struct commit *, void *buffer, unsigned long size); |
| 135 | |
| 136 | /* |
| 137 | * Get any cached object buffer associated with the commit. Returns NULL |
| 138 | * if none. The resulting memory should not be freed. |
| 139 | */ |
| 140 | const void *get_cached_commit_buffer(struct repository *, const struct commit *, unsigned long *size); |
| 141 | |
| 142 | /* |
| 143 | * Get the commit's object contents, either from cache or by reading the object |
| 144 | * from disk. The resulting memory should not be modified, and must be given |
| 145 | * to repo_unuse_commit_buffer when the caller is done. |
| 146 | */ |
| 147 | const void *repo_get_commit_buffer(struct repository *r, |
| 148 | const struct commit *, |
| 149 | unsigned long *size); |
| 150 | |
| 151 | /* |
| 152 | * Tell the commit subsystem that we are done with a particular commit buffer. |
| 153 | * The commit and buffer should be the input and return value, respectively, |
| 154 | * from an earlier call to repo_get_commit_buffer. The buffer may or may not be |
| 155 | * freed by this call; callers should not access the memory afterwards. |
| 156 | */ |
| 157 | void repo_unuse_commit_buffer(struct repository *r, |
| 158 | const struct commit *, |
| 159 | const void *buffer); |
| 160 | |
| 161 | /* |
| 162 | * Free any cached object buffer associated with the commit. |
| 163 | */ |
| 164 | void free_commit_buffer(struct parsed_object_pool *pool, struct commit *); |
| 165 | |
| 166 | struct tree *repo_get_commit_tree(struct repository *, const struct commit *); |
| 167 | struct object_id *get_commit_tree_oid(const struct commit *); |
| 168 | |
| 169 | /* |
| 170 | * Release memory related to a commit, including the parent list and |
| 171 | * any cached object buffer. |
| 172 | */ |
| 173 | void release_commit_memory(struct parsed_object_pool *pool, struct commit *c); |
| 174 | |
| 175 | /* |
| 176 | * Disassociate any cached object buffer from the commit, but do not free it. |
| 177 | * The buffer (or NULL, if none) is returned. |
| 178 | */ |
| 179 | const void *detach_commit_buffer(struct commit *, unsigned long *sizep); |
| 180 | |
| 181 | /* Find beginning and length of commit subject. */ |
| 182 | int find_commit_subject(const char *commit_buffer, const char **subject); |
| 183 | |
| 184 | /* Return length of the commit subject from commit log message. */ |
| 185 | size_t commit_subject_length(const char *body); |
| 186 | |
| 187 | struct commit_list *commit_list_insert(struct commit *item, |
| 188 | struct commit_list **list); |
| 189 | int commit_list_contains(struct commit *item, |
| 190 | struct commit_list *list); |
| 191 | struct commit_list **commit_list_append(struct commit *commit, |
| 192 | struct commit_list **next); |
| 193 | unsigned commit_list_count(const struct commit_list *l); |
| 194 | void commit_list_sort_by_date(struct commit_list **list); |
| 195 | |
| 196 | /* Shallow copy of the input list */ |
| 197 | struct commit_list *commit_list_copy(const struct commit_list *list); |
| 198 | |
| 199 | /* Modify list in-place to reverse it, returning new head; list will be tail */ |
| 200 | struct commit_list *commit_list_reverse(struct commit_list *list); |
| 201 | |
| 202 | void commit_list_free(struct commit_list *list); |
| 203 | |
| 204 | struct rev_info; /* in revision.h, it circularly uses enum cmit_fmt */ |
| 205 | |
| 206 | const char *repo_logmsg_reencode(struct repository *r, |
| 207 | const struct commit *commit, |
| 208 | char **commit_encoding, |
| 209 | const char *output_encoding); |
| 210 | |
| 211 | const char *skip_blank_lines(const char *msg); |
| 212 | |
| 213 | struct prio_queue; |
| 214 | |
| 215 | /* Removes the first commit from a prio_queue and adds its parents. */ |
| 216 | struct commit *pop_most_recent_commit(struct prio_queue *queue, |
| 217 | unsigned int mark); |
| 218 | |
| 219 | struct commit *pop_commit(struct commit_list **stack); |
| 220 | |
| 221 | void clear_commit_marks(struct commit *commit, unsigned int mark); |
| 222 | void clear_commit_marks_many(size_t nr, struct commit **commit, unsigned int mark); |
| 223 | |
| 224 | |
| 225 | enum rev_sort_order { |
| 226 | REV_SORT_IN_GRAPH_ORDER = 0, |
| 227 | REV_SORT_BY_COMMIT_DATE, |
| 228 | REV_SORT_BY_AUTHOR_DATE |
| 229 | }; |
| 230 | |
| 231 | /* |
| 232 | * Performs an in-place topological sort of list supplied. |
| 233 | * |
| 234 | * invariant of resulting list is: |
| 235 | * a reachable from b => ord(b) < ord(a) |
| 236 | * sort_order further specifies: |
| 237 | * REV_SORT_IN_GRAPH_ORDER: try to show a commit on a single-parent |
| 238 | * chain together. |
| 239 | * REV_SORT_BY_COMMIT_DATE: show eligible commits in committer-date order. |
| 240 | */ |
| 241 | void sort_in_topological_order(struct commit_list **, enum rev_sort_order); |
| 242 | |
| 243 | struct commit_graft { |
| 244 | struct object_id oid; |
| 245 | int nr_parent; /* < 0 if shallow commit */ |
| 246 | struct object_id parent[FLEX_ARRAY]; /* more */ |
| 247 | }; |
| 248 | typedef int (*each_commit_graft_fn)(const struct commit_graft *, void *); |
| 249 | |
| 250 | struct commit_graft *read_graft_line(struct strbuf *line); |
| 251 | /* commit_graft_pos returns an index into r->parsed_objects->grafts. */ |
| 252 | int commit_graft_pos(struct repository *r, const struct object_id *oid); |
| 253 | int register_commit_graft(struct repository *r, struct commit_graft *, int); |
| 254 | void prepare_commit_graft(struct repository *r); |
| 255 | struct commit_graft *lookup_commit_graft(struct repository *r, const struct object_id *oid); |
| 256 | |
| 257 | struct commit *get_fork_point(const char *refname, struct commit *commit); |
| 258 | |
| 259 | /* largest positive number a signed 32-bit integer can contain */ |
| 260 | #define INFINITE_DEPTH 0x7fffffff |
| 261 | |
| 262 | struct oid_array; |
| 263 | struct ref; |
| 264 | int for_each_commit_graft(each_commit_graft_fn, void *); |
| 265 | |
| 266 | int interactive_add(struct repository *repo, |
| 267 | const char **argv, |
| 268 | const char *prefix, |
| 269 | int patch, struct interactive_options *opts); |
| 270 | |
| 271 | struct commit_extra_header { |
| 272 | struct commit_extra_header *next; |
| 273 | char *key; |
| 274 | char *value; |
| 275 | size_t len; |
| 276 | }; |
| 277 | |
| 278 | void append_merge_tag_headers(const struct commit_list *parents, |
| 279 | struct commit_extra_header ***tail); |
| 280 | |
| 281 | int commit_tree(const char *msg, size_t msg_len, |
| 282 | const struct object_id *tree, |
| 283 | const struct commit_list *parents, struct object_id *ret, |
| 284 | const char *author, const char *sign_commit); |
| 285 | |
| 286 | int commit_tree_extended(const char *msg, size_t msg_len, |
| 287 | const struct object_id *tree, |
| 288 | const struct commit_list *parents, struct object_id *ret, |
| 289 | const char *author, const char *committer, |
| 290 | const char *sign_commit, const struct commit_extra_header *); |
| 291 | |
| 292 | struct commit_extra_header *read_commit_extra_headers(struct commit *, const char **); |
| 293 | |
| 294 | void free_commit_extra_headers(struct commit_extra_header *extra); |
| 295 | |
| 296 | /* |
| 297 | * Search the commit object contents given by "msg" for the header "key". |
| 298 | * Returns a pointer to the start of the header contents, or NULL. The length |
| 299 | * of the header, up to the first newline, is returned via out_len. |
| 300 | * |
| 301 | * Note that some headers (like mergetag) may be multi-line. It is the caller's |
| 302 | * responsibility to parse further in this case! |
| 303 | */ |
| 304 | const char *find_commit_header(const char *msg, const char *key, |
| 305 | size_t *out_len); |
| 306 | |
| 307 | /* Find the number of bytes to ignore from the end of a log message. */ |
| 308 | size_t ignored_log_message_bytes(const char *buf, size_t len); |
| 309 | |
| 310 | typedef int (*each_mergetag_fn)(struct commit *commit, struct commit_extra_header *extra, |
| 311 | void *cb_data); |
| 312 | |
| 313 | int for_each_mergetag(each_mergetag_fn fn, struct commit *commit, void *data); |
| 314 | |
| 315 | struct merge_remote_desc { |
| 316 | struct object *obj; /* the named object, could be a tag */ |
| 317 | char name[FLEX_ARRAY]; |
| 318 | }; |
| 319 | struct merge_remote_desc *merge_remote_util(const struct commit *); |
| 320 | void set_merge_remote_desc(struct commit *commit, |
| 321 | const char *name, struct object *obj); |
| 322 | |
| 323 | /* |
| 324 | * Given "name" from the command line to merge, find the commit object |
| 325 | * and return it, while storing merge_remote_desc in its ->util field, |
| 326 | * to allow callers to tell if we are told to merge a tag. |
| 327 | */ |
| 328 | struct commit *get_merge_parent(const char *name); |
| 329 | |
| 330 | int parse_signed_commit(const struct commit *commit, |
| 331 | struct strbuf *message, struct strbuf *signature, |
| 332 | const struct git_hash_algo *algop); |
| 333 | int remove_signature(struct strbuf *buf); |
| 334 | |
| 335 | /* |
| 336 | * Check the signature of the given commit. The result of the check is stored |
| 337 | * in sig->check_result, 'G' for a good signature, 'U' for a good signature |
| 338 | * from an untrusted signer, 'B' for a bad signature and 'N' for no signature |
| 339 | * at all. This may allocate memory for sig->gpg_output, sig->gpg_status, |
| 340 | * sig->signer and sig->key. |
| 341 | */ |
| 342 | int check_commit_signature(const struct commit *commit, struct signature_check *sigc); |
| 343 | |
| 344 | /* |
| 345 | * Same as check_commit_signature() but accepts a commit buffer and |
| 346 | * its size, instead of a `struct commit *`. |
| 347 | */ |
| 348 | int verify_commit_buffer(const char *buffer, size_t size, |
| 349 | struct signature_check *sigc); |
| 350 | |
| 351 | /* record author-date for each commit object */ |
| 352 | struct author_date_slab; |
| 353 | void record_author_date(struct author_date_slab *author_date, |
| 354 | struct commit *commit); |
| 355 | |
| 356 | int compare_commits_by_author_date(const void *a_, const void *b_, void *unused); |
| 357 | |
| 358 | /* |
| 359 | * Verify a single commit with check_commit_signature() and die() if it is not |
| 360 | * a good signature. This isn't really suitable for general use, but is a |
| 361 | * helper to implement consistent logic for pull/merge --verify-signatures. |
| 362 | * |
| 363 | * The check_trust parameter is meant for backward-compatibility. The GPG |
| 364 | * interface verifies key trust with a default trust level that is below the |
| 365 | * default trust level for merge operations. Its value should be non-zero if |
| 366 | * the user hasn't set a minimum trust level explicitly in their configuration. |
| 367 | * |
| 368 | * If the user has set a minimum trust level, then that value should be obeyed |
| 369 | * and check_trust should be zero, even if the configured trust level is below |
| 370 | * the default trust level for merges. |
| 371 | */ |
| 372 | void verify_merge_signature(struct commit *commit, int verbose, |
| 373 | int check_trust); |
| 374 | |
| 375 | int compare_commits_by_commit_date(const void *a_, const void *b_, void *unused); |
| 376 | int compare_commits_by_gen_then_commit_date(const void *a_, const void *b_, void *unused); |
| 377 | |
| 378 | LAST_ARG_MUST_BE_NULL |
| 379 | int run_commit_hook(int editor_is_used, const char *index_file, |
| 380 | int *invoked_hook, const char *name, ...); |
| 381 | |
| 382 | /* Parse the signature out of a header. */ |
| 383 | int parse_buffer_signed_by_header(const char *buffer, |
| 384 | unsigned long size, |
| 385 | struct strbuf *payload, |
| 386 | struct strbuf *signature, |
| 387 | const struct git_hash_algo *algop); |
| 388 | int add_header_signature(struct strbuf *buf, struct strbuf *sig, const struct git_hash_algo *algo); |
| 389 | |
| 390 | struct commit_stack { |
| 391 | struct commit **items; |
| 392 | size_t nr, alloc; |
| 393 | }; |
| 394 | #define COMMIT_STACK_INIT { 0 } |
| 395 | |
| 396 | void commit_stack_init(struct commit_stack *); |
| 397 | void commit_stack_grow(struct commit_stack *, size_t); |
| 398 | void commit_stack_push(struct commit_stack *, struct commit *); |
| 399 | struct commit *commit_stack_pop(struct commit_stack *); |
| 400 | void commit_stack_clear(struct commit_stack *); |
| 401 | |
| 402 | #endif /* COMMIT_H */ |