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