git.oblomov.eu Git - git/blob - commit.c

   1 #include "cache.h"
   2 #include "tag.h"
   3 #include "commit.h"
   4 #include "repository.h"
   5 #include "object-store.h"
   6 #include "pkt-line.h"
   7 #include "utf8.h"
   8 #include "diff.h"
   9 #include "revision.h"
  10 #include "notes.h"
  11 #include "alloc.h"
  12 #include "gpg-interface.h"
  13 #include "mergesort.h"
  14 #include "commit-slab.h"
  15 #include "prio-queue.h"
  16 #include "sha1-lookup.h"
  17 #include "wt-status.h"
  18
  19 static struct commit_extra_header *read_commit_extra_header_lines(const char *buf, size_t len, const char **);
  20
  21 int save_commit_buffer = 1;
  22
  23 const char *commit_type = "commit";
  24
  25 struct commit *lookup_commit_reference_gently(const struct object_id *oid,
  26                                               int quiet)
  27 {
  28         struct object *obj = deref_tag(parse_object(oid), NULL, 0);
  29
  30         if (!obj)
  31                 return NULL;
  32         return object_as_type(obj, OBJ_COMMIT, quiet);
  33 }
  34
  35 struct commit *lookup_commit_reference(const struct object_id *oid)
  36 {
  37         return lookup_commit_reference_gently(oid, 0);
  38 }
  39
  40 struct commit *lookup_commit_or_die(const struct object_id *oid, const char *ref_name)
  41 {
  42         struct commit *c = lookup_commit_reference(oid);
  43         if (!c)
  44                 die(_("could not parse %s"), ref_name);
  45         if (oidcmp(oid, &c->object.oid)) {
  46                 warning(_("%s %s is not a commit!"),
  47                         ref_name, oid_to_hex(oid));
  48         }
  49         return c;
  50 }
  51
  52 struct commit *lookup_commit(const struct object_id *oid)
  53 {
  54         struct object *obj = lookup_object(oid->hash);
  55         if (!obj)
  56                 return create_object(the_repository, oid->hash,
  57                                      alloc_commit_node(the_repository));
  58         return object_as_type(obj, OBJ_COMMIT, 0);
  59 }
  60
  61 struct commit *lookup_commit_reference_by_name(const char *name)
  62 {
  63         struct object_id oid;
  64         struct commit *commit;
  65
  66         if (get_oid_committish(name, &oid))
  67                 return NULL;
  68         commit = lookup_commit_reference(&oid);
  69         if (parse_commit(commit))
  70                 return NULL;
  71         return commit;
  72 }
  73
  74 static timestamp_t parse_commit_date(const char *buf, const char *tail)
  75 {
  76         const char *dateptr;
  77
  78         if (buf + 6 >= tail)
  79                 return 0;
  80         if (memcmp(buf, "author", 6))
  81                 return 0;
  82         while (buf < tail && *buf++ != '\n')
  83                 /* nada */;
  84         if (buf + 9 >= tail)
  85                 return 0;
  86         if (memcmp(buf, "committer", 9))
  87                 return 0;
  88         while (buf < tail && *buf++ != '>')
  89                 /* nada */;
  90         if (buf >= tail)
  91                 return 0;
  92         dateptr = buf;
  93         while (buf < tail && *buf++ != '\n')
  94                 /* nada */;
  95         if (buf >= tail)
  96                 return 0;
  97         /* dateptr < buf && buf[-1] == '\n', so parsing will stop at buf-1 */
  98         return parse_timestamp(dateptr, NULL, 10);
  99 }
 100
 101 static const unsigned char *commit_graft_sha1_access(size_t index, void *table)
 102 {
 103         struct commit_graft **commit_graft_table = table;
 104         return commit_graft_table[index]->oid.hash;
 105 }
 106
 107 static int commit_graft_pos(const unsigned char *sha1)
 108 {
 109         return sha1_pos(sha1, the_repository->parsed_objects->grafts,
 110                         the_repository->parsed_objects->grafts_nr,
 111                         commit_graft_sha1_access);
 112 }
 113
 114 int register_commit_graft(struct commit_graft *graft, int ignore_dups)
 115 {
 116         int pos = commit_graft_pos(graft->oid.hash);
 117
 118         if (0 <= pos) {
 119                 if (ignore_dups)
 120                         free(graft);
 121                 else {
 122                         free(the_repository->parsed_objects->grafts[pos]);
 123                         the_repository->parsed_objects->grafts[pos] = graft;
 124                 }
 125                 return 1;
 126         }
 127         pos = -pos - 1;
 128         ALLOC_GROW(the_repository->parsed_objects->grafts,
 129                    the_repository->parsed_objects->grafts_nr + 1,
 130                    the_repository->parsed_objects->grafts_alloc);
 131         the_repository->parsed_objects->grafts_nr++;
 132         if (pos < the_repository->parsed_objects->grafts_nr)
 133                 memmove(the_repository->parsed_objects->grafts + pos + 1,
 134                         the_repository->parsed_objects->grafts + pos,
 135                         (the_repository->parsed_objects->grafts_nr - pos - 1) *
 136                         sizeof(*the_repository->parsed_objects->grafts));
 137         the_repository->parsed_objects->grafts[pos] = graft;
 138         return 0;
 139 }
 140
 141 struct commit_graft *read_graft_line(struct strbuf *line)
 142 {
 143         /* The format is just "Commit Parent1 Parent2 ...\n" */
 144         int i, phase;
 145         const char *tail = NULL;
 146         struct commit_graft *graft = NULL;
 147         struct object_id dummy_oid, *oid;
 148
 149         strbuf_rtrim(line);
 150         if (!line->len || line->buf[0] == '#')
 151                 return NULL;
 152         /*
 153          * phase 0 verifies line, counts hashes in line and allocates graft
 154          * phase 1 fills graft
 155          */
 156         for (phase = 0; phase < 2; phase++) {
 157                 oid = graft ? &graft->oid : &dummy_oid;
 158                 if (parse_oid_hex(line->buf, oid, &tail))
 159                         goto bad_graft_data;
 160                 for (i = 0; *tail != '\0'; i++) {
 161                         oid = graft ? &graft->parent[i] : &dummy_oid;
 162                         if (!isspace(*tail++) || parse_oid_hex(tail, oid, &tail))
 163                                 goto bad_graft_data;
 164                 }
 165                 if (!graft) {
 166                         graft = xmalloc(st_add(sizeof(*graft),
 167                                                st_mult(sizeof(struct object_id), i)));
 168                         graft->nr_parent = i;
 169                 }
 170         }
 171         return graft;
 172
 173 bad_graft_data:
 174         error("bad graft data: %s", line->buf);
 175         assert(!graft);
 176         return NULL;
 177 }
 178
 179 static int read_graft_file(const char *graft_file)
 180 {
 181         FILE *fp = fopen_or_warn(graft_file, "r");
 182         struct strbuf buf = STRBUF_INIT;
 183         if (!fp)
 184                 return -1;
 185         while (!strbuf_getwholeline(&buf, fp, '\n')) {
 186                 /* The format is just "Commit Parent1 Parent2 ...\n" */
 187                 struct commit_graft *graft = read_graft_line(&buf);
 188                 if (!graft)
 189                         continue;
 190                 if (register_commit_graft(graft, 1))
 191                         error("duplicate graft data: %s", buf.buf);
 192         }
 193         fclose(fp);
 194         strbuf_release(&buf);
 195         return 0;
 196 }
 197
 198 static void prepare_commit_graft(void)
 199 {
 200         static int commit_graft_prepared;
 201         char *graft_file;
 202
 203         if (commit_graft_prepared)
 204                 return;
 205         graft_file = get_graft_file();
 206         read_graft_file(graft_file);
 207         /* make sure shallows are read */
 208         is_repository_shallow();
 209         commit_graft_prepared = 1;
 210 }
 211
 212 struct commit_graft *lookup_commit_graft(const struct object_id *oid)
 213 {
 214         int pos;
 215         prepare_commit_graft();
 216         pos = commit_graft_pos(oid->hash);
 217         if (pos < 0)
 218                 return NULL;
 219         return the_repository->parsed_objects->grafts[pos];
 220 }
 221
 222 int for_each_commit_graft(each_commit_graft_fn fn, void *cb_data)
 223 {
 224         int i, ret;
 225         for (i = ret = 0; i < the_repository->parsed_objects->grafts_nr && !ret; i++)
 226                 ret = fn(the_repository->parsed_objects->grafts[i], cb_data);
 227         return ret;
 228 }
 229
 230 int unregister_shallow(const struct object_id *oid)
 231 {
 232         int pos = commit_graft_pos(oid->hash);
 233         if (pos < 0)
 234                 return -1;
 235         if (pos + 1 < the_repository->parsed_objects->grafts_nr)
 236                 MOVE_ARRAY(the_repository->parsed_objects->grafts + pos,
 237                            the_repository->parsed_objects->grafts + pos + 1,
 238                            the_repository->parsed_objects->grafts_nr - pos - 1);
 239         the_repository->parsed_objects->grafts_nr--;
 240         return 0;
 241 }
 242
 243 struct commit_buffer {
 244         void *buffer;
 245         unsigned long size;
 246 };
 247 define_commit_slab(buffer_slab, struct commit_buffer);
 248 static struct buffer_slab buffer_slab = COMMIT_SLAB_INIT(1, buffer_slab);
 249
 250 void set_commit_buffer(struct commit *commit, void *buffer, unsigned long size)
 251 {
 252         struct commit_buffer *v = buffer_slab_at(&buffer_slab, commit);
 253         v->buffer = buffer;
 254         v->size = size;
 255 }
 256
 257 const void *get_cached_commit_buffer(const struct commit *commit, unsigned long *sizep)
 258 {
 259         struct commit_buffer *v = buffer_slab_peek(&buffer_slab, commit);
 260         if (!v) {
 261                 if (sizep)
 262                         *sizep = 0;
 263                 return NULL;
 264         }
 265         if (sizep)
 266                 *sizep = v->size;
 267         return v->buffer;
 268 }
 269
 270 const void *get_commit_buffer(const struct commit *commit, unsigned long *sizep)
 271 {
 272         const void *ret = get_cached_commit_buffer(commit, sizep);
 273         if (!ret) {
 274                 enum object_type type;
 275                 unsigned long size;
 276                 ret = read_object_file(&commit->object.oid, &type, &size);
 277                 if (!ret)
 278                         die("cannot read commit object %s",
 279                             oid_to_hex(&commit->object.oid));
 280                 if (type != OBJ_COMMIT)
 281                         die("expected commit for %s, got %s",
 282                             oid_to_hex(&commit->object.oid), type_name(type));
 283                 if (sizep)
 284                         *sizep = size;
 285         }
 286         return ret;
 287 }
 288
 289 void unuse_commit_buffer(const struct commit *commit, const void *buffer)
 290 {
 291         struct commit_buffer *v = buffer_slab_peek(&buffer_slab, commit);
 292         if (!(v && v->buffer == buffer))
 293                 free((void *)buffer);
 294 }
 295
 296 void free_commit_buffer(struct commit *commit)
 297 {
 298         struct commit_buffer *v = buffer_slab_peek(&buffer_slab, commit);
 299         if (v) {
 300                 FREE_AND_NULL(v->buffer);
 301                 v->size = 0;
 302         }
 303 }
 304
 305 void release_commit_memory(struct commit *c)
 306 {
 307         c->tree = NULL;
 308         c->index = 0;
 309         free_commit_buffer(c);
 310         free_commit_list(c->parents);
 311         /* TODO: what about commit->util? */
 312
 313         c->object.parsed = 0;
 314 }
 315
 316 const void *detach_commit_buffer(struct commit *commit, unsigned long *sizep)
 317 {
 318         struct commit_buffer *v = buffer_slab_peek(&buffer_slab, commit);
 319         void *ret;
 320
 321         if (!v) {
 322                 if (sizep)
 323                         *sizep = 0;
 324                 return NULL;
 325         }
 326         ret = v->buffer;
 327         if (sizep)
 328                 *sizep = v->size;
 329
 330         v->buffer = NULL;
 331         v->size = 0;
 332         return ret;
 333 }
 334
 335 int parse_commit_buffer(struct commit *item, const void *buffer, unsigned long size)
 336 {
 337         const char *tail = buffer;
 338         const char *bufptr = buffer;
 339         struct object_id parent;
 340         struct commit_list **pptr;
 341         struct commit_graft *graft;
 342         const int tree_entry_len = GIT_SHA1_HEXSZ + 5;
 343         const int parent_entry_len = GIT_SHA1_HEXSZ + 7;
 344
 345         if (item->object.parsed)
 346                 return 0;
 347         item->object.parsed = 1;
 348         tail += size;
 349         if (tail <= bufptr + tree_entry_len + 1 || memcmp(bufptr, "tree ", 5) ||
 350                         bufptr[tree_entry_len] != '\n')
 351                 return error("bogus commit object %s", oid_to_hex(&item->object.oid));
 352         if (get_sha1_hex(bufptr + 5, parent.hash) < 0)
 353                 return error("bad tree pointer in commit %s",
 354                              oid_to_hex(&item->object.oid));
 355         item->tree = lookup_tree(&parent);
 356         bufptr += tree_entry_len + 1; /* "tree " + "hex sha1" + "\n" */
 357         pptr = &item->parents;
 358
 359         graft = lookup_commit_graft(&item->object.oid);
 360         while (bufptr + parent_entry_len < tail && !memcmp(bufptr, "parent ", 7)) {
 361                 struct commit *new_parent;
 362
 363                 if (tail <= bufptr + parent_entry_len + 1 ||
 364                     get_sha1_hex(bufptr + 7, parent.hash) ||
 365                     bufptr[parent_entry_len] != '\n')
 366                         return error("bad parents in commit %s", oid_to_hex(&item->object.oid));
 367                 bufptr += parent_entry_len + 1;
 368                 /*
 369                  * The clone is shallow if nr_parent < 0, and we must
 370                  * not traverse its real parents even when we unhide them.
 371                  */
 372                 if (graft && (graft->nr_parent < 0 || grafts_replace_parents))
 373                         continue;
 374                 new_parent = lookup_commit(&parent);
 375                 if (new_parent)
 376                         pptr = &commit_list_insert(new_parent, pptr)->next;
 377         }
 378         if (graft) {
 379                 int i;
 380                 struct commit *new_parent;
 381                 for (i = 0; i < graft->nr_parent; i++) {
 382                         new_parent = lookup_commit(&graft->parent[i]);
 383                         if (!new_parent)
 384                                 continue;
 385                         pptr = &commit_list_insert(new_parent, pptr)->next;
 386                 }
 387         }
 388         item->date = parse_commit_date(bufptr, tail);
 389
 390         return 0;
 391 }
 392
 393 int parse_commit_gently(struct commit *item, int quiet_on_missing)
 394 {
 395         enum object_type type;
 396         void *buffer;
 397         unsigned long size;
 398         int ret;
 399
 400         if (!item)
 401                 return -1;
 402         if (item->object.parsed)
 403                 return 0;
 404         buffer = read_object_file(&item->object.oid, &type, &size);
 405         if (!buffer)
 406                 return quiet_on_missing ? -1 :
 407                         error("Could not read %s",
 408                              oid_to_hex(&item->object.oid));
 409         if (type != OBJ_COMMIT) {
 410                 free(buffer);
 411                 return error("Object %s not a commit",
 412                              oid_to_hex(&item->object.oid));
 413         }
 414         ret = parse_commit_buffer(item, buffer, size);
 415         if (save_commit_buffer && !ret) {
 416                 set_commit_buffer(item, buffer, size);
 417                 return 0;
 418         }
 419         free(buffer);
 420         return ret;
 421 }
 422
 423 void parse_commit_or_die(struct commit *item)
 424 {
 425         if (parse_commit(item))
 426                 die("unable to parse commit %s",
 427                     item ? oid_to_hex(&item->object.oid) : "(null)");
 428 }
 429
 430 int find_commit_subject(const char *commit_buffer, const char **subject)
 431 {
 432         const char *eol;
 433         const char *p = commit_buffer;
 434
 435         while (*p && (*p != '\n' || p[1] != '\n'))
 436                 p++;
 437         if (*p) {
 438                 p = skip_blank_lines(p + 2);
 439                 eol = strchrnul(p, '\n');
 440         } else
 441                 eol = p;
 442
 443         *subject = p;
 444
 445         return eol - p;
 446 }
 447
 448 struct commit_list *commit_list_insert(struct commit *item, struct commit_list **list_p)
 449 {
 450         struct commit_list *new_list = xmalloc(sizeof(struct commit_list));
 451         new_list->item = item;
 452         new_list->next = *list_p;
 453         *list_p = new_list;
 454         return new_list;
 455 }
 456
 457 unsigned commit_list_count(const struct commit_list *l)
 458 {
 459         unsigned c = 0;
 460         for (; l; l = l->next )
 461                 c++;
 462         return c;
 463 }
 464
 465 struct commit_list *copy_commit_list(struct commit_list *list)
 466 {
 467         struct commit_list *head = NULL;
 468         struct commit_list **pp = &head;
 469         while (list) {
 470                 pp = commit_list_append(list->item, pp);
 471                 list = list->next;
 472         }
 473         return head;
 474 }
 475
 476 void free_commit_list(struct commit_list *list)
 477 {
 478         while (list)
 479                 pop_commit(&list);
 480 }
 481
 482 struct commit_list * commit_list_insert_by_date(struct commit *item, struct commit_list **list)
 483 {
 484         struct commit_list **pp = list;
 485         struct commit_list *p;
 486         while ((p = *pp) != NULL) {
 487                 if (p->item->date < item->date) {
 488                         break;
 489                 }
 490                 pp = &p->next;
 491         }
 492         return commit_list_insert(item, pp);
 493 }
 494
 495 static int commit_list_compare_by_date(const void *a, const void *b)
 496 {
 497         timestamp_t a_date = ((const struct commit_list *)a)->item->date;
 498         timestamp_t b_date = ((const struct commit_list *)b)->item->date;
 499         if (a_date < b_date)
 500                 return 1;
 501         if (a_date > b_date)
 502                 return -1;
 503         return 0;
 504 }
 505
 506 static void *commit_list_get_next(const void *a)
 507 {
 508         return ((const struct commit_list *)a)->next;
 509 }
 510
 511 static void commit_list_set_next(void *a, void *next)
 512 {
 513         ((struct commit_list *)a)->next = next;
 514 }
 515
 516 void commit_list_sort_by_date(struct commit_list **list)
 517 {
 518         *list = llist_mergesort(*list, commit_list_get_next, commit_list_set_next,
 519                                 commit_list_compare_by_date);
 520 }
 521
 522 struct commit *pop_most_recent_commit(struct commit_list **list,
 523                                       unsigned int mark)
 524 {
 525         struct commit *ret = pop_commit(list);
 526         struct commit_list *parents = ret->parents;
 527
 528         while (parents) {
 529                 struct commit *commit = parents->item;
 530                 if (!parse_commit(commit) && !(commit->object.flags & mark)) {
 531                         commit->object.flags |= mark;
 532                         commit_list_insert_by_date(commit, list);
 533                 }
 534                 parents = parents->next;
 535         }
 536         return ret;
 537 }
 538
 539 static void clear_commit_marks_1(struct commit_list **plist,
 540                                  struct commit *commit, unsigned int mark)
 541 {
 542         while (commit) {
 543                 struct commit_list *parents;
 544
 545                 if (!(mark & commit->object.flags))
 546                         return;
 547
 548                 commit->object.flags &= ~mark;
 549
 550                 parents = commit->parents;
 551                 if (!parents)
 552                         return;
 553
 554                 while ((parents = parents->next))
 555                         commit_list_insert(parents->item, plist);
 556
 557                 commit = commit->parents->item;
 558         }
 559 }
 560
 561 void clear_commit_marks_many(int nr, struct commit **commit, unsigned int mark)
 562 {
 563         struct commit_list *list = NULL;
 564
 565         while (nr--) {
 566                 clear_commit_marks_1(&list, *commit, mark);
 567                 commit++;
 568         }
 569         while (list)
 570                 clear_commit_marks_1(&list, pop_commit(&list), mark);
 571 }
 572
 573 void clear_commit_marks(struct commit *commit, unsigned int mark)
 574 {
 575         clear_commit_marks_many(1, &commit, mark);
 576 }
 577
 578 struct commit *pop_commit(struct commit_list **stack)
 579 {
 580         struct commit_list *top = *stack;
 581         struct commit *item = top ? top->item : NULL;
 582
 583         if (top) {
 584                 *stack = top->next;
 585                 free(top);
 586         }
 587         return item;
 588 }
 589
 590 /*
 591  * Topological sort support
 592  */
 593
 594 /* count number of children that have not been emitted */
 595 define_commit_slab(indegree_slab, int);
 596
 597 /* record author-date for each commit object */
 598 define_commit_slab(author_date_slab, unsigned long);
 599
 600 static void record_author_date(struct author_date_slab *author_date,
 601                                struct commit *commit)
 602 {
 603         const char *buffer = get_commit_buffer(commit, NULL);
 604         struct ident_split ident;
 605         const char *ident_line;
 606         size_t ident_len;
 607         char *date_end;
 608         timestamp_t date;
 609
 610         ident_line = find_commit_header(buffer, "author", &ident_len);
 611         if (!ident_line)
 612                 goto fail_exit; /* no author line */
 613         if (split_ident_line(&ident, ident_line, ident_len) ||
 614             !ident.date_begin || !ident.date_end)
 615                 goto fail_exit; /* malformed "author" line */
 616
 617         date = parse_timestamp(ident.date_begin, &date_end, 10);
 618         if (date_end != ident.date_end)
 619                 goto fail_exit; /* malformed date */
 620         *(author_date_slab_at(author_date, commit)) = date;
 621
 622 fail_exit:
 623         unuse_commit_buffer(commit, buffer);
 624 }
 625
 626 static int compare_commits_by_author_date(const void *a_, const void *b_,
 627                                           void *cb_data)
 628 {
 629         const struct commit *a = a_, *b = b_;
 630         struct author_date_slab *author_date = cb_data;
 631         timestamp_t a_date = *(author_date_slab_at(author_date, a));
 632         timestamp_t b_date = *(author_date_slab_at(author_date, b));
 633
 634         /* newer commits with larger date first */
 635         if (a_date < b_date)
 636                 return 1;
 637         else if (a_date > b_date)
 638                 return -1;
 639         return 0;
 640 }
 641
 642 int compare_commits_by_commit_date(const void *a_, const void *b_, void *unused)
 643 {
 644         const struct commit *a = a_, *b = b_;
 645         /* newer commits with larger date first */
 646         if (a->date < b->date)
 647                 return 1;
 648         else if (a->date > b->date)
 649                 return -1;
 650         return 0;
 651 }
 652
 653 /*
 654  * Performs an in-place topological sort on the list supplied.
 655  */
 656 void sort_in_topological_order(struct commit_list **list, enum rev_sort_order sort_order)
 657 {
 658         struct commit_list *next, *orig = *list;
 659         struct commit_list **pptr;
 660         struct indegree_slab indegree;
 661         struct prio_queue queue;
 662         struct commit *commit;
 663         struct author_date_slab author_date;
 664
 665         if (!orig)
 666                 return;
 667         *list = NULL;
 668
 669         init_indegree_slab(&indegree);
 670         memset(&queue, '\0', sizeof(queue));
 671
 672         switch (sort_order) {
 673         default: /* REV_SORT_IN_GRAPH_ORDER */
 674                 queue.compare = NULL;
 675                 break;
 676         case REV_SORT_BY_COMMIT_DATE:
 677                 queue.compare = compare_commits_by_commit_date;
 678                 break;
 679         case REV_SORT_BY_AUTHOR_DATE:
 680                 init_author_date_slab(&author_date);
 681                 queue.compare = compare_commits_by_author_date;
 682                 queue.cb_data = &author_date;
 683                 break;
 684         }
 685
 686         /* Mark them and clear the indegree */
 687         for (next = orig; next; next = next->next) {
 688                 struct commit *commit = next->item;
 689                 *(indegree_slab_at(&indegree, commit)) = 1;
 690                 /* also record the author dates, if needed */
 691                 if (sort_order == REV_SORT_BY_AUTHOR_DATE)
 692                         record_author_date(&author_date, commit);
 693         }
 694
 695         /* update the indegree */
 696         for (next = orig; next; next = next->next) {
 697                 struct commit_list *parents = next->item->parents;
 698                 while (parents) {
 699                         struct commit *parent = parents->item;
 700                         int *pi = indegree_slab_at(&indegree, parent);
 701
 702                         if (*pi)
 703                                 (*pi)++;
 704                         parents = parents->next;
 705                 }
 706         }
 707
 708         /*
 709          * find the tips
 710          *
 711          * tips are nodes not reachable from any other node in the list
 712          *
 713          * the tips serve as a starting set for the work queue.
 714          */
 715         for (next = orig; next; next = next->next) {
 716                 struct commit *commit = next->item;
 717
 718                 if (*(indegree_slab_at(&indegree, commit)) == 1)
 719                         prio_queue_put(&queue, commit);
 720         }
 721
 722         /*
 723          * This is unfortunate; the initial tips need to be shown
 724          * in the order given from the revision traversal machinery.
 725          */
 726         if (sort_order == REV_SORT_IN_GRAPH_ORDER)
 727                 prio_queue_reverse(&queue);
 728
 729         /* We no longer need the commit list */
 730         free_commit_list(orig);
 731
 732         pptr = list;
 733         *list = NULL;
 734         while ((commit = prio_queue_get(&queue)) != NULL) {
 735                 struct commit_list *parents;
 736
 737                 for (parents = commit->parents; parents ; parents = parents->next) {
 738                         struct commit *parent = parents->item;
 739                         int *pi = indegree_slab_at(&indegree, parent);
 740
 741                         if (!*pi)
 742                                 continue;
 743
 744                         /*
 745                          * parents are only enqueued for emission
 746                          * when all their children have been emitted thereby
 747                          * guaranteeing topological order.
 748                          */
 749                         if (--(*pi) == 1)
 750                                 prio_queue_put(&queue, parent);
 751                 }
 752                 /*
 753                  * all children of commit have already been
 754                  * emitted. we can emit it now.
 755                  */
 756                 *(indegree_slab_at(&indegree, commit)) = 0;
 757
 758                 pptr = &commit_list_insert(commit, pptr)->next;
 759         }
 760
 761         clear_indegree_slab(&indegree);
 762         clear_prio_queue(&queue);
 763         if (sort_order == REV_SORT_BY_AUTHOR_DATE)
 764                 clear_author_date_slab(&author_date);
 765 }
 766
 767 /* merge-base stuff */
 768
 769 /* Remember to update object flag allocation in object.h */
 770 #define PARENT1         (1u<<16)
 771 #define PARENT2         (1u<<17)
 772 #define STALE           (1u<<18)
 773 #define RESULT          (1u<<19)
 774
 775 static const unsigned all_flags = (PARENT1 | PARENT2 | STALE | RESULT);
 776
 777 static int queue_has_nonstale(struct prio_queue *queue)
 778 {
 779         int i;
 780         for (i = 0; i < queue->nr; i++) {
 781                 struct commit *commit = queue->array[i].data;
 782                 if (!(commit->object.flags & STALE))
 783                         return 1;
 784         }
 785         return 0;
 786 }
 787
 788 /* all input commits in one and twos[] must have been parsed! */
 789 static struct commit_list *paint_down_to_common(struct commit *one, int n, struct commit **twos)
 790 {
 791         struct prio_queue queue = { compare_commits_by_commit_date };
 792         struct commit_list *result = NULL;
 793         int i;
 794
 795         one->object.flags |= PARENT1;
 796         if (!n) {
 797                 commit_list_append(one, &result);
 798                 return result;
 799         }
 800         prio_queue_put(&queue, one);
 801
 802         for (i = 0; i < n; i++) {
 803                 twos[i]->object.flags |= PARENT2;
 804                 prio_queue_put(&queue, twos[i]);
 805         }
 806
 807         while (queue_has_nonstale(&queue)) {
 808                 struct commit *commit = prio_queue_get(&queue);
 809                 struct commit_list *parents;
 810                 int flags;
 811
 812                 flags = commit->object.flags & (PARENT1 | PARENT2 | STALE);
 813                 if (flags == (PARENT1 | PARENT2)) {
 814                         if (!(commit->object.flags & RESULT)) {
 815                                 commit->object.flags |= RESULT;
 816                                 commit_list_insert_by_date(commit, &result);
 817                         }
 818                         /* Mark parents of a found merge stale */
 819                         flags |= STALE;
 820                 }
 821                 parents = commit->parents;
 822                 while (parents) {
 823                         struct commit *p = parents->item;
 824                         parents = parents->next;
 825                         if ((p->object.flags & flags) == flags)
 826                                 continue;
 827                         if (parse_commit(p))
 828                                 return NULL;
 829                         p->object.flags |= flags;
 830                         prio_queue_put(&queue, p);
 831                 }
 832         }
 833
 834         clear_prio_queue(&queue);
 835         return result;
 836 }
 837
 838 static struct commit_list *merge_bases_many(struct commit *one, int n, struct commit **twos)
 839 {
 840         struct commit_list *list = NULL;
 841         struct commit_list *result = NULL;
 842         int i;
 843
 844         for (i = 0; i < n; i++) {
 845                 if (one == twos[i])
 846                         /*
 847                          * We do not mark this even with RESULT so we do not
 848                          * have to clean it up.
 849                          */
 850                         return commit_list_insert(one, &result);
 851         }
 852
 853         if (parse_commit(one))
 854                 return NULL;
 855         for (i = 0; i < n; i++) {
 856                 if (parse_commit(twos[i]))
 857                         return NULL;
 858         }
 859
 860         list = paint_down_to_common(one, n, twos);
 861
 862         while (list) {
 863                 struct commit *commit = pop_commit(&list);
 864                 if (!(commit->object.flags & STALE))
 865                         commit_list_insert_by_date(commit, &result);
 866         }
 867         return result;
 868 }
 869
 870 struct commit_list *get_octopus_merge_bases(struct commit_list *in)
 871 {
 872         struct commit_list *i, *j, *k, *ret = NULL;
 873
 874         if (!in)
 875                 return ret;
 876
 877         commit_list_insert(in->item, &ret);
 878
 879         for (i = in->next; i; i = i->next) {
 880                 struct commit_list *new_commits = NULL, *end = NULL;
 881
 882                 for (j = ret; j; j = j->next) {
 883                         struct commit_list *bases;
 884                         bases = get_merge_bases(i->item, j->item);
 885                         if (!new_commits)
 886                                 new_commits = bases;
 887                         else
 888                                 end->next = bases;
 889                         for (k = bases; k; k = k->next)
 890                                 end = k;
 891                 }
 892                 ret = new_commits;
 893         }
 894         return ret;
 895 }
 896
 897 static int remove_redundant(struct commit **array, int cnt)
 898 {
 899         /*
 900          * Some commit in the array may be an ancestor of
 901          * another commit.  Move such commit to the end of
 902          * the array, and return the number of commits that
 903          * are independent from each other.
 904          */
 905         struct commit **work;
 906         unsigned char *redundant;
 907         int *filled_index;
 908         int i, j, filled;
 909
 910         work = xcalloc(cnt, sizeof(*work));
 911         redundant = xcalloc(cnt, 1);
 912         ALLOC_ARRAY(filled_index, cnt - 1);
 913
 914         for (i = 0; i < cnt; i++)
 915                 parse_commit(array[i]);
 916         for (i = 0; i < cnt; i++) {
 917                 struct commit_list *common;
 918
 919                 if (redundant[i])
 920                         continue;
 921                 for (j = filled = 0; j < cnt; j++) {
 922                         if (i == j || redundant[j])
 923                                 continue;
 924                         filled_index[filled] = j;
 925                         work[filled++] = array[j];
 926                 }
 927                 common = paint_down_to_common(array[i], filled, work);
 928                 if (array[i]->object.flags & PARENT2)
 929                         redundant[i] = 1;
 930                 for (j = 0; j < filled; j++)
 931                         if (work[j]->object.flags & PARENT1)
 932                                 redundant[filled_index[j]] = 1;
 933                 clear_commit_marks(array[i], all_flags);
 934                 clear_commit_marks_many(filled, work, all_flags);
 935                 free_commit_list(common);
 936         }
 937
 938         /* Now collect the result */
 939         COPY_ARRAY(work, array, cnt);
 940         for (i = filled = 0; i < cnt; i++)
 941                 if (!redundant[i])
 942                         array[filled++] = work[i];
 943         for (j = filled, i = 0; i < cnt; i++)
 944                 if (redundant[i])
 945                         array[j++] = work[i];
 946         free(work);
 947         free(redundant);
 948         free(filled_index);
 949         return filled;
 950 }
 951
 952 static struct commit_list *get_merge_bases_many_0(struct commit *one,
 953                                                   int n,
 954                                                   struct commit **twos,
 955                                                   int cleanup)
 956 {
 957         struct commit_list *list;
 958         struct commit **rslt;
 959         struct commit_list *result;
 960         int cnt, i;
 961
 962         result = merge_bases_many(one, n, twos);
 963         for (i = 0; i < n; i++) {
 964                 if (one == twos[i])
 965                         return result;
 966         }
 967         if (!result || !result->next) {
 968                 if (cleanup) {
 969                         clear_commit_marks(one, all_flags);
 970                         clear_commit_marks_many(n, twos, all_flags);
 971                 }
 972                 return result;
 973         }
 974
 975         /* There are more than one */
 976         cnt = commit_list_count(result);
 977         rslt = xcalloc(cnt, sizeof(*rslt));
 978         for (list = result, i = 0; list; list = list->next)
 979                 rslt[i++] = list->item;
 980         free_commit_list(result);
 981
 982         clear_commit_marks(one, all_flags);
 983         clear_commit_marks_many(n, twos, all_flags);
 984
 985         cnt = remove_redundant(rslt, cnt);
 986         result = NULL;
 987         for (i = 0; i < cnt; i++)
 988                 commit_list_insert_by_date(rslt[i], &result);
 989         free(rslt);
 990         return result;
 991 }
 992
 993 struct commit_list *get_merge_bases_many(struct commit *one,
 994                                          int n,
 995                                          struct commit **twos)
 996 {
 997         return get_merge_bases_many_0(one, n, twos, 1);
 998 }
 999
