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