fast-import.c

   1 /*
   2 Format of STDIN stream:
   3
   4   stream ::= cmd*;
   5
   6   cmd ::= new_blob
   7         | new_commit
   8         | new_tag
   9         | reset_branch
  10         | checkpoint
  11         | progress
  12         ;
  13
  14   new_blob ::= 'blob' lf
  15     mark?
  16     file_content;
  17   file_content ::= data;
  18
  19   new_commit ::= 'commit' sp ref_str lf
  20     mark?
  21     ('author' sp name '<' email '>' when lf)?
  22     'committer' sp name '<' email '>' when lf
  23     commit_msg
  24     ('from' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf)?
  25     ('merge' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf)*
  26     file_change*
  27     lf?;
  28   commit_msg ::= data;
  29
  30   file_change ::= file_clr
  31     | file_del
  32     | file_rnm
  33     | file_cpy
  34     | file_obm
  35     | file_inm;
  36   file_clr ::= 'deleteall' lf;
  37   file_del ::= 'D' sp path_str lf;
  38   file_rnm ::= 'R' sp path_str sp path_str lf;
  39   file_cpy ::= 'C' sp path_str sp path_str lf;
  40   file_obm ::= 'M' sp mode sp (hexsha1 | idnum) sp path_str lf;
  41   file_inm ::= 'M' sp mode sp 'inline' sp path_str lf
  42     data;
  43
  44   new_tag ::= 'tag' sp tag_str lf
  45     'from' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf
  46     'tagger' sp name '<' email '>' when lf
  47     tag_msg;
  48   tag_msg ::= data;
  49
  50   reset_branch ::= 'reset' sp ref_str lf
  51     ('from' sp (ref_str | hexsha1 | sha1exp_str | idnum) lf)?
  52     lf?;
  53
  54   checkpoint ::= 'checkpoint' lf
  55     lf?;
  56
  57   progress ::= 'progress' sp not_lf* lf
  58     lf?;
  59
  60      # note: the first idnum in a stream should be 1 and subsequent
  61      # idnums should not have gaps between values as this will cause
  62      # the stream parser to reserve space for the gapped values.  An
  63      # idnum can be updated in the future to a new object by issuing
  64      # a new mark directive with the old idnum.
  65      #
  66   mark ::= 'mark' sp idnum lf;
  67   data ::= (delimited_data | exact_data)
  68     lf?;
  69
  70     # note: delim may be any string but must not contain lf.
  71     # data_line may contain any data but must not be exactly
  72     # delim.
  73   delimited_data ::= 'data' sp '<<' delim lf
  74     (data_line lf)*
  75     delim lf;
  76
  77      # note: declen indicates the length of binary_data in bytes.
  78      # declen does not include the lf preceeding the binary data.
  79      #
  80   exact_data ::= 'data' sp declen lf
  81     binary_data;
  82
  83      # note: quoted strings are C-style quoting supporting \c for
  84      # common escapes of 'c' (e..g \n, \t, \\, \") or \nnn where nnn
  85      # is the signed byte value in octal.  Note that the only
  86      # characters which must actually be escaped to protect the
  87      # stream formatting is: \, " and LF.  Otherwise these values
  88      # are UTF8.
  89      #
  90   ref_str     ::= ref;
  91   sha1exp_str ::= sha1exp;
  92   tag_str     ::= tag;
  93   path_str    ::= path    | '"' quoted(path)    '"' ;
  94   mode        ::= '100644' | '644'
  95                 | '100755' | '755'
  96                 | '120000'
  97                 ;
  98
  99   declen ::= # unsigned 32 bit value, ascii base10 notation;
 100   bigint ::= # unsigned integer value, ascii base10 notation;
 101   binary_data ::= # file content, not interpreted;
 102
 103   when         ::= raw_when | rfc2822_when;
 104   raw_when     ::= ts sp tz;
 105   rfc2822_when ::= # Valid RFC 2822 date and time;
 106
 107   sp ::= # ASCII space character;
 108   lf ::= # ASCII newline (LF) character;
 109
 110      # note: a colon (':') must precede the numerical value assigned to
 111      # an idnum.  This is to distinguish it from a ref or tag name as
 112      # GIT does not permit ':' in ref or tag strings.
 113      #
 114   idnum   ::= ':' bigint;
 115   path    ::= # GIT style file path, e.g. "a/b/c";
 116   ref     ::= # GIT ref name, e.g. "refs/heads/MOZ_GECKO_EXPERIMENT";
 117   tag     ::= # GIT tag name, e.g. "FIREFOX_1_5";
 118   sha1exp ::= # Any valid GIT SHA1 expression;
 119   hexsha1 ::= # SHA1 in hexadecimal format;
 120
 121      # note: name and email are UTF8 strings, however name must not
 122      # contain '<' or lf and email must not contain any of the
 123      # following: '<', '>', lf.
 124      #
 125   name  ::= # valid GIT author/committer name;
 126   email ::= # valid GIT author/committer email;
 127   ts    ::= # time since the epoch in seconds, ascii base10 notation;
 128   tz    ::= # GIT style timezone;
 129
 130      # note: comments may appear anywhere in the input, except
 131      # within a data command.  Any form of the data command
 132      # always escapes the related input from comment processing.
 133      #
 134      # In case it is not clear, the '#' that starts the comment
 135      # must be the first character on that the line (an lf have
 136      # preceeded it).
 137      #
 138   comment ::= '#' not_lf* lf;
 139   not_lf  ::= # Any byte that is not ASCII newline (LF);
 140 */
 141
 142 #include "builtin.h"
 143 #include "cache.h"
 144 #include "object.h"
 145 #include "blob.h"
 146 #include "tree.h"
 147 #include "commit.h"
 148 #include "delta.h"
 149 #include "pack.h"
 150 #include "refs.h"
 151 #include "csum-file.h"
 152 #include "quote.h"
 153
 154 #define PACK_ID_BITS 16
 155 #define MAX_PACK_ID ((1<<PACK_ID_BITS)-1)
 156
 157 struct object_entry
 158 {
 159         struct object_entry *next;
 160         uint32_t offset;
 161         unsigned type : TYPE_BITS;
 162         unsigned pack_id : PACK_ID_BITS;
 163         unsigned char sha1[20];
 164 };
 165
 166 struct object_entry_pool
 167 {
 168         struct object_entry_pool *next_pool;
 169         struct object_entry *next_free;
 170         struct object_entry *end;
 171         struct object_entry entries[FLEX_ARRAY]; /* more */
 172 };
 173
 174 struct mark_set
 175 {
 176         union {
 177                 struct object_entry *marked[1024];
 178                 struct mark_set *sets[1024];
 179         } data;
 180         unsigned int shift;
 181 };
 182
 183 struct last_object
 184 {
 185         struct strbuf data;
 186         uint32_t offset;
 187         unsigned int depth;
 188         unsigned no_swap : 1;
 189 };
 190
 191 struct mem_pool
 192 {
 193         struct mem_pool *next_pool;
 194         char *next_free;
 195         char *end;
 196         char space[FLEX_ARRAY]; /* more */
 197 };
 198
 199 struct atom_str
 200 {
 201         struct atom_str *next_atom;
 202         unsigned short str_len;
 203         char str_dat[FLEX_ARRAY]; /* more */
 204 };
 205
 206 struct tree_content;
 207 struct tree_entry
 208 {
 209         struct tree_content *tree;
 210         struct atom_str* name;
 211         struct tree_entry_ms
 212         {
 213                 uint16_t mode;
 214                 unsigned char sha1[20];
 215         } versions[2];
 216 };
 217
 218 struct tree_content
 219 {
 220         unsigned int entry_capacity; /* must match avail_tree_content */
 221         unsigned int entry_count;
 222         unsigned int delta_depth;
 223         struct tree_entry *entries[FLEX_ARRAY]; /* more */
 224 };
 225
 226 struct avail_tree_content
 227 {
 228         unsigned int entry_capacity; /* must match tree_content */
 229         struct avail_tree_content *next_avail;
 230 };
 231
 232 struct branch
 233 {
 234         struct branch *table_next_branch;
 235         struct branch *active_next_branch;
 236         const char *name;
 237         struct tree_entry branch_tree;
 238         uintmax_t last_commit;
 239         unsigned active : 1;
 240         unsigned pack_id : PACK_ID_BITS;
 241         unsigned char sha1[20];
 242 };
 243
 244 struct tag
 245 {
 246         struct tag *next_tag;
 247         const char *name;
 248         unsigned int pack_id;
 249         unsigned char sha1[20];
 250 };
 251
 252 struct hash_list
 253 {
 254         struct hash_list *next;
 255         unsigned char sha1[20];
 256 };
 257
 258 typedef enum {
 259         WHENSPEC_RAW = 1,
 260         WHENSPEC_RFC2822,
 261         WHENSPEC_NOW,
 262 } whenspec_type;
 263
 264 struct recent_command
 265 {
 266         struct recent_command *prev;
 267         struct recent_command *next;
 268         char *buf;
 269 };
 270
 271 /* Configured limits on output */
 272 static unsigned long max_depth = 10;
 273 static off_t max_packsize = (1LL << 32) - 1;
 274 static int force_update;
 275
 276 /* Stats and misc. counters */
 277 static uintmax_t alloc_count;
 278 static uintmax_t marks_set_count;
 279 static uintmax_t object_count_by_type[1 << TYPE_BITS];
 280 static uintmax_t duplicate_count_by_type[1 << TYPE_BITS];
 281 static uintmax_t delta_count_by_type[1 << TYPE_BITS];
 282 static unsigned long object_count;
 283 static unsigned long branch_count;
 284 static unsigned long branch_load_count;
 285 static int failure;
 286 static FILE *pack_edges;
 287
 288 /* Memory pools */
 289 static size_t mem_pool_alloc = 2*1024*1024 - sizeof(struct mem_pool);
 290 static size_t total_allocd;
 291 static struct mem_pool *mem_pool;
 292
 293 /* Atom management */
 294 static unsigned int atom_table_sz = 4451;
 295 static unsigned int atom_cnt;
 296 static struct atom_str **atom_table;
 297
 298 /* The .pack file being generated */
 299 static unsigned int pack_id;
 300 static struct packed_git *pack_data;
 301 static struct packed_git **all_packs;
 302 static unsigned long pack_size;
 303
 304 /* Table of objects we've written. */
 305 static unsigned int object_entry_alloc = 5000;
 306 static struct object_entry_pool *blocks;
 307 static struct object_entry *object_table[1 << 16];
 308 static struct mark_set *marks;
 309 static const char* mark_file;
 310
 311 /* Our last blob */
 312 static struct last_object last_blob = { STRBUF_INIT, 0, 0, 0 };
 313
 314 /* Tree management */
 315 static unsigned int tree_entry_alloc = 1000;
 316 static void *avail_tree_entry;
 317 static unsigned int avail_tree_table_sz = 100;
 318 static struct avail_tree_content **avail_tree_table;
 319 static struct strbuf old_tree = STRBUF_INIT;
 320 static struct strbuf new_tree = STRBUF_INIT;
 321
 322 /* Branch data */
 323 static unsigned long max_active_branches = 5;
 324 static unsigned long cur_active_branches;
 325 static unsigned long branch_table_sz = 1039;
 326 static struct branch **branch_table;
 327 static struct branch *active_branches;
 328
 329 /* Tag data */
 330 static struct tag *first_tag;
 331 static struct tag *last_tag;
 332
 333 /* Input stream parsing */
 334 static whenspec_type whenspec = WHENSPEC_RAW;
 335 static struct strbuf command_buf = STRBUF_INIT;
 336 static int unread_command_buf;
 337 static struct recent_command cmd_hist = {&cmd_hist, &cmd_hist, NULL};
 338 static struct recent_command *cmd_tail = &cmd_hist;
 339 static struct recent_command *rc_free;
 340 static unsigned int cmd_save = 100;
 341 static uintmax_t next_mark;
 342 static struct strbuf new_data = STRBUF_INIT;
 343
 344 static void write_branch_report(FILE *rpt, struct branch *b)
 345 {
 346         fprintf(rpt, "%s:\n", b->name);
 347
 348         fprintf(rpt, "  status      :");
 349         if (b->active)
 350                 fputs(" active", rpt);
 351         if (b->branch_tree.tree)
 352                 fputs(" loaded", rpt);
 353         if (is_null_sha1(b->branch_tree.versions[1].sha1))
 354                 fputs(" dirty", rpt);
 355         fputc('\n', rpt);
 356
 357         fprintf(rpt, "  tip commit  : %s\n", sha1_to_hex(b->sha1));
 358         fprintf(rpt, "  old tree    : %s\n", sha1_to_hex(b->branch_tree.versions[0].sha1));
 359         fprintf(rpt, "  cur tree    : %s\n", sha1_to_hex(b->branch_tree.versions[1].sha1));
 360         fprintf(rpt, "  commit clock: %" PRIuMAX "\n", b->last_commit);
 361
 362         fputs("  last pack   : ", rpt);
 363         if (b->pack_id < MAX_PACK_ID)
 364                 fprintf(rpt, "%u", b->pack_id);
 365         fputc('\n', rpt);
 366
 367         fputc('\n', rpt);
 368 }
 369
 370 static void write_crash_report(const char *err)
 371 {
 372         char *loc = git_path("fast_import_crash_%d", getpid());
 373         FILE *rpt = fopen(loc, "w");
 374         struct branch *b;
 375         unsigned long lu;
 376         struct recent_command *rc;
 377
 378         if (!rpt) {
 379                 error("can't write crash report %s: %s", loc, strerror(errno));
 380                 return;
 381         }
 382
 383         fprintf(stderr, "fast-import: dumping crash report to %s\n", loc);
 384
 385         fprintf(rpt, "fast-import crash report:\n");
 386         fprintf(rpt, "    fast-import process: %d\n", getpid());
 387         fprintf(rpt, "    parent process     : %d\n", getppid());
 388         fprintf(rpt, "    at %s\n", show_date(time(NULL), 0, DATE_LOCAL));
 389         fputc('\n', rpt);
 390
 391         fputs("fatal: ", rpt);
 392         fputs(err, rpt);
 393         fputc('\n', rpt);
 394
 395         fputc('\n', rpt);
 396         fputs("Most Recent Commands Before Crash\n", rpt);
 397         fputs("---------------------------------\n", rpt);
 398         for (rc = cmd_hist.next; rc != &cmd_hist; rc = rc->next) {
 399                 if (rc->next == &cmd_hist)
 400                         fputs("* ", rpt);
 401                 else
 402                         fputs("  ", rpt);
 403                 fputs(rc->buf, rpt);
 404                 fputc('\n', rpt);
 405         }
 406
 407         fputc('\n', rpt);
 408         fputs("Active Branch LRU\n", rpt);
 409         fputs("-----------------\n", rpt);
 410         fprintf(rpt, "    active_branches = %lu cur, %lu max\n",
 411                 cur_active_branches,
 412                 max_active_branches);
 413         fputc('\n', rpt);
 414         fputs("  pos  clock name\n", rpt);
 415         fputs("  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n", rpt);
 416         for (b = active_branches, lu = 0; b; b = b->active_next_branch)
 417                 fprintf(rpt, "  %2lu) %6" PRIuMAX" %s\n",
 418                         ++lu, b->last_commit, b->name);
 419
 420         fputc('\n', rpt);
 421         fputs("Inactive Branches\n", rpt);
 422         fputs("-----------------\n", rpt);
 423         for (lu = 0; lu < branch_table_sz; lu++) {
 424                 for (b = branch_table[lu]; b; b = b->table_next_branch)
 425                         write_branch_report(rpt, b);
 426         }
 427
 428         fputc('\n', rpt);
 429         fputs("-------------------\n", rpt);
 430         fputs("END OF CRASH REPORT\n", rpt);
 431         fclose(rpt);
 432 }
 433
 434 static NORETURN void die_nicely(const char *err, va_list params)
 435 {
 436         static int zombie;
 437         char message[2 * PATH_MAX];
 438
 439         vsnprintf(message, sizeof(message), err, params);
 440         fputs("fatal: ", stderr);
 441         fputs(message, stderr);
 442         fputc('\n', stderr);
 443
 444         if (!zombie) {
 445                 zombie = 1;
 446                 write_crash_report(message);
 447         }
 448         exit(128);
 449 }
 450
 451 static void alloc_objects(unsigned int cnt)
 452 {
 453         struct object_entry_pool *b;
 454
 455         b = xmalloc(sizeof(struct object_entry_pool)
 456                 + cnt * sizeof(struct object_entry));
 457         b->next_pool = blocks;
 458         b->next_free = b->entries;
 459         b->end = b->entries + cnt;
 460         blocks = b;
 461         alloc_count += cnt;
 462 }
 463
 464 static struct object_entry *new_object(unsigned char *sha1)
 465 {
 466         struct object_entry *e;
 467
 468         if (blocks->next_free == blocks->end)
 469                 alloc_objects(object_entry_alloc);
 470
 471         e = blocks->next_free++;
 472         hashcpy(e->sha1, sha1);
 473         return e;
 474 }
 475
 476 static struct object_entry *find_object(unsigned char *sha1)
 477 {
 478         unsigned int h = sha1[0] << 8 | sha1[1];
 479         struct object_entry *e;
 480         for (e = object_table[h]; e; e = e->next)
 481                 if (!hashcmp(sha1, e->sha1))
 482                         return e;
 483         return NULL;
 484 }
 485
 486 static struct object_entry *insert_object(unsigned char *sha1)
 487 {
 488         unsigned int h = sha1[0] << 8 | sha1[1];
 489         struct object_entry *e = object_table[h];
 490         struct object_entry *p = NULL;
 491
 492         while (e) {
 493                 if (!hashcmp(sha1, e->sha1))
 494                         return e;
 495                 p = e;
 496                 e = e->next;
 497         }
 498
 499         e = new_object(sha1);
 500         e->next = NULL;
 501         e->offset = 0;
 502         if (p)
 503                 p->next = e;
 504         else
 505                 object_table[h] = e;
 506         return e;
 507 }
 508
 509 static unsigned int hc_str(const char *s, size_t len)
 510 {
 511         unsigned int r = 0;
 512         while (len-- > 0)
 513                 r = r * 31 + *s++;
 514         return r;
 515 }
 516
 517 static void *pool_alloc(size_t len)
 518 {
 519         struct mem_pool *p;
 520         void *r;
 521
 522         for (p = mem_pool; p; p = p->next_pool)
 523                 if ((p->end - p->next_free >= len))
 524                         break;
 525
 526         if (!p) {
 527                 if (len >= (mem_pool_alloc/2)) {
 528                         total_allocd += len;
 529                         return xmalloc(len);
 530                 }
 531                 total_allocd += sizeof(struct mem_pool) + mem_pool_alloc;
 532                 p = xmalloc(sizeof(struct mem_pool) + mem_pool_alloc);
 533                 p->next_pool = mem_pool;
 534                 p->next_free = p->space;
 535                 p->end = p->next_free + mem_pool_alloc;
 536                 mem_pool = p;
 537         }
 538
 539         r = p->next_free;
 540         /* round out to a pointer alignment */
 541         if (len & (sizeof(void*) - 1))
 542                 len += sizeof(void*) - (len & (sizeof(void*) - 1));
 543         p->next_free += len;
 544         return r;
 545 }
 546
 547 static void *pool_calloc(size_t count, size_t size)
 548 {
 549         size_t len = count * size;
 550         void *r = pool_alloc(len);
 551         memset(r, 0, len);
 552         return r;
 553 }
 554
 555 static char *pool_strdup(const char *s)
 556 {
 557         char *r = pool_alloc(strlen(s) + 1);
 558         strcpy(r, s);
 559         return r;
 560 }
 561
 562 static void insert_mark(uintmax_t idnum, struct object_entry *oe)
 563 {
 564         struct mark_set *s = marks;
 565         while ((idnum >> s->shift) >= 1024) {
 566                 s = pool_calloc(1, sizeof(struct mark_set));
 567                 s->shift = marks->shift + 10;
 568                 s->data.sets[0] = marks;
 569                 marks = s;
 570         }
 571         while (s->shift) {
 572                 uintmax_t i = idnum >> s->shift;
 573                 idnum -= i << s->shift;
 574                 if (!s->data.sets[i]) {
 575                         s->data.sets[i] = pool_calloc(1, sizeof(struct mark_set));
 576                         s->data.sets[i]->shift = s->shift - 10;
 577                 }
 578                 s = s->data.sets[i];
 579         }
 580         if (!s->data.marked[idnum])
 581                 marks_set_count++;
 582         s->data.marked[idnum] = oe;
 583 }
 584
 585 static struct object_entry *find_mark(uintmax_t idnum)
 586 {
 587         uintmax_t orig_idnum = idnum;
 588         struct mark_set *s = marks;
 589         struct object_entry *oe = NULL;
 590         if ((idnum >> s->shift) < 1024) {
 591                 while (s && s->shift) {
 592                         uintmax_t i = idnum >> s->shift;
 593                         idnum -= i << s->shift;
 594                         s = s->data.sets[i];
 595                 }
 596                 if (s)
 597                         oe = s->data.marked[idnum];
 598         }
 599         if (!oe)
 600                 die("mark :%" PRIuMAX " not declared", orig_idnum);
 601         return oe;
 602 }
 603
 604 static struct atom_str *to_atom(const char *s, unsigned short len)
 605 {
 606         unsigned int hc = hc_str(s, len) % atom_table_sz;
 607         struct atom_str *c;
 608
 609         for (c = atom_table[hc]; c; c = c->next_atom)
 610                 if (c->str_len == len && !strncmp(s, c->str_dat, len))
 611                         return c;
 612
 613         c = pool_alloc(sizeof(struct atom_str) + len + 1);
 614         c->str_len = len;
 615         strncpy(c->str_dat, s, len);
 616         c->str_dat[len] = 0;
 617         c->next_atom = atom_table[hc];
 618         atom_table[hc] = c;
 619         atom_cnt++;
 620         return c;
 621 }
 622
 623 static struct branch *lookup_branch(const char *name)
 624 {
 625         unsigned int hc = hc_str(name, strlen(name)) % branch_table_sz;
 626         struct branch *b;
 627
 628         for (b = branch_table[hc]; b; b = b->table_next_branch)
 629                 if (!strcmp(name, b->name))
 630                         return b;
 631         return NULL;
 632 }
 633
 634 static struct branch *new_branch(const char *name)
 635 {
 636         unsigned int hc = hc_str(name, strlen(name)) % branch_table_sz;
 637         struct branch* b = lookup_branch(name);
 638
 639         if (b)
 640                 die("Invalid attempt to create duplicate branch: %s", name);
 641         switch (check_ref_format(name)) {
 642         case  0: break; /* its valid */
 643         case -2: break; /* valid, but too few '/', allow anyway */
 644         default:
 645                 die("Branch name doesn't conform to GIT standards: %s", name);
 646         }
 647
 648         b = pool_calloc(1, sizeof(struct branch));
 649         b->name = pool_strdup(name);
 650         b->table_next_branch = branch_table[hc];
 651         b->branch_tree.versions[0].mode = S_IFDIR;
 652         b->branch_tree.versions[1].mode = S_IFDIR;
 653         b->active = 0;
 654         b->pack_id = MAX_PACK_ID;
 655         branch_table[hc] = b;
 656         branch_count++;
 657         return b;
 658 }
 659
 660 static unsigned int hc_entries(unsigned int cnt)
 661 {
 662         cnt = cnt & 7 ? (cnt / 8) + 1 : cnt / 8;
 663         return cnt < avail_tree_table_sz ? cnt : avail_tree_table_sz - 1;
 664 }
 665
 666 static struct tree_content *new_tree_content(unsigned int cnt)
 667 {
 668         struct avail_tree_content *f, *l = NULL;
 669         struct tree_content *t;
 670         unsigned int hc = hc_entries(cnt);
 671
 672         for (f = avail_tree_table[hc]; f; l = f, f = f->next_avail)
 673                 if (f->entry_capacity >= cnt)
 674                         break;
 675
 676         if (f) {
 677                 if (l)
 678                         l->next_avail = f->next_avail;
 679                 else
 680                         avail_tree_table[hc] = f->next_avail;
 681         } else {
 682                 cnt = cnt & 7 ? ((cnt / 8) + 1) * 8 : cnt;
 683                 f = pool_alloc(sizeof(*t) + sizeof(t->entries[0]) * cnt);
 684                 f->entry_capacity = cnt;
 685         }
 686
 687         t = (struct tree_content*)f;
 688         t->entry_count = 0;
 689         t->delta_depth = 0;
 690         return t;
 691 }
 692
 693 static void release_tree_entry(struct tree_entry *e);
 694 static void release_tree_content(struct tree_content *t)
 695 {
 696         struct avail_tree_content *f = (struct avail_tree_content*)t;
 697         unsigned int hc = hc_entries(f->entry_capacity);
 698         f->next_avail = avail_tree_table[hc];
 699         avail_tree_table[hc] = f;
 700 }
 701
 702 static void release_tree_content_recursive(struct tree_content *t)
 703 {
 704         unsigned int i;
 705         for (i = 0; i < t->entry_count; i++)
 706                 release_tree_entry(t->entries[i]);
 707         release_tree_content(t);
 708 }
 709
 710 static struct tree_content *grow_tree_content(
 711         struct tree_content *t,
 712         int amt)
 713 {
 714         struct tree_content *r = new_tree_content(t->entry_count + amt);
 715         r->entry_count = t->entry_count;
 716         r->delta_depth = t->delta_depth;
 717         memcpy(r->entries,t->entries,t->entry_count*sizeof(t->entries[0]));
 718         release_tree_content(t);
 719         return r;
 720 }
 721
 722 static struct tree_entry *new_tree_entry(void)
 723 {
 724         struct tree_entry *e;
 725
 726         if (!avail_tree_entry) {
 727                 unsigned int n = tree_entry_alloc;
 728                 total_allocd += n * sizeof(struct tree_entry);
 729                 avail_tree_entry = e = xmalloc(n * sizeof(struct tree_entry));
 730                 while (n-- > 1) {
 731                         *((void**)e) = e + 1;
 732                         e++;
 733                 }
 734                 *((void**)e) = NULL;
 735         }
 736
 737         e = avail_tree_entry;
 738         avail_tree_entry = *((void**)e);
 739         return e;
 740 }
 741
 742 static void release_tree_entry(struct tree_entry *e)
 743 {
 744         if (e->tree)
 745                 release_tree_content_recursive(e->tree);
 746         *((void**)e) = avail_tree_entry;
 747         avail_tree_entry = e;
 748 }
 749
 750 static struct tree_content *dup_tree_content(struct tree_content *s)
 751 {
 752         struct tree_content *d;
 753         struct tree_entry *a, *b;
 754         unsigned int i;
 755
 756         if (!s)
 757                 return NULL;
 758         d = new_tree_content(s->entry_count);
 759         for (i = 0; i < s->entry_count; i++) {
 760                 a = s->entries[i];
 761                 b = new_tree_entry();
 762                 memcpy(b, a, sizeof(*a));
 763                 if (a->tree && is_null_sha1(b->versions[1].sha1))
 764                         b->tree = dup_tree_content(a->tree);
 765                 else
 766                         b->tree = NULL;
 767                 d->entries[i] = b;
 768         }
 769         d->entry_count = s->entry_count;
 770         d->delta_depth = s->delta_depth;
 771
 772         return d;
 773 }
 774
 775 static void start_packfile(void)
 776 {
 777         static char tmpfile[PATH_MAX];
 778         struct packed_git *p;
 779         struct pack_header hdr;
 780         int pack_fd;
 781
 782         snprintf(tmpfile, sizeof(tmpfile),
 783                 "%s/tmp_pack_XXXXXX", get_object_directory());
 784         pack_fd = xmkstemp(tmpfile);
 785         p = xcalloc(1, sizeof(*p) + strlen(tmpfile) + 2);
 786         strcpy(p->pack_name, tmpfile);
 787         p->pack_fd = pack_fd;
 788
 789         hdr.hdr_signature = htonl(PACK_SIGNATURE);
 790         hdr.hdr_version = htonl(2);
 791         hdr.hdr_entries = 0;
 792         write_or_die(p->pack_fd, &hdr, sizeof(hdr));
 793
 794         pack_data = p;
 795         pack_size = sizeof(hdr);
 796         object_count = 0;
 797
 798         all_packs = xrealloc(all_packs, sizeof(*all_packs) * (pack_id + 1));
 799         all_packs[pack_id] = p;
 800 }
 801
 802 static int oecmp (const void *a_, const void *b_)
 803 {
 804         struct object_entry *a = *((struct object_entry**)a_);
 805         struct object_entry *b = *((struct object_entry**)b_);
 806         return hashcmp(a->sha1, b->sha1);
 807 }
 808
 809 static char *create_index(void)
 810 {
 811         static char tmpfile[PATH_MAX];
 812         SHA_CTX ctx;
 813         struct sha1file *f;
 814         struct object_entry **idx, **c, **last, *e;
 815         struct object_entry_pool *o;
 816         uint32_t array[256];
 817         int i, idx_fd;
 818
 819         /* Build the sorted table of object IDs. */
 820         idx = xmalloc(object_count * sizeof(struct object_entry*));
 821         c = idx;
 822         for (o = blocks; o; o = o->next_pool)
 823                 for (e = o->next_free; e-- != o->entries;)
 824                         if (pack_id == e->pack_id)
 825                                 *c++ = e;
 826         last = idx + object_count;
 827         if (c != last)
 828                 die("internal consistency error creating the index");
 829         qsort(idx, object_count, sizeof(struct object_entry*), oecmp);
 830
 831         /* Generate the fan-out array. */
 832         c = idx;
 833         for (i = 0; i < 256; i++) {
 834                 struct object_entry **next = c;;
 835                 while (next < last) {
 836                         if ((*next)->sha1[0] != i)
 837                                 break;
 838                         next++;
 839                 }
 840                 array[i] = htonl(next - idx);
 841                 c = next;
 842         }
 843
 844         snprintf(tmpfile, sizeof(tmpfile),
 845                 "%s/tmp_idx_XXXXXX", get_object_directory());
 846         idx_fd = xmkstemp(tmpfile);
 847         f = sha1fd(idx_fd, tmpfile);
 848         sha1write(f, array, 256 * sizeof(int));
 849         SHA1_Init(&ctx);
 850         for (c = idx; c != last; c++) {
 851                 uint32_t offset = htonl((*c)->offset);
 852                 sha1write(f, &offset, 4);
 853                 sha1write(f, (*c)->sha1, sizeof((*c)->sha1));
 854                 SHA1_Update(&ctx, (*c)->sha1, 20);
 855         }
 856         sha1write(f, pack_data->sha1, sizeof(pack_data->sha1));
 857         sha1close(f, NULL, 1);
 858         free(idx);
 859         SHA1_Final(pack_data->sha1, &ctx);
 860         return tmpfile;
 861 }
 862
 863 static char *keep_pack(char *curr_index_name)
 864 {
 865         static char name[PATH_MAX];
 866         static const char *keep_msg = "fast-import";
 867         int keep_fd;
 868
 869         chmod(pack_data->pack_name, 0444);
 870         chmod(curr_index_name, 0444);
 871
 872         snprintf(name, sizeof(name), "%s/pack/pack-%s.keep",
 873                  get_object_directory(), sha1_to_hex(pack_data->sha1));
 874         keep_fd = open(name, O_RDWR|O_CREAT|O_EXCL, 0600);
 875         if (keep_fd < 0)
 876                 die("cannot create keep file");
 877         write(keep_fd, keep_msg, strlen(keep_msg));
 878         close(keep_fd);
 879
 880         snprintf(name, sizeof(name), "%s/pack/pack-%s.pack",
 881                  get_object_directory(), sha1_to_hex(pack_data->sha1));
 882         if (move_temp_to_file(pack_data->pack_name, name))
 883                 die("cannot store pack file");
 884
 885         snprintf(name, sizeof(name), "%s/pack/pack-%s.idx",
 886                  get_object_directory(), sha1_to_hex(pack_data->sha1));
 887         if (move_temp_to_file(curr_index_name, name))
 888                 die("cannot store index file");
 889         return name;
 890 }
 891
 892 static void unkeep_all_packs(void)
 893 {
 894         static char name[PATH_MAX];
 895         int k;
 896
 897         for (k = 0; k < pack_id; k++) {
 898                 struct packed_git *p = all_packs[k];
 899                 snprintf(name, sizeof(name), "%s/pack/pack-%s.keep",
 900                          get_object_directory(), sha1_to_hex(p->sha1));
 901                 unlink(name);
 902         }
 903 }
 904
 905 static void end_packfile(void)
 906 {
 907         struct packed_git *old_p = pack_data, *new_p;
 908
 909         if (object_count) {
 910                 char *idx_name;
 911                 int i;
 912                 struct branch *b;
 913                 struct tag *t;
 914
 915                 fixup_pack_header_footer(pack_data->pack_fd, pack_data->sha1,
 916                                     pack_data->pack_name, object_count);
 917                 close(pack_data->pack_fd);
 918                 idx_name = keep_pack(create_index());
 919
 920                 /* Register the packfile with core git's machinary. */
 921                 new_p = add_packed_git(idx_name, strlen(idx_name), 1);
 922                 if (!new_p)
 923                         die("core git rejected index %s", idx_name);
 924                 new_p->windows = old_p->windows;
 925                 all_packs[pack_id] = new_p;
 926                 install_packed_git(new_p);
 927
 928                 /* Print the boundary */
 929                 if (pack_edges) {
 930                         fprintf(pack_edges, "%s:", new_p->pack_name);
 931                         for (i = 0; i < branch_table_sz; i++) {
 932                                 for (b = branch_table[i]; b; b = b->table_next_branch) {
 933                                         if (b->pack_id == pack_id)
 934                                                 fprintf(pack_edges, " %s", sha1_to_hex(b->sha1));
 935                                 }
 936                         }
 937                         for (t = first_tag; t; t = t->next_tag) {
 938                                 if (t->pack_id == pack_id)
 939                                         fprintf(pack_edges, " %s", sha1_to_hex(t->sha1));
 940                         }
 941                         fputc('\n', pack_edges);
 942                         fflush(pack_edges);
 943                 }
 944
 945                 pack_id++;
 946         }
 947         else
 948                 unlink(old_p->pack_name);
 949         free(old_p);
 950
 951         /* We can't carry a delta across packfiles. */
 952         strbuf_release(&last_blob.data);
 953         last_blob.offset = 0;
 954         last_blob.depth = 0;
 955 }
 956
 957 static void cycle_packfile(void)
 958 {
 959         end_packfile();
 960         start_packfile();
 961 }
 962
 963 static size_t encode_header(
 964         enum object_type type,
 965         size_t size,
 966         unsigned char *hdr)
 967 {
 968         int n = 1;
 969         unsigned char c;
 970
 971         if (type < OBJ_COMMIT || type > OBJ_REF_DELTA)
 972                 die("bad type %d", type);
 973
 974         c = (type << 4) | (size & 15);
 975         size >>= 4;
 976         while (size) {
 977                 *hdr++ = c | 0x80;
 978                 c = size & 0x7f;
 979                 size >>= 7;
 980                 n++;
 981         }
 982         *hdr = c;
 983         return n;
 984 }
 985
 986 static int store_object(
 987         enum object_type type,
 988         struct strbuf *dat,
 989         struct last_object *last,
 990         unsigned char *sha1out,
 991         uintmax_t mark)
 992 {
 993         void *out, *delta;
 994         struct object_entry *e;
 995         unsigned char hdr[96];
 996         unsigned char sha1[20];
 997         unsigned long hdrlen, deltalen;
 998         SHA_CTX c;
 999         z_stream s;
1000
1001         hdrlen = sprintf((char*)hdr,"%s %lu", typename(type),
1002                 (unsigned long)dat->len) + 1;
1003         SHA1_Init(&c);
1004         SHA1_Update(&c, hdr, hdrlen);
1005         SHA1_Update(&c, dat->buf, dat->len);
1006         SHA1_Final(sha1, &c);
1007         if (sha1out)
1008                 hashcpy(sha1out, sha1);
1009
1010         e = insert_object(sha1);
1011         if (mark)
1012                 insert_mark(mark, e);
1013         if (e->offset) {
1014                 duplicate_count_by_type[type]++;
1015                 return 1;
1016         } else if (find_sha1_pack(sha1, packed_git)) {
1017                 e->type = type;
1018                 e->pack_id = MAX_PACK_ID;
1019                 e->offset = 1; /* just not zero! */
1020                 duplicate_count_by_type[type]++;
1021                 return 1;
1022         }
1023
1024         if (last && last->data.buf && last->depth < max_depth) {
1025                 delta = diff_delta(last->data.buf, last->data.len,
1026                         dat->buf, dat->len,
1027                         &deltalen, 0);
1028                 if (delta && deltalen >= dat->len) {
1029                         free(delta);
1030                         delta = NULL;
1031                 }
1032         } else
1033                 delta = NULL;
1034
1035         memset(&s, 0, sizeof(s));
1036         deflateInit(&s, zlib_compression_level);
1037         if (delta) {
1038                 s.next_in = delta;
1039                 s.avail_in = deltalen;
1040         } else {
1041                 s.next_in = (void *)dat->buf;
1042                 s.avail_in = dat->len;
1043         }
1044         s.avail_out = deflateBound(&s, s.avail_in);
1045         s.next_out = out = xmalloc(s.avail_out);
1046         while (deflate(&s, Z_FINISH) == Z_OK)
1047                 /* nothing */;
1048         deflateEnd(&s);
1049
1050         /* Determine if we should auto-checkpoint. */
1051         if ((pack_size + 60 + s.total_out) > max_packsize
1052                 || (pack_size + 60 + s.total_out) < pack_size) {
1053
1054                 /* This new object needs to *not* have the current pack_id. */
1055                 e->pack_id = pack_id + 1;
1056                 cycle_packfile();
1057
1058                 /* We cannot carry a delta into the new pack. */
1059                 if (delta) {
1060                         free(delta);
1061                         delta = NULL;
1062
1063                         memset(&s, 0, sizeof(s));
1064                         deflateInit(&s, zlib_compression_level);
1065                         s.next_in = (void *)dat->buf;
1066                         s.avail_in = dat->len;
1067                         s.avail_out = deflateBound(&s, s.avail_in);
1068                         s.next_out = out = xrealloc(out, s.avail_out);
1069                         while (deflate(&s, Z_FINISH) == Z_OK)
1070                                 /* nothing */;
1071                         deflateEnd(&s);
1072                 }
1073         }
1074
1075         e->type = type;
1076         e->pack_id = pack_id;
1077         e->offset = pack_size;
1078         object_count++;
1079         object_count_by_type[type]++;
1080
1081         if (delta) {
1082                 unsigned long ofs = e->offset - last->offset;
1083                 unsigned pos = sizeof(hdr) - 1;
1084
1085                 delta_count_by_type[type]++;
1086                 last->depth++;
1087
1088                 hdrlen = encode_header(OBJ_OFS_DELTA, deltalen, hdr);
1089                 write_or_die(pack_data->pack_fd, hdr, hdrlen);
1090                 pack_size += hdrlen;
1091
1092                 hdr[pos] = ofs & 127;
1093                 while (ofs >>= 7)
1094                         hdr[--pos] = 128 | (--ofs & 127);
1095                 write_or_die(pack_data->pack_fd, hdr + pos, sizeof(hdr) - pos);
1096                 pack_size += sizeof(hdr) - pos;
1097         } else {
1098                 if (last)
1099                         last->depth = 0;
1100                 hdrlen = encode_header(type, dat->len, hdr);
1101                 write_or_die(pack_data->pack_fd, hdr, hdrlen);
1102                 pack_size += hdrlen;
1103         }
1104
1105         write_or_die(pack_data->pack_fd, out, s.total_out);
1106         pack_size += s.total_out;
1107
1108         free(out);
1109         free(delta);
1110         if (last) {
1111                 if (last->no_swap) {
1112                         last->data = *dat;
1113                 } else {
1114                         struct strbuf tmp = *dat;
1115                         *dat = last->data;
1116                         last->data = tmp;
1117                 }
1118                 last->offset = e->offset;
1119         }
1120         return 0;
1121 }
1122
1123 static void *gfi_unpack_entry(
1124         struct object_entry *oe,
1125         unsigned long *sizep)
1126 {
1127         enum object_type type;
1128         struct packed_git *p = all_packs[oe->pack_id];
1129         if (p == pack_data)
1130                 p->pack_size = pack_size + 20;
1131         return unpack_entry(p, oe->offset, &type, sizep);
1132 }
1133
1134 static const char *get_mode(const char *str, uint16_t *modep)
1135 {
1136         unsigned char c;
1137         uint16_t mode = 0;
1138
1139         while ((c = *str++) != ' ') {
1140                 if (c < '0' || c > '7')
1141                         return NULL;
1142                 mode = (mode << 3) + (c - '0');
1143         }
1144         *modep = mode;
1145         return str;
1146 }
1147
1148 static void load_tree(struct tree_entry *root)
1149 {
1150         unsigned char* sha1 = root->versions[1].sha1;
1151         struct object_entry *myoe;
1152         struct tree_content *t;
1153         unsigned long size;
1154         char *buf;
1155         const char *c;
1156
1157         root->tree = t = new_tree_content(8);
1158         if (is_null_sha1(sha1))
1159                 return;
1160
1161         myoe = find_object(sha1);
1162         if (myoe && myoe->pack_id != MAX_PACK_ID) {
1163                 if (myoe->type != OBJ_TREE)
1164                         die("Not a tree: %s", sha1_to_hex(sha1));
1165                 t->delta_depth = 0;
1166                 buf = gfi_unpack_entry(myoe, &size);
1167         } else {
1168                 enum object_type type;
1169                 buf = read_sha1_file(sha1, &type, &size);
1170                 if (!buf || type != OBJ_TREE)
1171                         die("Can't load tree %s", sha1_to_hex(sha1));
1172         }
1173
1174         c = buf;
1175         while (c != (buf + size)) {
1176                 struct tree_entry *e = new_tree_entry();
1177
1178                 if (t->entry_count == t->entry_capacity)
1179                         root->tree = t = grow_tree_content(t, t->entry_count);
1180                 t->entries[t->entry_count++] = e;
1181
1182                 e->tree = NULL;
1183                 c = get_mode(c, &e->versions[1].mode);
1184                 if (!c)
1185                         die("Corrupt mode in %s", sha1_to_hex(sha1));
1186                 e->versions[0].mode = e->versions[1].mode;
1187                 e->name = to_atom(c, strlen(c));
1188                 c += e->name->str_len + 1;
1189                 hashcpy(e->versions[0].sha1, (unsigned char*)c);
1190                 hashcpy(e->versions[1].sha1, (unsigned char*)c);
1191                 c += 20;
1192         }
1193         free(buf);
1194 }
1195
1196 static int tecmp0 (const void *_a, const void *_b)
1197 {
1198         struct tree_entry *a = *((struct tree_entry**)_a);
1199         struct tree_entry *b = *((struct tree_entry**)_b);
1200         return base_name_compare(
1201                 a->name->str_dat, a->name->str_len, a->versions[0].mode,
1202                 b->name->str_dat, b->name->str_len, b->versions[0].mode);
1203 }
1204
1205 static int tecmp1 (const void *_a, const void *_b)
1206 {
1207         struct tree_entry *a = *((struct tree_entry**)_a);
1208         struct tree_entry *b = *((struct tree_entry**)_b);
1209         return base_name_compare(
1210                 a->name->str_dat, a->name->str_len, a->versions[1].mode,
1211                 b->name->str_dat, b->name->str_len, b->versions[1].mode);
1212 }
1213
1214 static void mktree(struct tree_content *t, int v, struct strbuf *b)
1215 {
1216         size_t maxlen = 0;
1217         unsigned int i;
1218
1219         if (!v)
1220                 qsort(t->entries,t->entry_count,sizeof(t->entries[0]),tecmp0);
1221         else
1222                 qsort(t->entries,t->entry_count,sizeof(t->entries[0]),tecmp1);
1223
1224         for (i = 0; i < t->entry_count; i++) {
1225                 if (t->entries[i]->versions[v].mode)
1226                         maxlen += t->entries[i]->name->str_len + 34;
1227         }
1228
1229         strbuf_reset(b);
1230         strbuf_grow(b, maxlen);
1231         for (i = 0; i < t->entry_count; i++) {
1232                 struct tree_entry *e = t->entries[i];
1233                 if (!e->versions[v].mode)
1234                         continue;
1235                 strbuf_addf(b, "%o %s%c", (unsigned int)e->versions[v].mode,
1236                                         e->name->str_dat, '\0');
1237                 strbuf_add(b, e->versions[v].sha1, 20);
1238         }
1239 }
1240
1241 static void store_tree(struct tree_entry *root)
1242 {
1243         struct tree_content *t = root->tree;
1244         unsigned int i, j, del;
1245         struct last_object lo = { STRBUF_INIT, 0, 0, /* no_swap */ 1 };
1246         struct object_entry *le;
1247
1248         if (!is_null_sha1(root->versions[1].sha1))
1249                 return;
1250
1251         for (i = 0; i < t->entry_count; i++) {
1252                 if (t->entries[i]->tree)
1253                         store_tree(t->entries[i]);
1254         }
1255
1256         le = find_object(root->versions[0].sha1);
1257         if (S_ISDIR(root->versions[0].mode) && le && le->pack_id == pack_id) {
1258                 mktree(t, 0, &old_tree);
1259                 lo.data = old_tree;
1260                 lo.offset = le->offset;
1261                 lo.depth = t->delta_depth;
1262         }
1263
1264         mktree(t, 1, &new_tree);
1265         store_object(OBJ_TREE, &new_tree, &lo, root->versions[1].sha1, 0);
1266
1267         t->delta_depth = lo.depth;
1268         for (i = 0, j = 0, del = 0; i < t->entry_count; i++) {
1269                 struct tree_entry *e = t->entries[i];
1270                 if (e->versions[1].mode) {
1271                         e->versions[0].mode = e->versions[1].mode;
1272                         hashcpy(e->versions[0].sha1, e->versions[1].sha1);
1273                         t->entries[j++] = e;
1274                 } else {
1275                         release_tree_entry(e);
1276                         del++;
1277                 }
1278         }
1279         t->entry_count -= del;
1280 }
1281
1282 static int tree_content_set(
1283         struct tree_entry *root,
1284         const char *p,
1285         const unsigned char *sha1,
1286         const uint16_t mode,
1287         struct tree_content *subtree)
1288 {
1289         struct tree_content *t = root->tree;
1290         const char *slash1;
1291         unsigned int i, n;
1292         struct tree_entry *e;
1293
1294         slash1 = strchr(p, '/');
1295         if (slash1)
1296                 n = slash1 - p;
1297         else
1298                 n = strlen(p);
1299         if (!n)
1300                 die("Empty path component found in input");
1301         if (!slash1 && !S_ISDIR(mode) && subtree)
1302                 die("Non-directories cannot have subtrees");
1303
1304         for (i = 0; i < t->entry_count; i++) {
1305                 e = t->entries[i];
1306                 if (e->name->str_len == n && !strncmp(p, e->name->str_dat, n)) {
1307                         if (!slash1) {
1308                                 if (!S_ISDIR(mode)
1309                                                 && e->versions[1].mode == mode
1310                                                 && !hashcmp(e->versions[1].sha1, sha1))
1311                                         return 0;
1312                                 e->versions[1].mode = mode;
1313                                 hashcpy(e->versions[1].sha1, sha1);
1314                                 if (e->tree)
1315                                         release_tree_content_recursive(e->tree);
1316                                 e->tree = subtree;
1317                                 hashclr(root->versions[1].sha1);
1318                                 return 1;
1319                         }
1320                         if (!S_ISDIR(e->versions[1].mode)) {
1321                                 e->tree = new_tree_content(8);
1322                                 e->versions[1].mode = S_IFDIR;
1323                         }
1324                         if (!e->tree)
1325                                 load_tree(e);
1326                         if (tree_content_set(e, slash1 + 1, sha1, mode, subtree)) {
1327                                 hashclr(root->versions[1].sha1);
1328                                 return 1;
1329                         }
1330                         return 0;
1331                 }
1332         }
1333
1334         if (t->entry_count == t->entry_capacity)
1335                 root->tree = t = grow_tree_content(t, t->entry_count);
1336         e = new_tree_entry();
1337         e->name = to_atom(p, n);
1338         e->versions[0].mode = 0;
1339         hashclr(e->versions[0].sha1);
1340         t->entries[t->entry_count++] = e;
1341         if (slash1) {
1342                 e->tree = new_tree_content(8);
1343                 e->versions[1].mode = S_IFDIR;
1344                 tree_content_set(e, slash1 + 1, sha1, mode, subtree);
1345         } else {
1346                 e->tree = subtree;
1347                 e->versions[1].mode = mode;
1348                 hashcpy(e->versions[1].sha1, sha1);
1349         }
1350         hashclr(root->versions[1].sha1);
1351         return 1;
1352 }
1353
1354 static int tree_content_remove(
1355         struct tree_entry *root,
1356         const char *p,
1357         struct tree_entry *backup_leaf)
1358 {
1359         struct tree_content *t = root->tree;
1360         const char *slash1;
1361         unsigned int i, n;
1362         struct tree_entry *e;
1363
1364         slash1 = strchr(p, '/');
1365         if (slash1)
1366                 n = slash1 - p;
1367         else
1368                 n = strlen(p);
1369
1370         for (i = 0; i < t->entry_count; i++) {
1371                 e = t->entries[i];
1372                 if (e->name->str_len == n && !strncmp(p, e->name->str_dat, n)) {
1373                         if (!slash1 || !S_ISDIR(e->versions[1].mode))
1374                                 goto del_entry;
1375                         if (!e->tree)
1376                                 load_tree(e);
1377                         if (tree_content_remove(e, slash1 + 1, backup_leaf)) {
1378                                 for (n = 0; n < e->tree->entry_count; n++) {
1379                                         if (e->tree->entries[n]->versions[1].mode) {
1380                                                 hashclr(root->versions[1].sha1);
1381                                                 return 1;
1382                                         }
1383                                 }
1384                                 backup_leaf = NULL;
1385                                 goto del_entry;
1386                         }
1387                         return 0;
1388                 }
1389         }
1390         return 0;
1391
1392 del_entry:
1393         if (backup_leaf)
1394                 memcpy(backup_leaf, e, sizeof(*backup_leaf));
1395         else if (e->tree)
1396                 release_tree_content_recursive(e->tree);
1397         e->tree = NULL;
1398         e->versions[1].mode = 0;
1399         hashclr(e->versions[1].sha1);
1400         hashclr(root->versions[1].sha1);
1401         return 1;
1402 }
1403
1404 static int tree_content_get(
1405         struct tree_entry *root,
1406         const char *p,
1407         struct tree_entry *leaf)
1408 {
1409         struct tree_content *t = root->tree;
1410         const char *slash1;
1411         unsigned int i, n;
1412         struct tree_entry *e;
1413
1414         slash1 = strchr(p, '/');
1415         if (slash1)
1416                 n = slash1 - p;
1417         else
1418                 n = strlen(p);
1419
1420         for (i = 0; i < t->entry_count; i++) {
1421                 e = t->entries[i];
1422                 if (e->name->str_len == n && !strncmp(p, e->name->str_dat, n)) {
1423                         if (!slash1) {
1424                                 memcpy(leaf, e, sizeof(*leaf));
1425                                 if (e->tree && is_null_sha1(e->versions[1].sha1))
1426                                         leaf->tree = dup_tree_content(e->tree);
1427                                 else
1428                                         leaf->tree = NULL;
1429                                 return 1;
1430                         }
1431                         if (!S_ISDIR(e->versions[1].mode))
1432                                 return 0;
1433                         if (!e->tree)
1434                                 load_tree(e);
1435                         return tree_content_get(e, slash1 + 1, leaf);
1436                 }
1437         }
1438         return 0;
1439 }
1440
1441 static int update_branch(struct branch *b)
1442 {
1443         static const char *msg = "fast-import";
1444         struct ref_lock *lock;
1445         unsigned char old_sha1[20];
1446
1447         if (read_ref(b->name, old_sha1))
1448                 hashclr(old_sha1);
1449         lock = lock_any_ref_for_update(b->name, old_sha1, 0);
1450         if (!lock)
1451                 return error("Unable to lock %s", b->name);
1452         if (!force_update && !is_null_sha1(old_sha1)) {
1453                 struct commit *old_cmit, *new_cmit;
1454
1455                 old_cmit = lookup_commit_reference_gently(old_sha1, 0);
1456                 new_cmit = lookup_commit_reference_gently(b->sha1, 0);
1457                 if (!old_cmit || !new_cmit) {
1458                         unlock_ref(lock);
1459                         return error("Branch %s is missing commits.", b->name);
1460                 }
1461
1462                 if (!in_merge_bases(old_cmit, &new_cmit, 1)) {
1463                         unlock_ref(lock);
1464                         warning("Not updating %s"
1465                                 " (new tip %s does not contain %s)",
1466                                 b->name, sha1_to_hex(b->sha1), sha1_to_hex(old_sha1));
1467                         return -1;
1468                 }
1469         }
1470         if (write_ref_sha1(lock, b->sha1, msg) < 0)
1471                 return error("Unable to update %s", b->name);
1472         return 0;
1473 }
1474
1475 static void dump_branches(void)
1476 {
1477         unsigned int i;
1478         struct branch *b;
1479
1480         for (i = 0; i < branch_table_sz; i++) {
1481                 for (b = branch_table[i]; b; b = b->table_next_branch)
1482                         failure |= update_branch(b);
1483         }
1484 }
1485
1486 static void dump_tags(void)
1487 {
1488         static const char *msg = "fast-import";
1489         struct tag *t;
1490         struct ref_lock *lock;
1491         char ref_name[PATH_MAX];
1492
1493         for (t = first_tag; t; t = t->next_tag) {
1494                 sprintf(ref_name, "tags/%s", t->name);
1495                 lock = lock_ref_sha1(ref_name, NULL);
1496                 if (!lock || write_ref_sha1(lock, t->sha1, msg) < 0)
1497                         failure |= error("Unable to update %s", ref_name);
1498         }
1499 }
1500
1501 static void dump_marks_helper(FILE *f,
1502         uintmax_t base,
1503         struct mark_set *m)
1504 {
1505         uintmax_t k;
1506         if (m->shift) {
1507                 for (k = 0; k < 1024; k++) {
1508                         if (m->data.sets[k])
1509                                 dump_marks_helper(f, (base + k) << m->shift,
1510                                         m->data.sets[k]);
1511                 }
1512         } else {
1513                 for (k = 0; k < 1024; k++) {
1514                         if (m->data.marked[k])
1515                                 fprintf(f, ":%" PRIuMAX " %s\n", base + k,
1516                                         sha1_to_hex(m->data.marked[k]->sha1));
1517                 }
1518         }
1519 }
1520
1521 static void dump_marks(void)
1522 {
1523         static struct lock_file mark_lock;
1524         int mark_fd;
1525         FILE *f;
1526
1527         if (!mark_file)
1528                 return;
1529
1530         mark_fd = hold_lock_file_for_update(&mark_lock, mark_file, 0);
1531         if (mark_fd < 0) {
1532                 failure |= error("Unable to write marks file %s: %s",
1533                         mark_file, strerror(errno));
1534                 return;
1535         }
1536
1537         f = fdopen(mark_fd, "w");
1538         if (!f) {
1539                 rollback_lock_file(&mark_lock);
1540                 failure |= error("Unable to write marks file %s: %s",
1541                         mark_file, strerror(errno));
1542                 return;
1543         }
1544
1545         dump_marks_helper(f, 0, marks);
1546         fclose(f);
1547         if (commit_lock_file(&mark_lock))
1548                 failure |= error("Unable to write marks file %s: %s",
1549                         mark_file, strerror(errno));
1550 }
1551
1552 static int read_next_command(void)
1553 {
1554         static int stdin_eof = 0;
1555
1556         if (stdin_eof) {
1557                 unread_command_buf = 0;
1558                 return EOF;
1559         }
1560
1561         do {
1562                 if (unread_command_buf) {
1563                         unread_command_buf = 0;
1564                 } else {
1565                         struct recent_command *rc;
1566
1567                         strbuf_detach(&command_buf);
1568                         stdin_eof = strbuf_getline(&command_buf, stdin, '\n');
1569                         if (stdin_eof)
1570                                 return EOF;
1571
1572                         rc = rc_free;
1573                         if (rc)
1574                                 rc_free = rc->next;
1575                         else {
1576                                 rc = cmd_hist.next;
1577                                 cmd_hist.next = rc->next;
1578                                 cmd_hist.next->prev = &cmd_hist;
1579                                 free(rc->buf);
1580                         }
1581
1582                         rc->buf = command_buf.buf;
1583                         rc->prev = cmd_tail;
1584                         rc->next = cmd_hist.prev;
1585                         rc->prev->next = rc;
1586                         cmd_tail = rc;
1587                 }
1588         } while (command_buf.buf[0] == '#');
1589
1590         return 0;
1591 }
1592
1593 static void skip_optional_lf(void)
1594 {
1595         int term_char = fgetc(stdin);
1596         if (term_char != '\n' && term_char != EOF)
1597                 ungetc(term_char, stdin);
1598 }
1599
1600 static void cmd_mark(void)
1601 {
1602         if (!prefixcmp(command_buf.buf, "mark :")) {
1603                 next_mark = strtoumax(command_buf.buf + 6, NULL, 10);
1604                 read_next_command();
1605         }
1606         else
1607                 next_mark = 0;
1608 }
1609
1610 static void cmd_data(struct strbuf *sb)
1611 {
1612         strbuf_reset(sb);
1613
1614         if (prefixcmp(command_buf.buf, "data "))
1615                 die("Expected 'data n' command, found: %s", command_buf.buf);
1616
1617         if (!prefixcmp(command_buf.buf + 5, "<<")) {
1618                 char *term = xstrdup(command_buf.buf + 5 + 2);
1619                 size_t term_len = command_buf.len - 5 - 2;
1620
1621                 for (;;) {
1622                         if (strbuf_getline(&command_buf, stdin, '\n') == EOF)
1623                                 die("EOF in data (terminator '%s' not found)", term);
1624                         if (term_len == command_buf.len
1625                                 && !strcmp(term, command_buf.buf))
1626                                 break;
1627                         strbuf_addbuf(sb, &command_buf);
1628                         strbuf_addch(sb, '\n');
1629                 }
1630                 free(term);
1631         }
1632         else {
1633                 size_t n = 0, length;
1634
1635                 length = strtoul(command_buf.buf + 5, NULL, 10);
1636
1637                 while (n < length) {
1638                         size_t s = strbuf_fread(sb, length - n, stdin);
1639                         if (!s && feof(stdin))
1640                                 die("EOF in data (%lu bytes remaining)",
1641                                         (unsigned long)(length - n));
1642                         n += s;
1643                 }
1644         }
1645
1646         skip_optional_lf();
1647 }
1648
1649 static int validate_raw_date(const char *src, char *result, int maxlen)
1650 {
1651         const char *orig_src = src;
1652         char *endp, sign;
1653
1654         strtoul(src, &endp, 10);
1655         if (endp == src || *endp != ' ')
1656                 return -1;
1657
1658         src = endp + 1;
1659         if (*src != '-' && *src != '+')
1660                 return -1;
1661         sign = *src;
1662
1663         strtoul(src + 1, &endp, 10);
1664         if (endp == src || *endp || (endp - orig_src) >= maxlen)
1665                 return -1;
1666
1667         strcpy(result, orig_src);
1668         return 0;
1669 }
1670
1671 static char *parse_ident(const char *buf)
1672 {
1673         const char *gt;
1674         size_t name_len;
1675         char *ident;
1676
1677         gt = strrchr(buf, '>');
1678         if (!gt)
1679                 die("Missing > in ident string: %s", buf);
1680         gt++;
1681         if (*gt != ' ')
1682                 die("Missing space after > in ident string: %s", buf);
1683         gt++;
1684         name_len = gt - buf;
1685         ident = xmalloc(name_len + 24);
1686         strncpy(ident, buf, name_len);
1687
1688         switch (whenspec) {
1689         case WHENSPEC_RAW:
1690                 if (validate_raw_date(gt, ident + name_len, 24) < 0)
1691                         die("Invalid raw date \"%s\" in ident: %s", gt, buf);
1692                 break;
1693         case WHENSPEC_RFC2822:
1694                 if (parse_date(gt, ident + name_len, 24) < 0)
1695                         die("Invalid rfc2822 date \"%s\" in ident: %s", gt, buf);
1696                 break;
1697         case WHENSPEC_NOW:
1698                 if (strcmp("now", gt))
1699                         die("Date in ident must be 'now': %s", buf);
1700                 datestamp(ident + name_len, 24);
1701                 break;
1702         }
1703
1704         return ident;
1705 }
1706
1707 static void cmd_new_blob(void)
1708 {
1709         static struct strbuf buf = STRBUF_INIT;
1710
1711         read_next_command();
1712         cmd_mark();
1713         cmd_data(&buf);
1714         store_object(OBJ_BLOB, &buf, &last_blob, NULL, next_mark);
1715 }
1716
1717 static void unload_one_branch(void)
1718 {
1719         while (cur_active_branches
1720                 && cur_active_branches >= max_active_branches) {
1721                 uintmax_t min_commit = ULONG_MAX;
1722                 struct branch *e, *l = NULL, *p = NULL;
1723
1724                 for (e = active_branches; e; e = e->active_next_branch) {
1725                         if (e->last_commit < min_commit) {
1726                                 p = l;
1727                                 min_commit = e->last_commit;
1728                         }
1729                         l = e;
1730                 }
1731
1732                 if (p) {
1733                         e = p->active_next_branch;
1734                         p->active_next_branch = e->active_next_branch;
1735                 } else {
1736                         e = active_branches;
1737                         active_branches = e->active_next_branch;
1738                 }
1739                 e->active = 0;
1740                 e->active_next_branch = NULL;
1741                 if (e->branch_tree.tree) {
1742                         release_tree_content_recursive(e->branch_tree.tree);
1743                         e->branch_tree.tree = NULL;
1744                 }
1745                 cur_active_branches--;
1746         }
1747 }
1748
1749 static void load_branch(struct branch *b)
1750 {
1751         load_tree(&b->branch_tree);
1752         if (!b->active) {
1753                 b->active = 1;
1754                 b->active_next_branch = active_branches;
1755                 active_branches = b;
1756                 cur_active_branches++;
1757                 branch_load_count++;
1758         }
1759 }
1760
1761 static void file_change_m(struct branch *b)
1762 {
1763         const char *p = command_buf.buf + 2;
1764         char *p_uq;
1765         const char *endp;
1766         struct object_entry *oe = oe;
1767         unsigned char sha1[20];
1768         uint16_t mode, inline_data = 0;
1769
1770         p = get_mode(p, &mode);
1771         if (!p)
1772                 die("Corrupt mode: %s", command_buf.buf);
1773         switch (mode) {
1774         case S_IFREG | 0644:
1775         case S_IFREG | 0755:
1776         case S_IFLNK:
1777         case 0644:
1778         case 0755:
1779                 /* ok */
1780                 break;
1781         default:
1782                 die("Corrupt mode: %s", command_buf.buf);
1783         }
1784
1785         if (*p == ':') {
1786                 char *x;
1787                 oe = find_mark(strtoumax(p + 1, &x, 10));
1788                 hashcpy(sha1, oe->sha1);
1789                 p = x;
1790         } else if (!prefixcmp(p, "inline")) {
1791                 inline_data = 1;
1792                 p += 6;
1793         } else {
1794                 if (get_sha1_hex(p, sha1))
1795                         die("Invalid SHA1: %s", command_buf.buf);
1796                 oe = find_object(sha1);
1797                 p += 40;
1798         }
1799         if (*p++ != ' ')
1800                 die("Missing space after SHA1: %s", command_buf.buf);
1801
1802         p_uq = unquote_c_style(p, &endp);
1803         if (p_uq) {
1804                 if (*endp)
1805                         die("Garbage after path in: %s", command_buf.buf);
1806                 p = p_uq;
1807         }
1808
1809         if (inline_data) {
1810                 static struct strbuf buf = STRBUF_INIT;
1811
1812                 if (!p_uq)
1813                         p = p_uq = xstrdup(p);
1814                 read_next_command();
1815                 cmd_data(&buf);
1816                 store_object(OBJ_BLOB, &buf, &last_blob, sha1, 0);
1817         } else if (oe) {
1818                 if (oe->type != OBJ_BLOB)
1819                         die("Not a blob (actually a %s): %s",
1820                                 command_buf.buf, typename(oe->type));
1821         } else {
1822                 enum object_type type = sha1_object_info(sha1, NULL);
1823                 if (type < 0)
1824                         die("Blob not found: %s", command_buf.buf);
1825                 if (type != OBJ_BLOB)
1826                         die("Not a blob (actually a %s): %s",
1827                             typename(type), command_buf.buf);
1828         }
1829
1830         tree_content_set(&b->branch_tree, p, sha1, S_IFREG | mode, NULL);
1831         free(p_uq);
1832 }
1833
1834 static void file_change_d(struct branch *b)
1835 {
1836         const char *p = command_buf.buf + 2;
1837         char *p_uq;
1838         const char *endp;
1839
1840         p_uq = unquote_c_style(p, &endp);
1841         if (p_uq) {
1842                 if (*endp)
1843                         die("Garbage after path in: %s", command_buf.buf);
1844                 p = p_uq;
1845         }
1846         tree_content_remove(&b->branch_tree, p, NULL);
1847         free(p_uq);
1848 }
1849
1850 static void file_change_cr(struct branch *b, int rename)
1851 {
1852         const char *s, *d;
1853         char *s_uq, *d_uq;
1854         const char *endp;
1855         struct tree_entry leaf;
1856
1857         s = command_buf.buf + 2;
1858         s_uq = unquote_c_style(s, &endp);
1859         if (s_uq) {
1860                 if (*endp != ' ')
1861                         die("Missing space after source: %s", command_buf.buf);
1862         }
1863         else {
1864                 endp = strchr(s, ' ');
1865                 if (!endp)
1866                         die("Missing space after source: %s", command_buf.buf);
1867                 s_uq = xmalloc(endp - s + 1);
1868                 memcpy(s_uq, s, endp - s);
1869                 s_uq[endp - s] = 0;
1870         }
1871         s = s_uq;
1872
1873         endp++;
1874         if (!*endp)
1875                 die("Missing dest: %s", command_buf.buf);
1876
1877         d = endp;
1878         d_uq = unquote_c_style(d, &endp);
1879         if (d_uq) {
1880                 if (*endp)
1881                         die("Garbage after dest in: %s", command_buf.buf);
1882                 d = d_uq;
1883         }
1884
1885         memset(&leaf, 0, sizeof(leaf));
1886         if (rename)
1887                 tree_content_remove(&b->branch_tree, s, &leaf);
1888         else
1889                 tree_content_get(&b->branch_tree, s, &leaf);
1890         if (!leaf.versions[1].mode)
1891                 die("Path %s not in branch", s);
1892         tree_content_set(&b->branch_tree, d,
1893                 leaf.versions[1].sha1,
1894                 leaf.versions[1].mode,
1895                 leaf.tree);
1896
1897         free(s_uq);
1898         free(d_uq);
1899 }
1900
1901 static void file_change_deleteall(struct branch *b)
1902 {
1903         release_tree_content_recursive(b->branch_tree.tree);
1904         hashclr(b->branch_tree.versions[0].sha1);
1905         hashclr(b->branch_tree.versions[1].sha1);
1906         load_tree(&b->branch_tree);
1907 }
1908
1909 static void cmd_from_commit(struct branch *b, char *buf, unsigned long size)
1910 {
1911         if (!buf || size < 46)
1912                 die("Not a valid commit: %s", sha1_to_hex(b->sha1));
1913         if (memcmp("tree ", buf, 5)
1914                 || get_sha1_hex(buf + 5, b->branch_tree.versions[1].sha1))
1915                 die("The commit %s is corrupt", sha1_to_hex(b->sha1));
1916         hashcpy(b->branch_tree.versions[0].sha1,
1917                 b->branch_tree.versions[1].sha1);
1918 }
1919
1920 static void cmd_from_existing(struct branch *b)
1921 {
1922         if (is_null_sha1(b->sha1)) {
1923                 hashclr(b->branch_tree.versions[0].sha1);
1924                 hashclr(b->branch_tree.versions[1].sha1);
1925         } else {
1926                 unsigned long size;
1927                 char *buf;
1928
1929                 buf = read_object_with_reference(b->sha1,
1930                         commit_type, &size, b->sha1);
1931                 cmd_from_commit(b, buf, size);
1932                 free(buf);
1933         }
1934 }
1935
1936 static int cmd_from(struct branch *b)
1937 {
1938         const char *from;
1939         struct branch *s;
1940
1941         if (prefixcmp(command_buf.buf, "from "))
1942                 return 0;
1943
1944         if (b->branch_tree.tree) {
1945                 release_tree_content_recursive(b->branch_tree.tree);
1946                 b->branch_tree.tree = NULL;
1947         }
1948
1949         from = strchr(command_buf.buf, ' ') + 1;
1950         s = lookup_branch(from);
1951         if (b == s)
1952                 die("Can't create a branch from itself: %s", b->name);
1953         else if (s) {
1954                 unsigned char *t = s->branch_tree.versions[1].sha1;
1955                 hashcpy(b->sha1, s->sha1);
1956                 hashcpy(b->branch_tree.versions[0].sha1, t);
1957                 hashcpy(b->branch_tree.versions[1].sha1, t);
1958         } else if (*from == ':') {
1959                 uintmax_t idnum = strtoumax(from + 1, NULL, 10);
1960                 struct object_entry *oe = find_mark(idnum);
1961                 if (oe->type != OBJ_COMMIT)
1962                         die("Mark :%" PRIuMAX " not a commit", idnum);
1963                 hashcpy(b->sha1, oe->sha1);
1964                 if (oe->pack_id != MAX_PACK_ID) {
1965                         unsigned long size;
1966                         char *buf = gfi_unpack_entry(oe, &size);
1967                         cmd_from_commit(b, buf, size);
1968                         free(buf);
1969                 } else
1970                         cmd_from_existing(b);
1971         } else if (!get_sha1(from, b->sha1))
1972                 cmd_from_existing(b);
1973         else
1974                 die("Invalid ref name or SHA1 expression: %s", from);
1975
1976         read_next_command();
1977         return 1;
1978 }
1979
1980 static struct hash_list *cmd_merge(unsigned int *count)
1981 {
1982         struct hash_list *list = NULL, *n, *e = e;
1983         const char *from;
1984         struct branch *s;
1985
1986         *count = 0;
1987         while (!prefixcmp(command_buf.buf, "merge ")) {
1988                 from = strchr(command_buf.buf, ' ') + 1;
1989                 n = xmalloc(sizeof(*n));
1990                 s = lookup_branch(from);
1991                 if (s)
1992                         hashcpy(n->sha1, s->sha1);
1993                 else if (*from == ':') {
1994                         uintmax_t idnum = strtoumax(from + 1, NULL, 10);
1995                         struct object_entry *oe = find_mark(idnum);
1996                         if (oe->type != OBJ_COMMIT)
1997                                 die("Mark :%" PRIuMAX " not a commit", idnum);
1998                         hashcpy(n->sha1, oe->sha1);
1999                 } else if (!get_sha1(from, n->sha1)) {
2000                         unsigned long size;
2001                         char *buf = read_object_with_reference(n->sha1,
2002                                 commit_type, &size, n->sha1);
2003                         if (!buf || size < 46)
2004                                 die("Not a valid commit: %s", from);
2005                         free(buf);
2006                 } else
2007                         die("Invalid ref name or SHA1 expression: %s", from);
2008
2009                 n->next = NULL;
2010                 if (list)
2011                         e->next = n;
2012                 else
2013                         list = n;
2014                 e = n;
2015                 (*count)++;
2016                 read_next_command();
2017         }
2018         return list;
2019 }
2020
2021 static void cmd_new_commit(void)
2022 {
2023         static struct strbuf msg = STRBUF_INIT;
2024         struct branch *b;
2025         char *sp;
2026         char *author = NULL;
2027         char *committer = NULL;
2028         struct hash_list *merge_list = NULL;
2029         unsigned int merge_count;
2030
2031         /* Obtain the branch name from the rest of our command */
2032         sp = strchr(command_buf.buf, ' ') + 1;
2033         b = lookup_branch(sp);
2034         if (!b)
2035                 b = new_branch(sp);
2036
2037         read_next_command();
2038         cmd_mark();
2039         if (!prefixcmp(command_buf.buf, "author ")) {
2040                 author = parse_ident(command_buf.buf + 7);
2041                 read_next_command();
2042         }
2043         if (!prefixcmp(command_buf.buf, "committer ")) {
2044                 committer = parse_ident(command_buf.buf + 10);
2045                 read_next_command();
2046         }
2047         if (!committer)
2048                 die("Expected committer but didn't get one");
2049         cmd_data(&msg);
2050         read_next_command();
2051         cmd_from(b);
2052         merge_list = cmd_merge(&merge_count);
2053
2054         /* ensure the branch is active/loaded */
2055         if (!b->branch_tree.tree || !max_active_branches) {
2056                 unload_one_branch();
2057                 load_branch(b);
2058         }
2059
2060         /* file_change* */
2061         while (command_buf.len > 0) {
2062                 if (!prefixcmp(command_buf.buf, "M "))
2063                         file_change_m(b);
2064                 else if (!prefixcmp(command_buf.buf, "D "))
2065                         file_change_d(b);
2066                 else if (!prefixcmp(command_buf.buf, "R "))
2067                         file_change_cr(b, 1);
2068                 else if (!prefixcmp(command_buf.buf, "C "))
2069                         file_change_cr(b, 0);
2070                 else if (!strcmp("deleteall", command_buf.buf))
2071                         file_change_deleteall(b);
2072                 else {
2073                         unread_command_buf = 1;
2074                         break;
2075                 }
2076                 if (read_next_command() == EOF)
2077                         break;
2078         }
2079
2080         /* build the tree and the commit */
2081         store_tree(&b->branch_tree);
2082         hashcpy(b->branch_tree.versions[0].sha1,
2083                 b->branch_tree.versions[1].sha1);
2084
2085         strbuf_reset(&new_data);
2086         strbuf_addf(&new_data, "tree %s\n",
2087                 sha1_to_hex(b->branch_tree.versions[1].sha1));
2088         if (!is_null_sha1(b->sha1))
2089                 strbuf_addf(&new_data, "parent %s\n", sha1_to_hex(b->sha1));
2090         while (merge_list) {
2091                 struct hash_list *next = merge_list->next;
2092                 strbuf_addf(&new_data, "parent %s\n", sha1_to_hex(merge_list->sha1));
2093                 free(merge_list);
2094                 merge_list = next;
2095         }
2096         strbuf_addf(&new_data,
2097                 "author %s\n"
2098                 "committer %s\n"
2099                 "\n",
2100                 author ? author : committer, committer);
2101         strbuf_addbuf(&new_data, &msg);
2102         free(author);
2103         free(committer);
2104
2105         if (!store_object(OBJ_COMMIT, &new_data, NULL, b->sha1, next_mark))
2106                 b->pack_id = pack_id;
2107         b->last_commit = object_count_by_type[OBJ_COMMIT];
2108 }
2109
2110 static void cmd_new_tag(void)
2111 {
2112         static struct strbuf msg = STRBUF_INIT;
2113         char *sp;
2114         const char *from;
2115         char *tagger;
2116         struct branch *s;
2117         struct tag *t;
2118         uintmax_t from_mark = 0;
2119         unsigned char sha1[20];
2120
2121         /* Obtain the new tag name from the rest of our command */
2122         sp = strchr(command_buf.buf, ' ') + 1;
2123         t = pool_alloc(sizeof(struct tag));
2124         t->next_tag = NULL;
2125         t->name = pool_strdup(sp);
2126         if (last_tag)
2127                 last_tag->next_tag = t;
2128         else
2129                 first_tag = t;
2130         last_tag = t;
2131         read_next_command();
2132
2133         /* from ... */
2134         if (prefixcmp(command_buf.buf, "from "))
2135                 die("Expected from command, got %s", command_buf.buf);
2136         from = strchr(command_buf.buf, ' ') + 1;
2137         s = lookup_branch(from);
2138         if (s) {
2139                 hashcpy(sha1, s->sha1);
2140         } else if (*from == ':') {
2141                 struct object_entry *oe;
2142                 from_mark = strtoumax(from + 1, NULL, 10);
2143                 oe = find_mark(from_mark);
2144                 if (oe->type != OBJ_COMMIT)
2145                         die("Mark :%" PRIuMAX " not a commit", from_mark);
2146                 hashcpy(sha1, oe->sha1);
2147         } else if (!get_sha1(from, sha1)) {
2148                 unsigned long size;
2149                 char *buf;
2150
2151                 buf = read_object_with_reference(sha1,
2152                         commit_type, &size, sha1);
2153                 if (!buf || size < 46)
2154                         die("Not a valid commit: %s", from);
2155                 free(buf);
2156         } else
2157                 die("Invalid ref name or SHA1 expression: %s", from);
2158         read_next_command();
2159
2160         /* tagger ... */
2161         if (prefixcmp(command_buf.buf, "tagger "))
2162                 die("Expected tagger command, got %s", command_buf.buf);
2163         tagger = parse_ident(command_buf.buf + 7);
2164
2165         /* tag payload/message */
2166         read_next_command();
2167         cmd_data(&msg);
2168
2169         /* build the tag object */
2170         strbuf_reset(&new_data);
2171         strbuf_addf(&new_data,
2172                 "object %s\n"
2173                 "type %s\n"
2174                 "tag %s\n"
2175                 "tagger %s\n"
2176                 "\n",
2177                 sha1_to_hex(sha1), commit_type, t->name, tagger);
2178         strbuf_addbuf(&new_data, &msg);
2179         free(tagger);
2180
2181         if (store_object(OBJ_TAG, &new_data, NULL, t->sha1, 0))
2182                 t->pack_id = MAX_PACK_ID;
2183         else
2184                 t->pack_id = pack_id;
2185 }
2186
2187 static void cmd_reset_branch(void)
2188 {
2189         struct branch *b;
2190         char *sp;
2191
2192         /* Obtain the branch name from the rest of our command */
2193         sp = strchr(command_buf.buf, ' ') + 1;
2194         b = lookup_branch(sp);
2195         if (b) {
2196                 hashclr(b->sha1);
2197                 hashclr(b->branch_tree.versions[0].sha1);
2198                 hashclr(b->branch_tree.versions[1].sha1);
2199                 if (b->branch_tree.tree) {
2200                         release_tree_content_recursive(b->branch_tree.tree);
2201                         b->branch_tree.tree = NULL;
2202                 }
2203         }
2204         else
2205                 b = new_branch(sp);
2206         read_next_command();
2207         if (!cmd_from(b) && command_buf.len > 0)
2208                 unread_command_buf = 1;
2209 }
2210
2211 static void cmd_checkpoint(void)
2212 {
2213         if (object_count) {
2214                 cycle_packfile();
2215                 dump_branches();
2216                 dump_tags();
2217                 dump_marks();
2218         }
2219         skip_optional_lf();
2220 }
2221
2222 static void cmd_progress(void)
2223 {
2224         fwrite(command_buf.buf, 1, command_buf.len, stdout);
2225         fputc('\n', stdout);
2226         fflush(stdout);
2227         skip_optional_lf();
2228 }
2229
2230 static void import_marks(const char *input_file)
2231 {
2232         char line[512];
2233         FILE *f = fopen(input_file, "r");
2234         if (!f)
2235                 die("cannot read %s: %s", input_file, strerror(errno));
2236         while (fgets(line, sizeof(line), f)) {
2237                 uintmax_t mark;
2238                 char *end;
2239                 unsigned char sha1[20];
2240                 struct object_entry *e;
2241
2242                 end = strchr(line, '\n');
2243                 if (line[0] != ':' || !end)
2244                         die("corrupt mark line: %s", line);
2245                 *end = 0;
2246                 mark = strtoumax(line + 1, &end, 10);
2247                 if (!mark || end == line + 1
2248                         || *end != ' ' || get_sha1(end + 1, sha1))
2249                         die("corrupt mark line: %s", line);
2250                 e = find_object(sha1);
2251                 if (!e) {
2252                         enum object_type type = sha1_object_info(sha1, NULL);
2253                         if (type < 0)
2254                                 die("object not found: %s", sha1_to_hex(sha1));
2255                         e = insert_object(sha1);
2256                         e->type = type;
2257                         e->pack_id = MAX_PACK_ID;
2258                         e->offset = 1; /* just not zero! */
2259                 }
2260                 insert_mark(mark, e);
2261         }
2262         fclose(f);
2263 }
2264
2265 static const char fast_import_usage[] =
2266 "git-fast-import [--date-format=f] [--max-pack-size=n] [--depth=n] [--active-branches=n] [--export-marks=marks.file]";
2267
2268 int main(int argc, const char **argv)
2269 {
2270         unsigned int i, show_stats = 1;
2271
2272         git_config(git_default_config);
2273         alloc_objects(object_entry_alloc);
2274         strbuf_init(&command_buf, 0);
2275         atom_table = xcalloc(atom_table_sz, sizeof(struct atom_str*));
2276         branch_table = xcalloc(branch_table_sz, sizeof(struct branch*));
2277         avail_tree_table = xcalloc(avail_tree_table_sz, sizeof(struct avail_tree_content*));
2278         marks = pool_calloc(1, sizeof(struct mark_set));
2279
2280         for (i = 1; i < argc; i++) {
2281                 const char *a = argv[i];
2282
2283                 if (*a != '-' || !strcmp(a, "--"))
2284                         break;
2285                 else if (!prefixcmp(a, "--date-format=")) {
2286                         const char *fmt = a + 14;
2287                         if (!strcmp(fmt, "raw"))
2288                                 whenspec = WHENSPEC_RAW;
2289                         else if (!strcmp(fmt, "rfc2822"))
2290                                 whenspec = WHENSPEC_RFC2822;
2291                         else if (!strcmp(fmt, "now"))
2292                                 whenspec = WHENSPEC_NOW;
2293                         else
2294                                 die("unknown --date-format argument %s", fmt);
2295                 }
2296                 else if (!prefixcmp(a, "--max-pack-size="))
2297                         max_packsize = strtoumax(a + 16, NULL, 0) * 1024 * 1024;
2298                 else if (!prefixcmp(a, "--depth="))
2299                         max_depth = strtoul(a + 8, NULL, 0);
2300                 else if (!prefixcmp(a, "--active-branches="))
2301                         max_active_branches = strtoul(a + 18, NULL, 0);
2302                 else if (!prefixcmp(a, "--import-marks="))
2303                         import_marks(a + 15);
2304                 else if (!prefixcmp(a, "--export-marks="))
2305                         mark_file = a + 15;
2306                 else if (!prefixcmp(a, "--export-pack-edges=")) {
2307                         if (pack_edges)
2308                                 fclose(pack_edges);
2309                         pack_edges = fopen(a + 20, "a");
2310                         if (!pack_edges)
2311                                 die("Cannot open %s: %s", a + 20, strerror(errno));
2312                 } else if (!strcmp(a, "--force"))
2313                         force_update = 1;
2314                 else if (!strcmp(a, "--quiet"))
2315                         show_stats = 0;
2316                 else if (!strcmp(a, "--stats"))
2317                         show_stats = 1;
2318                 else
2319                         die("unknown option %s", a);
2320         }
2321         if (i != argc)
2322                 usage(fast_import_usage);
2323
2324         rc_free = pool_alloc(cmd_save * sizeof(*rc_free));
2325         for (i = 0; i < (cmd_save - 1); i++)
2326                 rc_free[i].next = &rc_free[i + 1];
2327         rc_free[cmd_save - 1].next = NULL;
2328
2329         prepare_packed_git();
2330         start_packfile();
2331         set_die_routine(die_nicely);
2332         while (read_next_command() != EOF) {
2333                 if (!strcmp("blob", command_buf.buf))
2334                         cmd_new_blob();
2335                 else if (!prefixcmp(command_buf.buf, "commit "))
2336                         cmd_new_commit();
2337                 else if (!prefixcmp(command_buf.buf, "tag "))
2338                         cmd_new_tag();
2339                 else if (!prefixcmp(command_buf.buf, "reset "))
2340                         cmd_reset_branch();
2341                 else if (!strcmp("checkpoint", command_buf.buf))
2342                         cmd_checkpoint();
2343                 else if (!prefixcmp(command_buf.buf, "progress "))
2344                         cmd_progress();
2345                 else
2346                         die("Unsupported command: %s", command_buf.buf);
2347         }
2348         end_packfile();
2349
2350         dump_branches();
2351         dump_tags();
2352         unkeep_all_packs();
2353         dump_marks();
2354
2355         if (pack_edges)
2356                 fclose(pack_edges);
2357
2358         if (show_stats) {
2359                 uintmax_t total_count = 0, duplicate_count = 0;
2360                 for (i = 0; i < ARRAY_SIZE(object_count_by_type); i++)
2361                         total_count += object_count_by_type[i];
2362                 for (i = 0; i < ARRAY_SIZE(duplicate_count_by_type); i++)
2363                         duplicate_count += duplicate_count_by_type[i];
2364
2365                 fprintf(stderr, "%s statistics:\n", argv[0]);
2366                 fprintf(stderr, "---------------------------------------------------------------------\n");
2367                 fprintf(stderr, "Alloc'd objects: %10" PRIuMAX "\n", alloc_count);
2368                 fprintf(stderr, "Total objects:   %10" PRIuMAX " (%10" PRIuMAX " duplicates                  )\n", total_count, duplicate_count);
2369                 fprintf(stderr, "      blobs  :   %10" PRIuMAX " (%10" PRIuMAX " duplicates %10" PRIuMAX " deltas)\n", object_count_by_type[OBJ_BLOB], duplicate_count_by_type[OBJ_BLOB], delta_count_by_type[OBJ_BLOB]);
2370                 fprintf(stderr, "      trees  :   %10" PRIuMAX " (%10" PRIuMAX " duplicates %10" PRIuMAX " deltas)\n", object_count_by_type[OBJ_TREE], duplicate_count_by_type[OBJ_TREE], delta_count_by_type[OBJ_TREE]);
2371                 fprintf(stderr, "      commits:   %10" PRIuMAX " (%10" PRIuMAX " duplicates %10" PRIuMAX " deltas)\n", object_count_by_type[OBJ_COMMIT], duplicate_count_by_type[OBJ_COMMIT], delta_count_by_type[OBJ_COMMIT]);
2372                 fprintf(stderr, "      tags   :   %10" PRIuMAX " (%10" PRIuMAX " duplicates %10" PRIuMAX " deltas)\n", object_count_by_type[OBJ_TAG], duplicate_count_by_type[OBJ_TAG], delta_count_by_type[OBJ_TAG]);
2373                 fprintf(stderr, "Total branches:  %10lu (%10lu loads     )\n", branch_count, branch_load_count);
2374                 fprintf(stderr, "      marks:     %10" PRIuMAX " (%10" PRIuMAX " unique    )\n", (((uintmax_t)1) << marks->shift) * 1024, marks_set_count);
2375                 fprintf(stderr, "      atoms:     %10u\n", atom_cnt);
2376                 fprintf(stderr, "Memory total:    %10" PRIuMAX " KiB\n", (total_allocd + alloc_count*sizeof(struct object_entry))/1024);
2377                 fprintf(stderr, "       pools:    %10lu KiB\n", (unsigned long)(total_allocd/1024));
2378                 fprintf(stderr, "     objects:    %10" PRIuMAX " KiB\n", (alloc_count*sizeof(struct object_entry))/1024);
2379                 fprintf(stderr, "---------------------------------------------------------------------\n");
2380                 pack_report();
2381                 fprintf(stderr, "---------------------------------------------------------------------\n");
2382                 fprintf(stderr, "\n");
2383         }
2384
2385         return failure ? 1 : 0;
2386 }