1000 struct commit_list *get_merge_bases_many_dirty(struct commit *one,
1001                                                int n,
1002                                                struct commit **twos)
1003 {
1004         return get_merge_bases_many_0(one, n, twos, 0);
1005 }
1006
1007 struct commit_list *get_merge_bases(struct commit *one, struct commit *two)
1008 {
1009         return get_merge_bases_many_0(one, 1, &two, 1);
1010 }
1011
1012 /*
1013  * Is "commit" a descendant of one of the elements on the "with_commit" list?
1014  */
1015 int is_descendant_of(struct commit *commit, struct commit_list *with_commit)
1016 {
1017         if (!with_commit)
1018                 return 1;
1019         while (with_commit) {
1020                 struct commit *other;
1021
1022                 other = with_commit->item;
1023                 with_commit = with_commit->next;
1024                 if (in_merge_bases(other, commit))
1025                         return 1;
1026         }
1027         return 0;
1028 }
1029
1030 /*
1031  * Is "commit" an ancestor of one of the "references"?
1032  */
1033 int in_merge_bases_many(struct commit *commit, int nr_reference, struct commit **reference)
1034 {
1035         struct commit_list *bases;
1036         int ret = 0, i;
1037
1038         if (parse_commit(commit))
1039                 return ret;
1040         for (i = 0; i < nr_reference; i++)
1041                 if (parse_commit(reference[i]))
1042                         return ret;
1043
1044         bases = paint_down_to_common(commit, nr_reference, reference);
1045         if (commit->object.flags & PARENT2)
1046                 ret = 1;
1047         clear_commit_marks(commit, all_flags);
1048         clear_commit_marks_many(nr_reference, reference, all_flags);
1049         free_commit_list(bases);
1050         return ret;
1051 }
1052
1053 /*
1054  * Is "commit" an ancestor of (i.e. reachable from) the "reference"?
1055  */
1056 int in_merge_bases(struct commit *commit, struct commit *reference)
1057 {
1058         return in_merge_bases_many(commit, 1, &reference);
1059 }
1060
1061 struct commit_list *reduce_heads(struct commit_list *heads)
1062 {
1063         struct commit_list *p;
1064         struct commit_list *result = NULL, **tail = &result;
1065         struct commit **array;
1066         int num_head, i;
1067
1068         if (!heads)
1069                 return NULL;
1070
1071         /* Uniquify */
1072         for (p = heads; p; p = p->next)
1073                 p->item->object.flags &= ~STALE;
1074         for (p = heads, num_head = 0; p; p = p->next) {
1075                 if (p->item->object.flags & STALE)
1076                         continue;
1077                 p->item->object.flags |= STALE;
1078                 num_head++;
1079         }
1080         array = xcalloc(num_head, sizeof(*array));
1081         for (p = heads, i = 0; p; p = p->next) {
1082                 if (p->item->object.flags & STALE) {
1083                         array[i++] = p->item;
1084                         p->item->object.flags &= ~STALE;
1085                 }
1086         }
1087         num_head = remove_redundant(array, num_head);
1088         for (i = 0; i < num_head; i++)
1089                 tail = &commit_list_insert(array[i], tail)->next;
1090         free(array);
1091         return result;
1092 }
1093
1094 void reduce_heads_replace(struct commit_list **heads)
1095 {
1096         struct commit_list *result = reduce_heads(*heads);
1097         free_commit_list(*heads);
1098         *heads = result;
1099 }
1100
1101 static const char gpg_sig_header[] = "gpgsig";
1102 static const int gpg_sig_header_len = sizeof(gpg_sig_header) - 1;
1103
1104 static int do_sign_commit(struct strbuf *buf, const char *keyid)
1105 {
1106         struct strbuf sig = STRBUF_INIT;
1107         int inspos, copypos;
1108         const char *eoh;
1109
1110         /* find the end of the header */
1111         eoh = strstr(buf->buf, "\n\n");
1112         if (!eoh)
1113                 inspos = buf->len;
1114         else
1115                 inspos = eoh - buf->buf + 1;
1116
1117         if (!keyid || !*keyid)
1118                 keyid = get_signing_key();
1119         if (sign_buffer(buf, &sig, keyid)) {
1120                 strbuf_release(&sig);
1121                 return -1;
1122         }
1123
1124         for (copypos = 0; sig.buf[copypos]; ) {
1125                 const char *bol = sig.buf + copypos;
1126                 const char *eol = strchrnul(bol, '\n');
1127                 int len = (eol - bol) + !!*eol;
1128
1129                 if (!copypos) {
1130                         strbuf_insert(buf, inspos, gpg_sig_header, gpg_sig_header_len);
1131                         inspos += gpg_sig_header_len;
1132                 }
1133                 strbuf_insert(buf, inspos++, " ", 1);
1134                 strbuf_insert(buf, inspos, bol, len);
1135                 inspos += len;
1136                 copypos += len;
1137         }
1138         strbuf_release(&sig);
1139         return 0;
1140 }
1141
1142 int parse_signed_commit(const struct commit *commit,
1143                         struct strbuf *payload, struct strbuf *signature)
1144 {
1145
1146         unsigned long size;
1147         const char *buffer = get_commit_buffer(commit, &size);
1148         int in_signature, saw_signature = -1;
1149         const char *line, *tail;
1150
1151         line = buffer;
1152         tail = buffer + size;
1153         in_signature = 0;
1154         saw_signature = 0;
1155         while (line < tail) {
1156                 const char *sig = NULL;
1157                 const char *next = memchr(line, '\n', tail - line);
1158
1159                 next = next ? next + 1 : tail;
1160                 if (in_signature && line[0] == ' ')
1161                         sig = line + 1;
1162                 else if (starts_with(line, gpg_sig_header) &&
1163                          line[gpg_sig_header_len] == ' ')
1164                         sig = line + gpg_sig_header_len + 1;
1165                 if (sig) {
1166                         strbuf_add(signature, sig, next - sig);
1167                         saw_signature = 1;
1168                         in_signature = 1;
1169                 } else {
1170                         if (*line == '\n')
1171                                 /* dump the whole remainder of the buffer */
1172                                 next = tail;
1173                         strbuf_add(payload, line, next - line);
1174                         in_signature = 0;
1175                 }
1176                 line = next;
1177         }
1178         unuse_commit_buffer(commit, buffer);
1179         return saw_signature;
1180 }
1181
1182 int remove_signature(struct strbuf *buf)
1183 {
1184         const char *line = buf->buf;
1185         const char *tail = buf->buf + buf->len;
1186         int in_signature = 0;
1187         const char *sig_start = NULL;
1188         const char *sig_end = NULL;
1189
1190         while (line < tail) {
1191                 const char *next = memchr(line, '\n', tail - line);
1192                 next = next ? next + 1 : tail;
1193
1194                 if (in_signature && line[0] == ' ')
1195                         sig_end = next;
1196                 else if (starts_with(line, gpg_sig_header) &&
1197                          line[gpg_sig_header_len] == ' ') {
1198                         sig_start = line;
1199                         sig_end = next;
1200                         in_signature = 1;
1201                 } else {
1202                         if (*line == '\n')
1203                                 /* dump the whole remainder of the buffer */
1204                                 next = tail;
1205                         in_signature = 0;
1206                 }
1207                 line = next;
1208         }
1209
1210         if (sig_start)
1211                 strbuf_remove(buf, sig_start - buf->buf, sig_end - sig_start);
1212
1213         return sig_start != NULL;
1214 }
1215
1216 static void handle_signed_tag(struct commit *parent, struct commit_extra_header ***tail)
1217 {
1218         struct merge_remote_desc *desc;
1219         struct commit_extra_header *mergetag;
1220         char *buf;
1221         unsigned long size, len;
1222         enum object_type type;
1223
1224         desc = merge_remote_util(parent);
1225         if (!desc || !desc->obj)
1226                 return;
1227         buf = read_object_file(&desc->obj->oid, &type, &size);
1228         if (!buf || type != OBJ_TAG)
1229                 goto free_return;
1230         len = parse_signature(buf, size);
1231         if (size == len)
1232                 goto free_return;
1233         /*
1234          * We could verify this signature and either omit the tag when
1235          * it does not validate, but the integrator may not have the
1236          * public key of the signer of the tag he is merging, while a
1237          * later auditor may have it while auditing, so let's not run
1238          * verify-signed-buffer here for now...
1239          *
1240          * if (verify_signed_buffer(buf, len, buf + len, size - len, ...))
1241          *      warn("warning: signed tag unverified.");
1242          */
1243         mergetag = xcalloc(1, sizeof(*mergetag));
1244         mergetag->key = xstrdup("mergetag");
1245         mergetag->value = buf;
1246         mergetag->len = size;
1247
1248         **tail = mergetag;
1249         *tail = &mergetag->next;
1250         return;
1251
1252 free_return:
1253         free(buf);
1254 }
1255
1256 int check_commit_signature(const struct commit *commit, struct signature_check *sigc)
1257 {
1258         struct strbuf payload = STRBUF_INIT;
1259         struct strbuf signature = STRBUF_INIT;
1260         int ret = 1;
1261
1262         sigc->result = 'N';
1263
1264         if (parse_signed_commit(commit, &payload, &signature) <= 0)
1265                 goto out;
1266         ret = check_signature(payload.buf, payload.len, signature.buf,
1267                 signature.len, sigc);
1268
1269  out:
1270         strbuf_release(&payload);
1271         strbuf_release(&signature);
1272
1273         return ret;
1274 }
1275
1276
1277
1278 void append_merge_tag_headers(struct commit_list *parents,
1279                               struct commit_extra_header ***tail)
1280 {
1281         while (parents) {
1282                 struct commit *parent = parents->item;
1283                 handle_signed_tag(parent, tail);
1284                 parents = parents->next;
1285         }
1286 }
1287
1288 static void add_extra_header(struct strbuf *buffer,
1289                              struct commit_extra_header *extra)
1290 {
1291         strbuf_addstr(buffer, extra->key);
1292         if (extra->len)
1293                 strbuf_add_lines(buffer, " ", extra->value, extra->len);
1294         else
1295                 strbuf_addch(buffer, '\n');
1296 }
1297
1298 struct commit_extra_header *read_commit_extra_headers(struct commit *commit,
1299                                                       const char **exclude)
1300 {
1301         struct commit_extra_header *extra = NULL;
1302         unsigned long size;
1303         const char *buffer = get_commit_buffer(commit, &size);
1304         extra = read_commit_extra_header_lines(buffer, size, exclude);
1305         unuse_commit_buffer(commit, buffer);
1306         return extra;
1307 }
1308
1309 void for_each_mergetag(each_mergetag_fn fn, struct commit *commit, void *data)
1310 {
1311         struct commit_extra_header *extra, *to_free;
1312
1313         to_free = read_commit_extra_headers(commit, NULL);
1314         for (extra = to_free; extra; extra = extra->next) {
1315                 if (strcmp(extra->key, "mergetag"))
1316                         continue; /* not a merge tag */
1317                 fn(commit, extra, data);
1318         }
1319         free_commit_extra_headers(to_free);
1320 }
1321
1322 static inline int standard_header_field(const char *field, size_t len)
1323 {
1324         return ((len == 4 && !memcmp(field, "tree", 4)) ||
1325                 (len == 6 && !memcmp(field, "parent", 6)) ||
1326                 (len == 6 && !memcmp(field, "author", 6)) ||
1327                 (len == 9 && !memcmp(field, "committer", 9)) ||
1328                 (len == 8 && !memcmp(field, "encoding", 8)));
1329 }
1330
1331 static int excluded_header_field(const char *field, size_t len, const char **exclude)
1332 {
1333         if (!exclude)
1334                 return 0;
1335
1336         while (*exclude) {
1337                 size_t xlen = strlen(*exclude);
1338                 if (len == xlen && !memcmp(field, *exclude, xlen))
1339                         return 1;
1340                 exclude++;
1341         }
1342         return 0;
1343 }
1344
1345 static struct commit_extra_header *read_commit_extra_header_lines(
1346         const char *buffer, size_t size,
1347         const char **exclude)
1348 {
1349         struct commit_extra_header *extra = NULL, **tail = &extra, *it = NULL;
1350         const char *line, *next, *eof, *eob;
1351         struct strbuf buf = STRBUF_INIT;
1352
1353         for (line = buffer, eob = line + size;
1354              line < eob && *line != '\n';
1355              line = next) {
1356                 next = memchr(line, '\n', eob - line);
1357                 next = next ? next + 1 : eob;
1358                 if (*line == ' ') {
1359                         /* continuation */
1360                         if (it)
1361                                 strbuf_add(&buf, line + 1, next - (line + 1));
1362                         continue;
1363                 }
1364                 if (it)
1365                         it->value = strbuf_detach(&buf, &it->len);
1366                 strbuf_reset(&buf);
1367                 it = NULL;
1368
1369                 eof = memchr(line, ' ', next - line);
1370                 if (!eof)
1371                         eof = next;
1372                 else if (standard_header_field(line, eof - line) ||
1373                          excluded_header_field(line, eof - line, exclude))
1374                         continue;
1375
1376                 it = xcalloc(1, sizeof(*it));
1377                 it->key = xmemdupz(line, eof-line);
1378                 *tail = it;
1379                 tail = &it->next;
1380                 if (eof + 1 < next)
1381                         strbuf_add(&buf, eof + 1, next - (eof + 1));
1382         }
1383         if (it)
1384                 it->value = strbuf_detach(&buf, &it->len);
1385         return extra;
1386 }
1387
1388 void free_commit_extra_headers(struct commit_extra_header *extra)
1389 {
1390         while (extra) {
1391                 struct commit_extra_header *next = extra->next;
1392                 free(extra->key);
1393                 free(extra->value);
1394                 free(extra);
1395                 extra = next;
1396         }
1397 }
1398
1399 int commit_tree(const char *msg, size_t msg_len, const struct object_id *tree,
1400                 struct commit_list *parents, struct object_id *ret,
1401                 const char *author, const char *sign_commit)
1402 {
1403         struct commit_extra_header *extra = NULL, **tail = &extra;
1404         int result;
1405
1406         append_merge_tag_headers(parents, &tail);
1407         result = commit_tree_extended(msg, msg_len, tree, parents, ret,
1408                                       author, sign_commit, extra);
1409         free_commit_extra_headers(extra);
1410         return result;
1411 }
1412
1413 static int find_invalid_utf8(const char *buf, int len)
1414 {
1415         int offset = 0;
1416         static const unsigned int max_codepoint[] = {
1417                 0x7f, 0x7ff, 0xffff, 0x10ffff
1418         };
1419
1420         while (len) {
1421                 unsigned char c = *buf++;
1422                 int bytes, bad_offset;
1423                 unsigned int codepoint;
1424                 unsigned int min_val, max_val;
1425
1426                 len--;
1427                 offset++;
1428
1429                 /* Simple US-ASCII? No worries. */
1430                 if (c < 0x80)
1431                         continue;
1432
1433                 bad_offset = offset-1;
1434
1435                 /*
1436                  * Count how many more high bits set: that's how
1437                  * many more bytes this sequence should have.
1438                  */
1439                 bytes = 0;
1440                 while (c & 0x40) {
1441                         c <<= 1;
1442                         bytes++;
1443                 }
1444
1445                 /*
1446                  * Must be between 1 and 3 more bytes.  Longer sequences result in
1447                  * codepoints beyond U+10FFFF, which are guaranteed never to exist.
1448                  */
1449                 if (bytes < 1 || 3 < bytes)
1450                         return bad_offset;
1451
1452                 /* Do we *have* that many bytes? */
1453                 if (len < bytes)
1454                         return bad_offset;
1455
1456                 /*
1457                  * Place the encoded bits at the bottom of the value and compute the
1458                  * valid range.
1459                  */
1460                 codepoint = (c & 0x7f) >> bytes;
1461                 min_val = max_codepoint[bytes-1] + 1;
1462                 max_val = max_codepoint[bytes];
1463
1464                 offset += bytes;
1465                 len -= bytes;
1466
1467                 /* And verify that they are good continuation bytes */
1468                 do {
1469                         codepoint <<= 6;
1470                         codepoint |= *buf & 0x3f;
1471                         if ((*buf++ & 0xc0) != 0x80)
1472                                 return bad_offset;
1473                 } while (--bytes);
1474
1475                 /* Reject codepoints that are out of range for the sequence length. */
1476                 if (codepoint < min_val || codepoint > max_val)
1477                         return bad_offset;
1478                 /* Surrogates are only for UTF-16 and cannot be encoded in UTF-8. */
1479                 if ((codepoint & 0x1ff800) == 0xd800)
1480                         return bad_offset;
1481                 /* U+xxFFFE and U+xxFFFF are guaranteed non-characters. */
1482                 if ((codepoint & 0xfffe) == 0xfffe)
1483                         return bad_offset;
1484                 /* So are anything in the range U+FDD0..U+FDEF. */
1485                 if (codepoint >= 0xfdd0 && codepoint <= 0xfdef)
1486                         return bad_offset;
1487         }
1488         return -1;
1489 }
1490
1491 /*
1492  * This verifies that the buffer is in proper utf8 format.
1493  *
1494  * If it isn't, it assumes any non-utf8 characters are Latin1,
1495  * and does the conversion.
1496  */
1497 static int verify_utf8(struct strbuf *buf)
1498 {
1499         int ok = 1;
1500         long pos = 0;
1501
1502         for (;;) {
1503                 int bad;
1504                 unsigned char c;
1505                 unsigned char replace[2];
1506
1507                 bad = find_invalid_utf8(buf->buf + pos, buf->len - pos);
1508                 if (bad < 0)
1509                         return ok;
1510                 pos += bad;
1511                 ok = 0;
1512                 c = buf->buf[pos];
1513                 strbuf_remove(buf, pos, 1);
1514
1515                 /* We know 'c' must be in the range 128-255 */
1516                 replace[0] = 0xc0 + (c >> 6);
1517                 replace[1] = 0x80 + (c & 0x3f);
1518                 strbuf_insert(buf, pos, replace, 2);
1519                 pos += 2;
1520         }
1521 }
1522
1523 static const char commit_utf8_warn[] =
1524 N_("Warning: commit message did not conform to UTF-8.\n"
1525    "You may want to amend it after fixing the message, or set the config\n"
1526    "variable i18n.commitencoding to the encoding your project uses.\n");
1527
1528 int commit_tree_extended(const char *msg, size_t msg_len,
1529                          const struct object_id *tree,
1530                          struct commit_list *parents, struct object_id *ret,
1531                          const char *author, const char *sign_commit,
1532                          struct commit_extra_header *extra)
1533 {
1534         int result;
1535         int encoding_is_utf8;
1536         struct strbuf buffer;
1537
1538         assert_oid_type(tree, OBJ_TREE);
1539
1540         if (memchr(msg, '\0', msg_len))
1541                 return error("a NUL byte in commit log message not allowed.");
1542
1543         /* Not having i18n.commitencoding is the same as having utf-8 */
1544         encoding_is_utf8 = is_encoding_utf8(git_commit_encoding);
1545
1546         strbuf_init(&buffer, 8192); /* should avoid reallocs for the headers */
1547         strbuf_addf(&buffer, "tree %s\n", oid_to_hex(tree));
1548
1549         /*
1550          * NOTE! This ordering means that the same exact tree merged with a
1551          * different order of parents will be a _different_ changeset even
1552          * if everything else stays the same.
1553          */
1554         while (parents) {
1555                 struct commit *parent = pop_commit(&parents);
1556                 strbuf_addf(&buffer, "parent %s\n",
1557                             oid_to_hex(&parent->object.oid));
1558         }
1559
1560         /* Person/date information */
1561         if (!author)
1562                 author = git_author_info(IDENT_STRICT);
1563         strbuf_addf(&buffer, "author %s\n", author);
1564         strbuf_addf(&buffer, "committer %s\n", git_committer_info(IDENT_STRICT));
1565         if (!encoding_is_utf8)
1566                 strbuf_addf(&buffer, "encoding %s\n", git_commit_encoding);
1567
1568         while (extra) {
1569                 add_extra_header(&buffer, extra);
1570                 extra = extra->next;
1571         }
1572         strbuf_addch(&buffer, '\n');
1573
1574         /* And add the comment */
1575         strbuf_add(&buffer, msg, msg_len);
1576
1577         /* And check the encoding */
1578         if (encoding_is_utf8 && !verify_utf8(&buffer))
1579                 fprintf(stderr, _(commit_utf8_warn));
1580
1581         if (sign_commit && do_sign_commit(&buffer, sign_commit)) {
1582                 result = -1;
1583                 goto out;
1584         }
1585
1586         result = write_object_file(buffer.buf, buffer.len, commit_type, ret);
1587 out:
1588         strbuf_release(&buffer);
1589         return result;
1590 }
1591
1592 void set_merge_remote_desc(struct commit *commit,
1593                            const char *name, struct object *obj)
1594 {
1595         struct merge_remote_desc *desc;
1596         FLEX_ALLOC_STR(desc, name, name);
1597         desc->obj = obj;
1598         commit->util = desc;
1599 }
1600
1601 struct commit *get_merge_parent(const char *name)
1602 {
1603         struct object *obj;
1604         struct commit *commit;
1605         struct object_id oid;
1606         if (get_oid(name, &oid))
1607                 return NULL;
1608         obj = parse_object(&oid);
1609         commit = (struct commit *)peel_to_type(name, 0, obj, OBJ_COMMIT);
1610         if (commit && !commit->util)
1611                 set_merge_remote_desc(commit, name, obj);
1612         return commit;
1613 }
1614
1615 /*
1616  * Append a commit to the end of the commit_list.
1617  *
1618  * next starts by pointing to the variable that holds the head of an
1619  * empty commit_list, and is updated to point to the "next" field of
1620  * the last item on the list as new commits are appended.
1621  *
1622  * Usage example:
1623  *
1624  *     struct commit_list *list;
1625  *     struct commit_list **next = &list;
1626  *
1627  *     next = commit_list_append(c1, next);
1628  *     next = commit_list_append(c2, next);
1629  *     assert(commit_list_count(list) == 2);
1630  *     return list;
1631  */
1632 struct commit_list **commit_list_append(struct commit *commit,
1633                                         struct commit_list **next)
1634 {
1635         struct commit_list *new_commit = xmalloc(sizeof(struct commit_list));
1636         new_commit->item = commit;
1637         *next = new_commit;
1638         new_commit->next = NULL;
1639         return &new_commit->next;
1640 }
1641
1642 const char *find_commit_header(const char *msg, const char *key, size_t *out_len)
1643 {
1644         int key_len = strlen(key);
1645         const char *line = msg;
1646
1647         while (line) {
1648                 const char *eol = strchrnul(line, '\n');
1649
1650                 if (line == eol)
1651                         return NULL;
1652
1653                 if (eol - line > key_len &&
1654                     !strncmp(line, key, key_len) &&
1655                     line[key_len] == ' ') {
1656                         *out_len = eol - line - key_len - 1;
1657                         return line + key_len + 1;
1658                 }
1659                 line = *eol ? eol + 1 : NULL;
1660         }
1661         return NULL;
1662 }
1663
1664 /*
1665  * Inspect the given string and determine the true "end" of the log message, in
1666  * order to find where to put a new Signed-off-by: line.  Ignored are
1667  * trailing comment lines and blank lines.  To support "git commit -s
1668  * --amend" on an existing commit, we also ignore "Conflicts:".  To
1669  * support "git commit -v", we truncate at cut lines.
1670  *
1671  * Returns the number of bytes from the tail to ignore, to be fed as
1672  * the second parameter to append_signoff().
1673  */
1674 int ignore_non_trailer(const char *buf, size_t len)
1675 {
1676         int boc = 0;
1677         int bol = 0;
1678         int in_old_conflicts_block = 0;
1679         size_t cutoff = wt_status_locate_end(buf, len);
1680
1681         while (bol < cutoff) {
1682                 const char *next_line = memchr(buf + bol, '\n', len - bol);
1683
1684                 if (!next_line)
1685                         next_line = buf + len;
1686                 else
1687                         next_line++;
1688
1689                 if (buf[bol] == comment_line_char || buf[bol] == '\n') {
1690                         /* is this the first of the run of comments? */
1691                         if (!boc)
1692                                 boc = bol;
1693                         /* otherwise, it is just continuing */
1694                 } else if (starts_with(buf + bol, "Conflicts:\n")) {
1695                         in_old_conflicts_block = 1;
1696                         if (!boc)
1697                                 boc = bol;
1698                 } else if (in_old_conflicts_block && buf[bol] == '\t') {
1699                         ; /* a pathname in the conflicts block */
1700                 } else if (boc) {
1701                         /* the previous was not trailing comment */
1702                         boc = 0;
1703                         in_old_conflicts_block = 0;
1704                 }
1705                 bol = next_line - buf;
1706         }
1707         return boc ? len - boc : len - cutoff;
1708 }