builtin/fast-export.c

   1 /*
   2  * "git fast-export" builtin command
   3  *
   4  * Copyright (C) 2007 Johannes E. Schindelin
   5  */
   6 #define USE_THE_REPOSITORY_VARIABLE
   7 #include "builtin.h"
   8 #include "config.h"
   9 #include "gettext.h"
  10 #include "hex.h"
  11 #include "refs.h"
  12 #include "refspec.h"
  13 #include "object-file.h"
  14 #include "object-store-ll.h"
  15 #include "commit.h"
  16 #include "object.h"
  17 #include "tag.h"
  18 #include "diff.h"
  19 #include "diffcore.h"
  20 #include "log-tree.h"
  21 #include "revision.h"
  22 #include "decorate.h"
  23 #include "string-list.h"
  24 #include "utf8.h"
  25 #include "parse-options.h"
  26 #include "quote.h"
  27 #include "remote.h"
  28 #include "blob.h"
  29
  30 static const char *fast_export_usage[] = {
  31         N_("git fast-export [<rev-list-opts>]"),
  32         NULL
  33 };
  34
  35 static int progress;
  36 static enum signed_tag_mode { SIGNED_TAG_ABORT, VERBATIM, WARN, WARN_STRIP, STRIP } signed_tag_mode = SIGNED_TAG_ABORT;
  37 static enum tag_of_filtered_mode { TAG_FILTERING_ABORT, DROP, REWRITE } tag_of_filtered_mode = TAG_FILTERING_ABORT;
  38 static enum reencode_mode { REENCODE_ABORT, REENCODE_YES, REENCODE_NO } reencode_mode = REENCODE_ABORT;
  39 static int fake_missing_tagger;
  40 static int use_done_feature;
  41 static int no_data;
  42 static int full_tree;
  43 static int reference_excluded_commits;
  44 static int show_original_ids;
  45 static int mark_tags;
  46 static struct string_list extra_refs = STRING_LIST_INIT_DUP;
  47 static struct string_list tag_refs = STRING_LIST_INIT_DUP;
  48 static struct refspec refspecs = REFSPEC_INIT_FETCH;
  49 static int anonymize;
  50 static struct hashmap anonymized_seeds;
  51 static struct revision_sources revision_sources;
  52
  53 static int parse_opt_signed_tag_mode(const struct option *opt,
  54                                      const char *arg, int unset)
  55 {
  56         enum signed_tag_mode *val = opt->value;
  57
  58         if (unset || !strcmp(arg, "abort"))
  59                 *val = SIGNED_TAG_ABORT;
  60         else if (!strcmp(arg, "verbatim") || !strcmp(arg, "ignore"))
  61                 *val = VERBATIM;
  62         else if (!strcmp(arg, "warn"))
  63                 *val = WARN;
  64         else if (!strcmp(arg, "warn-strip"))
  65                 *val = WARN_STRIP;
  66         else if (!strcmp(arg, "strip"))
  67                 *val = STRIP;
  68         else
  69                 return error("Unknown signed-tags mode: %s", arg);
  70         return 0;
  71 }
  72
  73 static int parse_opt_tag_of_filtered_mode(const struct option *opt,
  74                                           const char *arg, int unset)
  75 {
  76         enum tag_of_filtered_mode *val = opt->value;
  77
  78         if (unset || !strcmp(arg, "abort"))
  79                 *val = TAG_FILTERING_ABORT;
  80         else if (!strcmp(arg, "drop"))
  81                 *val = DROP;
  82         else if (!strcmp(arg, "rewrite"))
  83                 *val = REWRITE;
  84         else
  85                 return error("Unknown tag-of-filtered mode: %s", arg);
  86         return 0;
  87 }
  88
  89 static int parse_opt_reencode_mode(const struct option *opt,
  90                                    const char *arg, int unset)
  91 {
  92         enum reencode_mode *val = opt->value;
  93
  94         if (unset) {
  95                 *val = REENCODE_ABORT;
  96                 return 0;
  97         }
  98
  99         switch (git_parse_maybe_bool(arg)) {
 100         case 0:
 101                 *val = REENCODE_NO;
 102                 break;
 103         case 1:
 104                 *val = REENCODE_YES;
 105                 break;
 106         default:
 107                 if (!strcasecmp(arg, "abort"))
 108                         *val = REENCODE_ABORT;
 109                 else
 110                         return error("Unknown reencoding mode: %s", arg);
 111         }
 112
 113         return 0;
 114 }
 115
 116 static struct decoration idnums;
 117 static uint32_t last_idnum;
 118 struct anonymized_entry {
 119         struct hashmap_entry hash;
 120         char *anon;
 121         const char orig[FLEX_ARRAY];
 122 };
 123
 124 struct anonymized_entry_key {
 125         struct hashmap_entry hash;
 126         const char *orig;
 127         size_t orig_len;
 128 };
 129
 130 static int anonymized_entry_cmp(const void *cmp_data UNUSED,
 131                                 const struct hashmap_entry *eptr,
 132                                 const struct hashmap_entry *entry_or_key,
 133                                 const void *keydata)
 134 {
 135         const struct anonymized_entry *a, *b;
 136
 137         a = container_of(eptr, const struct anonymized_entry, hash);
 138         if (keydata) {
 139                 const struct anonymized_entry_key *key = keydata;
 140                 int equal = !xstrncmpz(a->orig, key->orig, key->orig_len);
 141                 return !equal;
 142         }
 143
 144         b = container_of(entry_or_key, const struct anonymized_entry, hash);
 145         return strcmp(a->orig, b->orig);
 146 }
 147
 148 static struct anonymized_entry *add_anonymized_entry(struct hashmap *map,
 149                                                      unsigned hash,
 150                                                      const char *orig, size_t len,
 151                                                      char *anon)
 152 {
 153         struct anonymized_entry *ret, *old;
 154
 155         if (!map->cmpfn)
 156                 hashmap_init(map, anonymized_entry_cmp, NULL, 0);
 157
 158         FLEX_ALLOC_MEM(ret, orig, orig, len);
 159         hashmap_entry_init(&ret->hash, hash);
 160         ret->anon = anon;
 161         old = hashmap_put_entry(map, ret, hash);
 162
 163         if (old) {
 164                 free(old->anon);
 165                 free(old);
 166         }
 167
 168         return ret;
 169 }
 170
 171 /*
 172  * Basically keep a cache of X->Y so that we can repeatedly replace
 173  * the same anonymized string with another. The actual generation
 174  * is farmed out to the generate function.
 175  */
 176 static const char *anonymize_str(struct hashmap *map,
 177                                  char *(*generate)(void),
 178                                  const char *orig, size_t len)
 179 {
 180         struct anonymized_entry_key key;
 181         struct anonymized_entry *ret;
 182
 183         hashmap_entry_init(&key.hash, memhash(orig, len));
 184         key.orig = orig;
 185         key.orig_len = len;
 186
 187         /* First check if it's a token the user configured manually... */
 188         ret = hashmap_get_entry(&anonymized_seeds, &key, hash, &key);
 189
 190         /* ...otherwise check if we've already seen it in this context... */
 191         if (!ret)
 192                 ret = hashmap_get_entry(map, &key, hash, &key);
 193
 194         /* ...and finally generate a new mapping if necessary */
 195         if (!ret)
 196                 ret = add_anonymized_entry(map, key.hash.hash,
 197                                            orig, len, generate());
 198
 199         return ret->anon;
 200 }
 201
 202 /*
 203  * We anonymize each component of a path individually,
 204  * so that paths a/b and a/c will share a common root.
 205  * The paths are cached via anonymize_mem so that repeated
 206  * lookups for "a" will yield the same value.
 207  */
 208 static void anonymize_path(struct strbuf *out, const char *path,
 209                            struct hashmap *map,
 210                            char *(*generate)(void))
 211 {
 212         while (*path) {
 213                 const char *end_of_component = strchrnul(path, '/');
 214                 size_t len = end_of_component - path;
 215                 const char *c = anonymize_str(map, generate, path, len);
 216                 strbuf_addstr(out, c);
 217                 path = end_of_component;
 218                 if (*path)
 219                         strbuf_addch(out, *path++);
 220         }
 221 }
 222
 223 static inline void *mark_to_ptr(uint32_t mark)
 224 {
 225         return (void *)(uintptr_t)mark;
 226 }
 227
 228 static inline uint32_t ptr_to_mark(void * mark)
 229 {
 230         return (uint32_t)(uintptr_t)mark;
 231 }
 232
 233 static inline void mark_object(struct object *object, uint32_t mark)
 234 {
 235         add_decoration(&idnums, object, mark_to_ptr(mark));
 236 }
 237
 238 static inline void mark_next_object(struct object *object)
 239 {
 240         mark_object(object, ++last_idnum);
 241 }
 242
 243 static int get_object_mark(struct object *object)
 244 {
 245         void *decoration = lookup_decoration(&idnums, object);
 246         if (!decoration)
 247                 return 0;
 248         return ptr_to_mark(decoration);
 249 }
 250
 251 static struct commit *rewrite_commit(struct commit *p)
 252 {
 253         for (;;) {
 254                 if (p->parents && p->parents->next)
 255                         break;
 256                 if (p->object.flags & UNINTERESTING)
 257                         break;
 258                 if (!(p->object.flags & TREESAME))
 259                         break;
 260                 if (!p->parents)
 261                         return NULL;
 262                 p = p->parents->item;
 263         }
 264         return p;
 265 }
 266
 267 static void show_progress(void)
 268 {
 269         static int counter = 0;
 270         if (!progress)
 271                 return;
 272         if ((++counter % progress) == 0)
 273                 printf("progress %d objects\n", counter);
 274 }
 275
 276 /*
 277  * Ideally we would want some transformation of the blob data here
 278  * that is unreversible, but would still be the same size and have
 279  * the same data relationship to other blobs (so that we get the same
 280  * delta and packing behavior as the original). But the first and last
 281  * requirements there are probably mutually exclusive, so let's take
 282  * the easy way out for now, and just generate arbitrary content.
 283  *
 284  * There's no need to cache this result with anonymize_mem, since
 285  * we already handle blob content caching with marks.
 286  */
 287 static char *anonymize_blob(unsigned long *size)
 288 {
 289         static int counter;
 290         struct strbuf out = STRBUF_INIT;
 291         strbuf_addf(&out, "anonymous blob %d", counter++);
 292         *size = out.len;
 293         return strbuf_detach(&out, NULL);
 294 }
 295
 296 static void export_blob(const struct object_id *oid)
 297 {
 298         unsigned long size;
 299         enum object_type type;
 300         char *buf;
 301         struct object *object;
 302         int eaten;
 303
 304         if (no_data)
 305                 return;
 306
 307         if (is_null_oid(oid))
 308                 return;
 309
 310         object = lookup_object(the_repository, oid);
 311         if (object && object->flags & SHOWN)
 312                 return;
 313
 314         if (anonymize) {
 315                 buf = anonymize_blob(&size);
 316                 object = (struct object *)lookup_blob(the_repository, oid);
 317                 eaten = 0;
 318         } else {
 319                 buf = repo_read_object_file(the_repository, oid, &type, &size);
 320                 if (!buf)
 321                         die("could not read blob %s", oid_to_hex(oid));
 322                 if (check_object_signature(the_repository, oid, buf, size,
 323                                            type) < 0)
 324                         die("oid mismatch in blob %s", oid_to_hex(oid));
 325                 object = parse_object_buffer(the_repository, oid, type,
 326                                              size, buf, &eaten);
 327         }
 328
 329         if (!object)
 330                 die("Could not read blob %s", oid_to_hex(oid));
 331
 332         mark_next_object(object);
 333
 334         printf("blob\nmark :%"PRIu32"\n", last_idnum);
 335         if (show_original_ids)
 336                 printf("original-oid %s\n", oid_to_hex(oid));
 337         printf("data %"PRIuMAX"\n", (uintmax_t)size);
 338         if (size && fwrite(buf, size, 1, stdout) != 1)
 339                 die_errno("could not write blob '%s'", oid_to_hex(oid));
 340         printf("\n");
 341
 342         show_progress();
 343
 344         object->flags |= SHOWN;
 345         if (!eaten)
 346                 free(buf);
 347 }
 348
 349 static int depth_first(const void *a_, const void *b_)
 350 {
 351         const struct diff_filepair *a = *((const struct diff_filepair **)a_);
 352         const struct diff_filepair *b = *((const struct diff_filepair **)b_);
 353         const char *name_a, *name_b;
 354         int len_a, len_b, len;
 355         int cmp;
 356
 357         name_a = a->one ? a->one->path : a->two->path;
 358         name_b = b->one ? b->one->path : b->two->path;
 359
 360         len_a = strlen(name_a);
 361         len_b = strlen(name_b);
 362         len = (len_a < len_b) ? len_a : len_b;
 363
 364         /* strcmp will sort 'd' before 'd/e', we want 'd/e' before 'd' */
 365         cmp = memcmp(name_a, name_b, len);
 366         if (cmp)
 367                 return cmp;
 368         cmp = len_b - len_a;
 369         if (cmp)
 370                 return cmp;
 371         /*
 372          * Move 'R'ename entries last so that all references of the file
 373          * appear in the output before it is renamed (e.g., when a file
 374          * was copied and renamed in the same commit).
 375          */
 376         return (a->status == 'R') - (b->status == 'R');
 377 }
 378
 379 static void print_path_1(const char *path)
 380 {
 381         int need_quote = quote_c_style(path, NULL, NULL, 0);
 382         if (need_quote)
 383                 quote_c_style(path, NULL, stdout, 0);
 384         else if (strchr(path, ' '))
 385                 printf("\"%s\"", path);
 386         else
 387                 printf("%s", path);
 388 }
 389
 390 static char *anonymize_path_component(void)
 391 {
 392         static int counter;
 393         struct strbuf out = STRBUF_INIT;
 394         strbuf_addf(&out, "path%d", counter++);
 395         return strbuf_detach(&out, NULL);
 396 }
 397
 398 static void print_path(const char *path)
 399 {
 400         if (!anonymize)
 401                 print_path_1(path);
 402         else {
 403                 static struct hashmap paths;
 404                 static struct strbuf anon = STRBUF_INIT;
 405
 406                 anonymize_path(&anon, path, &paths, anonymize_path_component);
 407                 print_path_1(anon.buf);
 408                 strbuf_reset(&anon);
 409         }
 410 }
 411
 412 static char *generate_fake_oid(void)
 413 {
 414         static uint32_t counter = 1; /* avoid null oid */
 415         const unsigned hashsz = the_hash_algo->rawsz;
 416         struct object_id oid;
 417         char *hex = xmallocz(GIT_MAX_HEXSZ);
 418
 419         oidclr(&oid, the_repository->hash_algo);
 420         put_be32(oid.hash + hashsz - 4, counter++);
 421         return oid_to_hex_r(hex, &oid);
 422 }
 423
 424 static const char *anonymize_oid(const char *oid_hex)
 425 {
 426         static struct hashmap objs;
 427         size_t len = strlen(oid_hex);
 428         return anonymize_str(&objs, generate_fake_oid, oid_hex, len);
 429 }
 430
 431 static void show_filemodify(struct diff_queue_struct *q,
 432                             struct diff_options *options UNUSED, void *data)
 433 {
 434         int i;
 435         struct string_list *changed = data;
 436
 437         /*
 438          * Handle files below a directory first, in case they are all deleted
 439          * and the directory changes to a file or symlink.
 440          */
 441         QSORT(q->queue, q->nr, depth_first);
 442
 443         for (i = 0; i < q->nr; i++) {
 444                 struct diff_filespec *ospec = q->queue[i]->one;
 445                 struct diff_filespec *spec = q->queue[i]->two;
 446
 447                 switch (q->queue[i]->status) {
 448                 case DIFF_STATUS_DELETED:
 449                         printf("D ");
 450                         print_path(spec->path);
 451                         string_list_insert(changed, spec->path);
 452                         putchar('\n');
 453                         break;
 454
 455                 case DIFF_STATUS_COPIED:
 456                 case DIFF_STATUS_RENAMED:
 457                         /*
 458                          * If a change in the file corresponding to ospec->path
 459                          * has been observed, we cannot trust its contents
 460                          * because the diff is calculated based on the prior
 461                          * contents, not the current contents.  So, declare a
 462                          * copy or rename only if there was no change observed.
 463                          */
 464                         if (!string_list_has_string(changed, ospec->path)) {
 465                                 printf("%c ", q->queue[i]->status);
 466                                 print_path(ospec->path);
 467                                 putchar(' ');
 468                                 print_path(spec->path);
 469                                 string_list_insert(changed, spec->path);
 470                                 putchar('\n');
 471
 472                                 if (oideq(&ospec->oid, &spec->oid) &&
 473                                     ospec->mode == spec->mode)
 474                                         break;
 475                         }
 476                         /* fallthrough */
 477
 478                 case DIFF_STATUS_TYPE_CHANGED:
 479                 case DIFF_STATUS_MODIFIED:
 480                 case DIFF_STATUS_ADDED:
 481                         /*
 482                          * Links refer to objects in another repositories;
 483                          * output the SHA-1 verbatim.
 484                          */
 485                         if (no_data || S_ISGITLINK(spec->mode))
 486                                 printf("M %06o %s ", spec->mode,
 487                                        anonymize ?
 488                                        anonymize_oid(oid_to_hex(&spec->oid)) :
 489                                        oid_to_hex(&spec->oid));
 490                         else {
 491                                 struct object *object = lookup_object(the_repository,
 492                                                                       &spec->oid);
 493                                 printf("M %06o :%d ", spec->mode,
 494                                        get_object_mark(object));
 495                         }
 496                         print_path(spec->path);
 497                         string_list_insert(changed, spec->path);
 498                         putchar('\n');
 499                         break;
 500
 501                 default:
 502                         die("Unexpected comparison status '%c' for %s, %s",
 503                                 q->queue[i]->status,
 504                                 ospec->path ? ospec->path : "none",
 505                                 spec->path ? spec->path : "none");
 506                 }
 507         }
 508 }
 509
 510 static const char *find_encoding(const char *begin, const char *end)
 511 {
 512         const char *needle = "\nencoding ";
 513         char *bol, *eol;
 514
 515         bol = memmem(begin, end ? end - begin : strlen(begin),
 516                      needle, strlen(needle));
 517         if (!bol)
 518                 return NULL;
 519         bol += strlen(needle);
 520         eol = strchrnul(bol, '\n');
 521         *eol = '\0';
 522         return bol;
 523 }
 524
 525 static char *anonymize_ref_component(void)
 526 {
 527         static int counter;
 528         struct strbuf out = STRBUF_INIT;
 529         strbuf_addf(&out, "ref%d", counter++);
 530         return strbuf_detach(&out, NULL);
 531 }
 532
 533 static const char *anonymize_refname(const char *refname)
 534 {
 535         /*
 536          * If any of these prefixes is found, we will leave it intact
 537          * so that tags remain tags and so forth.
 538          */
 539         static const char *prefixes[] = {
 540                 "refs/heads/",
 541                 "refs/tags/",
 542                 "refs/remotes/",
 543                 "refs/"
 544         };
 545         static struct hashmap refs;
 546         static struct strbuf anon = STRBUF_INIT;
 547         int i;
 548
 549         strbuf_reset(&anon);
 550         for (i = 0; i < ARRAY_SIZE(prefixes); i++) {
 551                 if (skip_prefix(refname, prefixes[i], &refname)) {
 552                         strbuf_addstr(&anon, prefixes[i]);
 553                         break;
 554                 }
 555         }
 556
 557         anonymize_path(&anon, refname, &refs, anonymize_ref_component);
 558         return anon.buf;
 559 }
 560
 561 /*
 562  * We do not even bother to cache commit messages, as they are unlikely
 563  * to be repeated verbatim, and it is not that interesting when they are.
 564  */
 565 static char *anonymize_commit_message(void)
 566 {
 567         static int counter;
 568         return xstrfmt("subject %d\n\nbody\n", counter++);
 569 }
 570
 571 static char *anonymize_ident(void)
 572 {
 573         static int counter;
 574         struct strbuf out = STRBUF_INIT;
 575         strbuf_addf(&out, "User %d <user%d@example.com>", counter, counter);
 576         counter++;
 577         return strbuf_detach(&out, NULL);
 578 }
 579
 580 /*
 581  * Our strategy here is to anonymize the names and email addresses,
 582  * but keep timestamps intact, as they influence things like traversal
 583  * order (and by themselves should not be too revealing).
 584  */
 585 static void anonymize_ident_line(const char **beg, const char **end)
 586 {
 587         static struct hashmap idents;
 588         static struct strbuf buffers[] = { STRBUF_INIT, STRBUF_INIT };
 589         static unsigned which_buffer;
 590
 591         struct strbuf *out;
 592         struct ident_split split;
 593         const char *end_of_header;
 594
 595         out = &buffers[which_buffer++];
 596         which_buffer %= ARRAY_SIZE(buffers);
 597         strbuf_reset(out);
 598
 599         /* skip "committer", "author", "tagger", etc */
 600         end_of_header = strchr(*beg, ' ');
 601         if (!end_of_header)
 602                 BUG("malformed line fed to anonymize_ident_line: %.*s",
 603                     (int)(*end - *beg), *beg);
 604         end_of_header++;
 605         strbuf_add(out, *beg, end_of_header - *beg);
 606
 607         if (!split_ident_line(&split, end_of_header, *end - end_of_header) &&
 608             split.date_begin) {
 609                 const char *ident;
 610                 size_t len;
 611
 612                 len = split.mail_end - split.name_begin;
 613                 ident = anonymize_str(&idents, anonymize_ident,
 614                                       split.name_begin, len);
 615                 strbuf_addstr(out, ident);
 616                 strbuf_addch(out, ' ');
 617                 strbuf_add(out, split.date_begin, split.tz_end - split.date_begin);
 618         } else {
 619                 strbuf_addstr(out, "Malformed Ident <malformed@example.com> 0 -0000");
 620         }
 621
 622         *beg = out->buf;
 623         *end = out->buf + out->len;
 624 }
 625
 626 static void handle_commit(struct commit *commit, struct rev_info *rev,
 627                           struct string_list *paths_of_changed_objects)
 628 {
 629         int saved_output_format = rev->diffopt.output_format;
 630         const char *commit_buffer;
 631         const char *author, *author_end, *committer, *committer_end;
 632         const char *encoding, *message;
 633         char *reencoded = NULL;
 634         struct commit_list *p;
 635         const char *refname;
 636         int i;
 637
 638         rev->diffopt.output_format = DIFF_FORMAT_CALLBACK;
 639
 640         parse_commit_or_die(commit);
 641         commit_buffer = repo_get_commit_buffer(the_repository, commit, NULL);
 642         author = strstr(commit_buffer, "\nauthor ");
 643         if (!author)
 644                 die("could not find author in commit %s",
 645                     oid_to_hex(&commit->object.oid));
 646         author++;
 647         author_end = strchrnul(author, '\n');
 648         committer = strstr(author_end, "\ncommitter ");
 649         if (!committer)
 650                 die("could not find committer in commit %s",
 651                     oid_to_hex(&commit->object.oid));
 652         committer++;
 653         committer_end = strchrnul(committer, '\n');
 654         message = strstr(committer_end, "\n\n");
 655         encoding = find_encoding(committer_end, message);
 656         if (message)
 657                 message += 2;
 658
 659         if (commit->parents &&
 660             (get_object_mark(&commit->parents->item->object) != 0 ||
 661              reference_excluded_commits) &&
 662             !full_tree) {
 663                 parse_commit_or_die(commit->parents->item);
 664                 diff_tree_oid(get_commit_tree_oid(commit->parents->item),
 665                               get_commit_tree_oid(commit), "", &rev->diffopt);
 666         }
 667         else
 668                 diff_root_tree_oid(get_commit_tree_oid(commit),
 669                                    "", &rev->diffopt);
 670
 671         /* Export the referenced blobs, and remember the marks. */
 672         for (i = 0; i < diff_queued_diff.nr; i++)
 673                 if (!S_ISGITLINK(diff_queued_diff.queue[i]->two->mode))
 674                         export_blob(&diff_queued_diff.queue[i]->two->oid);
 675
 676         refname = *revision_sources_at(&revision_sources, commit);
 677         /*
 678          * FIXME: string_list_remove() below for each ref is overall
 679          * O(N^2).  Compared to a history walk and diffing trees, this is
 680          * just lost in the noise in practice.  However, theoretically a
 681          * repo may have enough refs for this to become slow.
 682          */
 683         string_list_remove(&extra_refs, refname, 0);
 684         if (anonymize) {
 685                 refname = anonymize_refname(refname);
 686                 anonymize_ident_line(&committer, &committer_end);
 687                 anonymize_ident_line(&author, &author_end);
 688         }
 689
 690         mark_next_object(&commit->object);
 691         if (anonymize) {
 692                 reencoded = anonymize_commit_message();
 693         } else if (encoding) {
 694                 switch(reencode_mode) {
 695                 case REENCODE_YES:
 696                         reencoded = reencode_string(message, "UTF-8", encoding);
 697                         break;
 698                 case REENCODE_NO:
 699                         break;
 700                 case REENCODE_ABORT:
 701                         die("Encountered commit-specific encoding %s in commit "
 702                             "%s; use --reencode=[yes|no] to handle it",
 703                             encoding, oid_to_hex(&commit->object.oid));
 704                 }
 705         }
 706         if (!commit->parents)
 707                 printf("reset %s\n", refname);
 708         printf("commit %s\nmark :%"PRIu32"\n", refname, last_idnum);
 709         if (show_original_ids)
 710                 printf("original-oid %s\n", oid_to_hex(&commit->object.oid));
 711         printf("%.*s\n%.*s\n",
 712                (int)(author_end - author), author,
 713                (int)(committer_end - committer), committer);
 714         if (!reencoded && encoding)
 715                 printf("encoding %s\n", encoding);
 716         printf("data %u\n%s",
 717                (unsigned)(reencoded
 718                           ? strlen(reencoded) : message
 719                           ? strlen(message) : 0),
 720                reencoded ? reencoded : message ? message : "");
 721         free(reencoded);
 722         repo_unuse_commit_buffer(the_repository, commit, commit_buffer);
 723
 724         for (i = 0, p = commit->parents; p; p = p->next) {
 725                 struct object *obj = &p->item->object;
 726                 int mark = get_object_mark(obj);
 727
 728                 if (!mark && !reference_excluded_commits)
 729                         continue;
 730                 if (i == 0)
 731                         printf("from ");
 732                 else
 733                         printf("merge ");
 734                 if (mark)
 735                         printf(":%d\n", mark);
 736                 else
 737                         printf("%s\n",
 738                                anonymize ?
 739                                anonymize_oid(oid_to_hex(&obj->oid)) :
 740                                oid_to_hex(&obj->oid));
 741                 i++;
 742         }
 743
 744         if (full_tree)
 745                 printf("deleteall\n");
 746         log_tree_diff_flush(rev);
 747         string_list_clear(paths_of_changed_objects, 0);
 748         rev->diffopt.output_format = saved_output_format;
 749
 750         printf("\n");
 751
 752         show_progress();
 753 }
 754
 755 static char *anonymize_tag(void)
 756 {
 757         static int counter;
 758         struct strbuf out = STRBUF_INIT;
 759         strbuf_addf(&out, "tag message %d", counter++);
 760         return strbuf_detach(&out, NULL);
 761 }
 762
 763
 764 static void handle_tag(const char *name, struct tag *tag)
 765 {
 766         unsigned long size;
 767         enum object_type type;
 768         char *buf;
 769         const char *tagger, *tagger_end, *message;
 770         size_t message_size = 0;
 771         struct object *tagged;
 772         int tagged_mark;
 773         struct commit *p;
 774
 775         /* Trees have no identifier in fast-export output, thus we have no way
 776          * to output tags of trees, tags of tags of trees, etc.  Simply omit
 777          * such tags.
 778          */
 779         tagged = tag->tagged;
 780         while (tagged->type == OBJ_TAG) {
 781                 tagged = ((struct tag *)tagged)->tagged;
 782         }
 783         if (tagged->type == OBJ_TREE) {
 784                 warning("Omitting tag %s,\nsince tags of trees (or tags of tags of trees, etc.) are not supported.",
 785                         oid_to_hex(&tag->object.oid));
 786                 return;
 787         }
 788
 789         buf = repo_read_object_file(the_repository, &tag->object.oid, &type,
 790                                     &size);
 791         if (!buf)
 792                 die("could not read tag %s", oid_to_hex(&tag->object.oid));
 793         message = memmem(buf, size, "\n\n", 2);
 794         if (message) {
 795                 message += 2;
 796                 message_size = strlen(message);
 797         }
 798         tagger = memmem(buf, message ? message - buf : size, "\ntagger ", 8);
 799         if (!tagger) {
 800                 if (fake_missing_tagger)
 801                         tagger = "tagger Unspecified Tagger "
 802                                 "<unspecified-tagger> 0 +0000";
 803                 else
 804                         tagger = "";
 805                 tagger_end = tagger + strlen(tagger);
 806         } else {
 807                 tagger++;
 808                 tagger_end = strchrnul(tagger, '\n');
 809                 if (anonymize)
 810                         anonymize_ident_line(&tagger, &tagger_end);
 811         }
 812
 813         if (anonymize) {
 814                 name = anonymize_refname(name);
 815                 if (message) {
 816                         static struct hashmap tags;
 817                         message = anonymize_str(&tags, anonymize_tag,
 818                                                 message, message_size);
 819                         message_size = strlen(message);
 820                 }
 821         }
 822
 823         /* handle signed tags */
 824         if (message) {
 825                 const char *signature = strstr(message,
 826                                                "\n-----BEGIN PGP SIGNATURE-----\n");
 827                 if (signature)
 828                         switch(signed_tag_mode) {
 829                         case SIGNED_TAG_ABORT:
 830                                 die("encountered signed tag %s; use "
 831                                     "--signed-tags=<mode> to handle it",
 832                                     oid_to_hex(&tag->object.oid));
 833                         case WARN:
 834                                 warning("exporting signed tag %s",
 835                                         oid_to_hex(&tag->object.oid));
 836                                 /* fallthru */
 837                         case VERBATIM:
 838                                 break;
 839                         case WARN_STRIP:
 840                                 warning("stripping signature from tag %s",
 841                                         oid_to_hex(&tag->object.oid));
 842                                 /* fallthru */
 843                         case STRIP:
 844                                 message_size = signature + 1 - message;
 845                                 break;
 846                         }
 847         }
 848
 849         /* handle tag->tagged having been filtered out due to paths specified */
 850         tagged = tag->tagged;
 851         tagged_mark = get_object_mark(tagged);
 852         if (!tagged_mark) {
 853                 switch(tag_of_filtered_mode) {
 854                 case TAG_FILTERING_ABORT:
 855                         die("tag %s tags unexported object; use "
 856                             "--tag-of-filtered-object=<mode> to handle it",
 857                             oid_to_hex(&tag->object.oid));
 858                 case DROP:
 859                         /* Ignore this tag altogether */
 860                         free(buf);
 861                         return;
 862                 case REWRITE:
 863                         if (tagged->type == OBJ_TAG && !mark_tags) {
 864                                 die(_("Error: Cannot export nested tags unless --mark-tags is specified."));
 865                         } else if (tagged->type == OBJ_COMMIT) {
 866                                 p = rewrite_commit((struct commit *)tagged);
 867                                 if (!p) {
 868                                         printf("reset %s\nfrom %s\n\n",
 869                                                name, oid_to_hex(null_oid()));
 870                                         free(buf);
 871                                         return;
 872                                 }
 873                                 tagged_mark = get_object_mark(&p->object);
 874                         } else {
 875                                 /* tagged->type is either OBJ_BLOB or OBJ_TAG */
 876                                 tagged_mark = get_object_mark(tagged);
 877                         }
 878                 }
 879         }
 880
 881         if (tagged->type == OBJ_TAG) {
 882                 printf("reset %s\nfrom %s\n\n",
 883                        name, oid_to_hex(null_oid()));
 884         }
 885         skip_prefix(name, "refs/tags/", &name);
 886         printf("tag %s\n", name);
 887         if (mark_tags) {
 888                 mark_next_object(&tag->object);
 889                 printf("mark :%"PRIu32"\n", last_idnum);
 890         }
 891         if (tagged_mark)
 892                 printf("from :%d\n", tagged_mark);
 893         else
 894                 printf("from %s\n", oid_to_hex(&tagged->oid));
 895
 896         if (show_original_ids)
 897                 printf("original-oid %s\n", oid_to_hex(&tag->object.oid));
 898         printf("%.*s%sdata %d\n%.*s\n",
 899                (int)(tagger_end - tagger), tagger,
 900                tagger == tagger_end ? "" : "\n",
 901                (int)message_size, (int)message_size, message ? message : "");
 902         free(buf);
 903 }
 904
 905 static struct commit *get_commit(struct rev_cmdline_entry *e, const char *full_name)
 906 {
 907         switch (e->item->type) {
 908         case OBJ_COMMIT:
 909                 return (struct commit *)e->item;
 910         case OBJ_TAG: {
 911                 struct tag *tag = (struct tag *)e->item;
 912
 913                 /* handle nested tags */
 914                 while (tag && tag->object.type == OBJ_TAG) {
 915                         parse_object(the_repository, &tag->object.oid);
 916                         string_list_append(&tag_refs, full_name)->util = tag;
 917                         tag = (struct tag *)tag->tagged;
 918                 }
 919                 if (!tag)
 920                         die("Tag %s points nowhere?", e->name);
 921                 return (struct commit *)tag;
 922         }
 923         default:
 924                 return NULL;
 925         }
 926 }
 927
 928 static void get_tags_and_duplicates(struct rev_cmdline_info *info)
 929 {
 930         int i;
 931
 932         for (i = 0; i < info->nr; i++) {
 933                 struct rev_cmdline_entry *e = info->rev + i;
 934                 struct object_id oid;
 935                 struct commit *commit;
 936                 char *full_name = NULL;
 937
 938                 if (e->flags & UNINTERESTING)
 939                         continue;
 940
 941                 if (repo_dwim_ref(the_repository, e->name, strlen(e->name),
 942                                   &oid, &full_name, 0) != 1) {
 943                         free(full_name);
 944                         continue;
 945                 }
 946
 947                 if (refspecs.nr) {
 948                         char *private;
 949                         private = apply_refspecs(&refspecs, full_name);
 950                         if (private) {
 951                                 free(full_name);
 952                                 full_name = private;
 953                         }
 954                 }
 955
 956                 commit = get_commit(e, full_name);
 957                 if (!commit) {
 958                         warning("%s: Unexpected object of type %s, skipping.",
 959                                 e->name,
 960                                 type_name(e->item->type));
 961                         free(full_name);
 962                         continue;
 963                 }
 964
 965                 switch(commit->object.type) {
 966                 case OBJ_COMMIT:
 967                         break;
 968                 case OBJ_BLOB:
 969                         export_blob(&commit->object.oid);
 970                         free(full_name);
 971                         continue;
 972                 default: /* OBJ_TAG (nested tags) is already handled */
 973                         warning("Tag points to object of unexpected type %s, skipping.",
 974                                 type_name(commit->object.type));
 975                         free(full_name);
 976                         continue;
 977                 }
 978
 979                 /*
 980                  * Make sure this ref gets properly updated eventually, whether
 981                  * through a commit or manually at the end.
 982                  */
 983                 if (e->item->type != OBJ_TAG)
 984                         string_list_append(&extra_refs, full_name)->util = commit;
 985
 986                 if (!*revision_sources_at(&revision_sources, commit))
 987                         *revision_sources_at(&revision_sources, commit) = full_name;
 988                 else
 989                         free(full_name);
 990         }
 991
 992         string_list_sort(&extra_refs);
 993         string_list_remove_duplicates(&extra_refs, 0);
 994 }
 995
 996 static void handle_tags_and_duplicates(struct string_list *extras)
 997 {
 998         struct commit *commit;
 999         int i;
1000
1001         for (i = extras->nr - 1; i >= 0; i--) {
1002                 const char *name = extras->items[i].string;
1003                 struct object *object = extras->items[i].util;
1004                 int mark;
1005
1006                 switch (object->type) {
1007                 case OBJ_TAG:
1008                         handle_tag(name, (struct tag *)object);
1009                         break;
1010                 case OBJ_COMMIT:
1011                         if (anonymize)
1012                                 name = anonymize_refname(name);
1013                         /* create refs pointing to already seen commits */
1014                         commit = rewrite_commit((struct commit *)object);
1015                         if (!commit) {
1016                                 /*
1017                                  * Neither this object nor any of its
1018                                  * ancestors touch any relevant paths, so
1019                                  * it has been filtered to nothing.  Delete
1020                                  * it.
1021                                  */
1022                                 printf("reset %s\nfrom %s\n\n",
1023                                        name, oid_to_hex(null_oid()));
1024                                 continue;
1025                         }
1026
1027                         mark = get_object_mark(&commit->object);
1028                         if (!mark) {
1029                                 /*
1030                                  * Getting here means we have a commit which
1031                                  * was excluded by a negative refspec (e.g.
1032                                  * fast-export ^HEAD HEAD).  If we are
1033                                  * referencing excluded commits, set the ref
1034                                  * to the exact commit.  Otherwise, the user
1035                                  * wants the branch exported but every commit
1036                                  * in its history to be deleted, which basically
1037                                  * just means deletion of the ref.
1038                                  */
1039                                 if (!reference_excluded_commits) {
1040                                         /* delete the ref */
1041                                         printf("reset %s\nfrom %s\n\n",
1042                                                name, oid_to_hex(null_oid()));
1043                                         continue;
1044                                 }
1045                                 /* set ref to commit using oid, not mark */
1046                                 printf("reset %s\nfrom %s\n\n", name,
1047                                        oid_to_hex(&commit->object.oid));
1048                                 continue;
1049                         }
1050
1051                         printf("reset %s\nfrom :%d\n\n", name, mark
1052                                );
1053                         show_progress();
1054                         break;
1055                 }
1056         }
1057 }
1058
1059 static void export_marks(char *file)
1060 {
1061         unsigned int i;
1062         uint32_t mark;
1063         struct decoration_entry *deco = idnums.entries;
1064         FILE *f;
1065         int e = 0;
1066
1067         f = fopen_for_writing(file);
1068         if (!f)
1069                 die_errno("Unable to open marks file %s for writing.", file);
1070
1071         for (i = 0; i < idnums.size; i++) {
1072                 if (deco->base && deco->base->type == 1) {
1073                         mark = ptr_to_mark(deco->decoration);
1074                         if (fprintf(f, ":%"PRIu32" %s\n", mark,
1075                                 oid_to_hex(&deco->base->oid)) < 0) {
1076                             e = 1;
1077                             break;
1078                         }
1079                 }
1080                 deco++;
1081         }
1082
1083         e |= ferror(f);
1084         e |= fclose(f);
1085         if (e)
1086                 error("Unable to write marks file %s.", file);
1087 }
1088
1089 static void import_marks(char *input_file, int check_exists)
1090 {
1091         char line[512];
1092         FILE *f;
1093         struct stat sb;
1094
1095         if (check_exists && stat(input_file, &sb))
1096                 return;
1097
1098         f = xfopen(input_file, "r");
1099         while (fgets(line, sizeof(line), f)) {
1100                 uint32_t mark;
1101                 char *line_end, *mark_end;
1102                 struct object_id oid;
1103                 struct object *object;
1104                 struct commit *commit;
1105                 enum object_type type;
1106
1107                 line_end = strchr(line, '\n');
1108                 if (line[0] != ':' || !line_end)
1109                         die("corrupt mark line: %s", line);
1110                 *line_end = '\0';
1111
1112                 mark = strtoumax(line + 1, &mark_end, 10);
1113                 if (!mark || mark_end == line + 1
1114                         || *mark_end != ' ' || get_oid_hex(mark_end + 1, &oid))
1115                         die("corrupt mark line: %s", line);
1116
1117                 if (last_idnum < mark)
1118                         last_idnum = mark;
1119
1120                 type = oid_object_info(the_repository, &oid, NULL);
1121                 if (type < 0)
1122                         die("object not found: %s", oid_to_hex(&oid));
1123
1124                 if (type != OBJ_COMMIT)
1125                         /* only commits */
1126                         continue;
1127
1128                 commit = lookup_commit(the_repository, &oid);
1129                 if (!commit)
1130                         die("not a commit? can't happen: %s", oid_to_hex(&oid));
1131
1132                 object = &commit->object;
1133
1134                 if (object->flags & SHOWN)
1135                         error("Object %s already has a mark", oid_to_hex(&oid));
1136
1137                 mark_object(object, mark);
1138
1139                 object->flags |= SHOWN;
1140         }
1141         fclose(f);
1142 }
1143
1144 static void handle_deletes(void)
1145 {
1146         int i;
1147         for (i = 0; i < refspecs.nr; i++) {
1148                 struct refspec_item *refspec = &refspecs.items[i];
1149                 if (*refspec->src)
1150                         continue;
1151
1152                 printf("reset %s\nfrom %s\n\n",
1153                                 refspec->dst, oid_to_hex(null_oid()));
1154         }
1155 }
1156
1157 static int parse_opt_anonymize_map(const struct option *opt,
1158                                    const char *arg, int unset)
1159 {
1160         struct hashmap *map = opt->value;
1161         const char *delim, *value;
1162         size_t keylen;
1163
1164         BUG_ON_OPT_NEG(unset);
1165
1166         delim = strchr(arg, ':');
1167         if (delim) {
1168                 keylen = delim - arg;
1169                 value = delim + 1;
1170         } else {
1171                 keylen = strlen(arg);
1172                 value = arg;
1173         }
1174
1175         if (!keylen || !*value)
1176                 return error(_("--anonymize-map token cannot be empty"));
1177
1178         add_anonymized_entry(map, memhash(arg, keylen), arg, keylen,
1179                              xstrdup(value));
1180
1181         return 0;
1182 }
1183
1184 int cmd_fast_export(int argc,
1185                     const char **argv,
1186                     const char *prefix,
1187                     struct repository *repo UNUSED)
1188 {
1189         struct rev_info revs;
1190         struct commit *commit;
1191         char *export_filename = NULL,
1192              *import_filename = NULL,
1193              *import_filename_if_exists = NULL;
1194         uint32_t lastimportid;
1195         struct string_list refspecs_list = STRING_LIST_INIT_NODUP;
1196         struct string_list paths_of_changed_objects = STRING_LIST_INIT_DUP;
1197         struct option options[] = {
1198                 OPT_INTEGER(0, "progress", &progress,
1199                             N_("show progress after <n> objects")),
1200                 OPT_CALLBACK(0, "signed-tags", &signed_tag_mode, N_("mode"),
1201                              N_("select handling of signed tags"),
1202                              parse_opt_signed_tag_mode),
1203                 OPT_CALLBACK(0, "tag-of-filtered-object", &tag_of_filtered_mode, N_("mode"),
1204                              N_("select handling of tags that tag filtered objects"),
1205                              parse_opt_tag_of_filtered_mode),
1206                 OPT_CALLBACK(0, "reencode", &reencode_mode, N_("mode"),
1207                              N_("select handling of commit messages in an alternate encoding"),
1208                              parse_opt_reencode_mode),
1209                 OPT_STRING(0, "export-marks", &export_filename, N_("file"),
1210                              N_("dump marks to this file")),
1211                 OPT_STRING(0, "import-marks", &import_filename, N_("file"),
1212                              N_("import marks from this file")),
1213                 OPT_STRING(0, "import-marks-if-exists",
1214                              &import_filename_if_exists,
1215                              N_("file"),
1216                              N_("import marks from this file if it exists")),
1217                 OPT_BOOL(0, "fake-missing-tagger", &fake_missing_tagger,
1218                          N_("fake a tagger when tags lack one")),
1219                 OPT_BOOL(0, "full-tree", &full_tree,
1220                          N_("output full tree for each commit")),
1221                 OPT_BOOL(0, "use-done-feature", &use_done_feature,
1222                              N_("use the done feature to terminate the stream")),
1223                 OPT_BOOL(0, "no-data", &no_data, N_("skip output of blob data")),
1224                 OPT_STRING_LIST(0, "refspec", &refspecs_list, N_("refspec"),
1225                              N_("apply refspec to exported refs")),
1226                 OPT_BOOL(0, "anonymize", &anonymize, N_("anonymize output")),
1227                 OPT_CALLBACK_F(0, "anonymize-map", &anonymized_seeds, N_("from:to"),
1228                                N_("convert <from> to <to> in anonymized output"),
1229                                PARSE_OPT_NONEG, parse_opt_anonymize_map),
1230                 OPT_BOOL(0, "reference-excluded-parents",
1231                          &reference_excluded_commits, N_("reference parents which are not in fast-export stream by object id")),
1232                 OPT_BOOL(0, "show-original-ids", &show_original_ids,
1233                             N_("show original object ids of blobs/commits")),
1234                 OPT_BOOL(0, "mark-tags", &mark_tags,
1235                             N_("label tags with mark ids")),
1236
1237                 OPT_END()
1238         };
1239
1240         if (argc == 1)
1241                 usage_with_options (fast_export_usage, options);
1242
1243         /* we handle encodings */
1244         git_config(git_default_config, NULL);
1245
1246         repo_init_revisions(the_repository, &revs, prefix);
1247         init_revision_sources(&revision_sources);
1248         revs.topo_order = 1;
1249         revs.sources = &revision_sources;
1250         revs.rewrite_parents = 1;
1251         argc = parse_options(argc, argv, prefix, options, fast_export_usage,
1252                         PARSE_OPT_KEEP_ARGV0 | PARSE_OPT_KEEP_UNKNOWN_OPT);
1253         argc = setup_revisions(argc, argv, &revs, NULL);
1254         if (argc > 1)
1255                 usage_with_options (fast_export_usage, options);
1256
1257         if (anonymized_seeds.cmpfn && !anonymize)
1258                 die(_("the option '%s' requires '%s'"), "--anonymize-map", "--anonymize");
1259
1260         if (refspecs_list.nr) {
1261                 int i;
1262
1263                 for (i = 0; i < refspecs_list.nr; i++)
1264                         refspec_append(&refspecs, refspecs_list.items[i].string);
1265
1266                 string_list_clear(&refspecs_list, 1);
1267         }
1268
1269         if (use_done_feature)
1270                 printf("feature done\n");
1271
1272         if (import_filename && import_filename_if_exists)
1273                 die(_("options '%s' and '%s' cannot be used together"), "--import-marks", "--import-marks-if-exists");
1274         if (import_filename)
1275                 import_marks(import_filename, 0);
1276         else if (import_filename_if_exists)
1277                 import_marks(import_filename_if_exists, 1);
1278         lastimportid = last_idnum;
1279
1280         if (import_filename && revs.prune_data.nr)
1281                 full_tree = 1;
1282
1283         get_tags_and_duplicates(&revs.cmdline);
1284
1285         if (prepare_revision_walk(&revs))
1286                 die("revision walk setup failed");
1287
1288         revs.reverse = 1;
1289         revs.diffopt.format_callback = show_filemodify;
1290         revs.diffopt.format_callback_data = &paths_of_changed_objects;
1291         revs.diffopt.flags.recursive = 1;
1292
1293         revs.diffopt.no_free = 1;
1294         while ((commit = get_revision(&revs)))
1295                 handle_commit(commit, &revs, &paths_of_changed_objects);
1296         revs.diffopt.no_free = 0;
1297
1298         handle_tags_and_duplicates(&extra_refs);
1299         handle_tags_and_duplicates(&tag_refs);
1300         handle_deletes();
1301
1302         if (export_filename && lastimportid != last_idnum)
1303                 export_marks(export_filename);
1304
1305         if (use_done_feature)
1306                 printf("done\n");
1307
1308         refspec_clear(&refspecs);
1309         release_revisions(&revs);
1310
1311         return 0;
1312 }