git.oblomov.eu Git - git/blob - builtin-fetch-pack.c

   1 #include "cache.h"
   2 #include "refs.h"
   3 #include "pkt-line.h"
   4 #include "commit.h"
   5 #include "tag.h"
   6 #include "exec_cmd.h"
   7 #include "pack.h"
   8 #include "sideband.h"
   9 #include "fetch-pack.h"
  10
  11 static int transfer_unpack_limit = -1;
  12 static int fetch_unpack_limit = -1;
  13 static int unpack_limit = 100;
  14 static struct fetch_pack_args args = {
  15         /* .uploadpack = */ "git-upload-pack",
  16 };
  17
  18 static const char fetch_pack_usage[] =
  19 "git-fetch-pack [--all] [--quiet|-q] [--keep|-k] [--thin] [--upload-pack=<git-upload-pack>] [--depth=<n>] [--no-progress] [-v] [<host>:]<directory> [<refs>...]";
  20
  21 #define COMPLETE        (1U << 0)
  22 #define COMMON          (1U << 1)
  23 #define COMMON_REF      (1U << 2)
  24 #define SEEN            (1U << 3)
  25 #define POPPED          (1U << 4)
  26
  27 /*
  28  * After sending this many "have"s if we do not get any new ACK , we
  29  * give up traversing our history.
  30  */
  31 #define MAX_IN_VAIN 256
  32
  33 static struct commit_list *rev_list;
  34 static int non_common_revs, multi_ack, use_thin_pack, use_sideband;
  35
  36 static void rev_list_push(struct commit *commit, int mark)
  37 {
  38         if (!(commit->object.flags & mark)) {
  39                 commit->object.flags |= mark;
  40
  41                 if (!(commit->object.parsed))
  42                         parse_commit(commit);
  43
  44                 insert_by_date(commit, &rev_list);
  45
  46                 if (!(commit->object.flags & COMMON))
  47                         non_common_revs++;
  48         }
  49 }
  50
  51 static int rev_list_insert_ref(const char *path, const unsigned char *sha1, int flag, void *cb_data)
  52 {
  53         struct object *o = deref_tag(parse_object(sha1), path, 0);
  54
  55         if (o && o->type == OBJ_COMMIT)
  56                 rev_list_push((struct commit *)o, SEEN);
  57
  58         return 0;
  59 }
  60
  61 /*
  62    This function marks a rev and its ancestors as common.
  63    In some cases, it is desirable to mark only the ancestors (for example
  64    when only the server does not yet know that they are common).
  65 */
  66
  67 static void mark_common(struct commit *commit,
  68                 int ancestors_only, int dont_parse)
  69 {
  70         if (commit != NULL && !(commit->object.flags & COMMON)) {
  71                 struct object *o = (struct object *)commit;
  72
  73                 if (!ancestors_only)
  74                         o->flags |= COMMON;
  75
  76                 if (!(o->flags & SEEN))
  77                         rev_list_push(commit, SEEN);
  78                 else {
  79                         struct commit_list *parents;
  80
  81                         if (!ancestors_only && !(o->flags & POPPED))
  82                                 non_common_revs--;
  83                         if (!o->parsed && !dont_parse)
  84                                 parse_commit(commit);
  85
  86                         for (parents = commit->parents;
  87                                         parents;
  88                                         parents = parents->next)
  89                                 mark_common(parents->item, 0, dont_parse);
  90                 }
  91         }
  92 }
  93
  94 /*
  95   Get the next rev to send, ignoring the common.
  96 */
  97
  98 static const unsigned char* get_rev(void)
  99 {
 100         struct commit *commit = NULL;
 101
 102         while (commit == NULL) {
 103                 unsigned int mark;
 104                 struct commit_list* parents;
 105
 106                 if (rev_list == NULL || non_common_revs == 0)
 107                         return NULL;
 108
 109                 commit = rev_list->item;
 110                 if (!(commit->object.parsed))
 111                         parse_commit(commit);
 112                 commit->object.flags |= POPPED;
 113                 if (!(commit->object.flags & COMMON))
 114                         non_common_revs--;
 115
 116                 parents = commit->parents;
 117
 118                 if (commit->object.flags & COMMON) {
 119                         /* do not send "have", and ignore ancestors */
 120                         commit = NULL;
 121                         mark = COMMON | SEEN;
 122                 } else if (commit->object.flags & COMMON_REF)
 123                         /* send "have", and ignore ancestors */
 124                         mark = COMMON | SEEN;
 125                 else
 126                         /* send "have", also for its ancestors */
 127                         mark = SEEN;
 128
 129                 while (parents) {
 130                         if (!(parents->item->object.flags & SEEN))
 131                                 rev_list_push(parents->item, mark);
 132                         if (mark & COMMON)
 133                                 mark_common(parents->item, 1, 0);
 134                         parents = parents->next;
 135                 }
 136
 137                 rev_list = rev_list->next;
 138         }
 139
 140         return commit->object.sha1;
 141 }
 142
 143 static int find_common(int fd[2], unsigned char *result_sha1,
 144                        struct ref *refs)
 145 {
 146         int fetching;
 147         int count = 0, flushes = 0, retval;
 148         const unsigned char *sha1;
 149         unsigned in_vain = 0;
 150         int got_continue = 0;
 151
 152         for_each_ref(rev_list_insert_ref, NULL);
 153
 154         fetching = 0;
 155         for ( ; refs ; refs = refs->next) {
 156                 unsigned char *remote = refs->old_sha1;
 157                 struct object *o;
 158
 159                 /*
 160                  * If that object is complete (i.e. it is an ancestor of a
 161                  * local ref), we tell them we have it but do not have to
 162                  * tell them about its ancestors, which they already know
 163                  * about.
 164                  *
 165                  * We use lookup_object here because we are only
 166                  * interested in the case we *know* the object is
 167                  * reachable and we have already scanned it.
 168                  */
 169                 if (((o = lookup_object(remote)) != NULL) &&
 170                                 (o->flags & COMPLETE)) {
 171                         continue;
 172                 }
 173
 174                 if (!fetching)
 175                         packet_write(fd[1], "want %s%s%s%s%s%s%s\n",
 176                                      sha1_to_hex(remote),
 177                                      (multi_ack ? " multi_ack" : ""),
 178                                      (use_sideband == 2 ? " side-band-64k" : ""),
 179                                      (use_sideband == 1 ? " side-band" : ""),
 180                                      (use_thin_pack ? " thin-pack" : ""),
 181                                      (args.no_progress ? " no-progress" : ""),
 182                                      " ofs-delta");
 183                 else
 184                         packet_write(fd[1], "want %s\n", sha1_to_hex(remote));
 185                 fetching++;
 186         }
 187         if (is_repository_shallow())
 188                 write_shallow_commits(fd[1], 1);
 189         if (args.depth > 0)
 190                 packet_write(fd[1], "deepen %d", args.depth);
 191         packet_flush(fd[1]);
 192         if (!fetching)
 193                 return 1;
 194
 195         if (args.depth > 0) {
 196                 char line[1024];
 197                 unsigned char sha1[20];
 198                 int len;
 199
 200                 while ((len = packet_read_line(fd[0], line, sizeof(line)))) {
 201                         if (!prefixcmp(line, "shallow ")) {
 202                                 if (get_sha1_hex(line + 8, sha1))
 203                                         die("invalid shallow line: %s", line);
 204                                 register_shallow(sha1);
 205                                 continue;
 206                         }
 207                         if (!prefixcmp(line, "unshallow ")) {
 208                                 if (get_sha1_hex(line + 10, sha1))
 209                                         die("invalid unshallow line: %s", line);
 210                                 if (!lookup_object(sha1))
 211                                         die("object not found: %s", line);
 212                                 /* make sure that it is parsed as shallow */
 213                                 parse_object(sha1);
 214                                 if (unregister_shallow(sha1))
 215                                         die("no shallow found: %s", line);
 216                                 continue;
 217                         }
 218                         die("expected shallow/unshallow, got %s", line);
 219                 }
 220         }
 221
 222         flushes = 0;
 223         retval = -1;
 224         while ((sha1 = get_rev())) {
 225                 packet_write(fd[1], "have %s\n", sha1_to_hex(sha1));
 226                 if (args.verbose)
 227                         fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
 228                 in_vain++;
 229                 if (!(31 & ++count)) {
 230                         int ack;
 231
 232                         packet_flush(fd[1]);
 233                         flushes++;
 234
 235                         /*
 236                          * We keep one window "ahead" of the other side, and
 237                          * will wait for an ACK only on the next one
 238                          */
 239                         if (count == 32)
 240                                 continue;
 241
 242                         do {
 243                                 ack = get_ack(fd[0], result_sha1);
 244                                 if (args.verbose && ack)
 245                                         fprintf(stderr, "got ack %d %s\n", ack,
 246                                                         sha1_to_hex(result_sha1));
 247                                 if (ack == 1) {
 248                                         flushes = 0;
 249                                         multi_ack = 0;
 250                                         retval = 0;
 251                                         goto done;
 252                                 } else if (ack == 2) {
 253                                         struct commit *commit =
 254                                                 lookup_commit(result_sha1);
 255                                         mark_common(commit, 0, 1);
 256                                         retval = 0;
 257                                         in_vain = 0;
 258                                         got_continue = 1;
 259                                 }
 260                         } while (ack);
 261                         flushes--;
 262                         if (got_continue && MAX_IN_VAIN < in_vain) {
 263                                 if (args.verbose)
 264                                         fprintf(stderr, "giving up\n");
 265                                 break; /* give up */
 266                         }
 267                 }
 268         }
 269 done:
 270         packet_write(fd[1], "done\n");
 271         if (args.verbose)
 272                 fprintf(stderr, "done\n");
 273         if (retval != 0) {
 274                 multi_ack = 0;
 275                 flushes++;
 276         }
 277         while (flushes || multi_ack) {
 278                 int ack = get_ack(fd[0], result_sha1);
 279                 if (ack) {
 280                         if (args.verbose)
 281                                 fprintf(stderr, "got ack (%d) %s\n", ack,
 282                                         sha1_to_hex(result_sha1));
 283                         if (ack == 1)
 284                                 return 0;
 285                         multi_ack = 1;
 286                         continue;
 287                 }
 288                 flushes--;
 289         }
 290         return retval;
 291 }
 292
 293 static struct commit_list *complete;
 294
 295 static int mark_complete(const char *path, const unsigned char *sha1, int flag, void *cb_data)
 296 {
 297         struct object *o = parse_object(sha1);
 298
 299         while (o && o->type == OBJ_TAG) {
 300                 struct tag *t = (struct tag *) o;
 301                 if (!t->tagged)
 302                         break; /* broken repository */
 303                 o->flags |= COMPLETE;
 304                 o = parse_object(t->tagged->sha1);
 305         }
 306         if (o && o->type == OBJ_COMMIT) {
 307                 struct commit *commit = (struct commit *)o;
 308                 commit->object.flags |= COMPLETE;
 309                 insert_by_date(commit, &complete);
 310         }
 311         return 0;
 312 }
 313
 314 static void mark_recent_complete_commits(unsigned long cutoff)
 315 {
 316         while (complete && cutoff <= complete->item->date) {
 317                 if (args.verbose)
 318                         fprintf(stderr, "Marking %s as complete\n",
 319                                 sha1_to_hex(complete->item->object.sha1));
 320                 pop_most_recent_commit(&complete, COMPLETE);
 321         }
 322 }
 323
 324 static void filter_refs(struct ref **refs, int nr_match, char **match)
 325 {
 326         struct ref **return_refs;
 327         struct ref *newlist = NULL;
 328         struct ref **newtail = &newlist;
 329         struct ref *ref, *next;
 330         struct ref *fastarray[32];
 331
 332         if (nr_match && !args.fetch_all) {
 333                 if (ARRAY_SIZE(fastarray) < nr_match)
 334                         return_refs = xcalloc(nr_match, sizeof(struct ref *));
 335                 else {
 336                         return_refs = fastarray;
 337                         memset(return_refs, 0, sizeof(struct ref *) * nr_match);
 338                 }
 339         }
 340         else
 341                 return_refs = NULL;
 342
 343         for (ref = *refs; ref; ref = next) {
 344                 next = ref->next;
 345                 if (!memcmp(ref->name, "refs/", 5) &&
 346                     check_ref_format(ref->name + 5))
 347                         ; /* trash */
 348                 else if (args.fetch_all &&
 349                          (!args.depth || prefixcmp(ref->name, "refs/tags/") )) {
 350                         *newtail = ref;
 351                         ref->next = NULL;
 352                         newtail = &ref->next;
 353                         continue;
 354                 }
 355                 else {
 356                         int order = path_match(ref->name, nr_match, match);
 357                         if (order) {
 358                                 return_refs[order-1] = ref;
 359                                 continue; /* we will link it later */
 360                         }
 361                 }
 362                 free(ref);
 363         }
 364
 365         if (!args.fetch_all) {
 366                 int i;
 367                 for (i = 0; i < nr_match; i++) {
 368                         ref = return_refs[i];
 369                         if (ref) {
 370                                 *newtail = ref;
 371                                 ref->next = NULL;
 372                                 newtail = &ref->next;
 373                         }
 374                 }
 375                 if (return_refs != fastarray)
 376                         free(return_refs);
 377         }
 378         *refs = newlist;
 379 }
 380
 381 static int everything_local(struct ref **refs, int nr_match, char **match)
 382 {
 383         struct ref *ref;
 384         int retval;
 385         unsigned long cutoff = 0;
 386
 387         track_object_refs = 0;
 388         save_commit_buffer = 0;
 389
 390         for (ref = *refs; ref; ref = ref->next) {
 391                 struct object *o;
 392
 393                 o = parse_object(ref->old_sha1);
 394                 if (!o)
 395                         continue;
 396
 397                 /* We already have it -- which may mean that we were
 398                  * in sync with the other side at some time after
 399                  * that (it is OK if we guess wrong here).
 400                  */
 401                 if (o->type == OBJ_COMMIT) {
 402                         struct commit *commit = (struct commit *)o;
 403                         if (!cutoff || cutoff < commit->date)
 404                                 cutoff = commit->date;
 405                 }
 406         }
 407
 408         if (!args.depth) {
 409                 for_each_ref(mark_complete, NULL);
 410                 if (cutoff)
 411                         mark_recent_complete_commits(cutoff);
 412         }
 413
 414         /*
 415          * Mark all complete remote refs as common refs.
 416          * Don't mark them common yet; the server has to be told so first.
 417          */
 418         for (ref = *refs; ref; ref = ref->next) {
 419                 struct object *o = deref_tag(lookup_object(ref->old_sha1),
 420                                              NULL, 0);
 421
 422                 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
 423                         continue;
 424
 425                 if (!(o->flags & SEEN)) {
 426                         rev_list_push((struct commit *)o, COMMON_REF | SEEN);
 427
 428                         mark_common((struct commit *)o, 1, 1);
 429                 }
 430         }
 431
 432         filter_refs(refs, nr_match, match);
 433
 434         for (retval = 1, ref = *refs; ref ; ref = ref->next) {
 435                 const unsigned char *remote = ref->old_sha1;
 436                 unsigned char local[20];
 437                 struct object *o;
 438
 439                 o = lookup_object(remote);
 440                 if (!o || !(o->flags & COMPLETE)) {
 441                         retval = 0;
 442                         if (!args.verbose)
 443                                 continue;
 444                         fprintf(stderr,
 445                                 "want %s (%s)\n", sha1_to_hex(remote),
 446                                 ref->name);
 447                         continue;
 448                 }
 449
 450                 hashcpy(ref->new_sha1, local);
 451                 if (!args.verbose)
 452                         continue;
 453                 fprintf(stderr,
 454                         "already have %s (%s)\n", sha1_to_hex(remote),
 455                         ref->name);
 456         }
 457         return retval;
 458 }
 459
 460 static pid_t setup_sideband(int fd[2], int xd[2])
 461 {
 462         pid_t side_pid;
 463
 464         if (!use_sideband) {
 465                 fd[0] = xd[0];
 466                 fd[1] = xd[1];
 467                 return 0;
 468         }
 469         /* xd[] is talking with upload-pack; subprocess reads from
 470          * xd[0], spits out band#2 to stderr, and feeds us band#1
 471          * through our fd[0].
 472          */
 473         if (pipe(fd) < 0)
 474                 die("fetch-pack: unable to set up pipe");
 475         side_pid = fork();
 476         if (side_pid < 0)
 477                 die("fetch-pack: unable to fork off sideband demultiplexer");
 478         if (!side_pid) {
 479                 /* subprocess */
 480                 close(fd[0]);
 481                 if (xd[0] != xd[1])
 482                         close(xd[1]);
 483                 if (recv_sideband("fetch-pack", xd[0], fd[1], 2))
 484                         exit(1);
 485                 exit(0);
 486         }
 487         close(xd[0]);
 488         close(fd[1]);
 489         fd[1] = xd[1];
 490         return side_pid;
 491 }
 492
 493 static int get_pack(int xd[2], char **pack_lockfile)
 494 {
 495         int status;
 496         pid_t pid, side_pid;
 497         int fd[2];
 498         const char *argv[20];
 499         char keep_arg[256];
 500         char hdr_arg[256];
 501         const char **av;
 502         int do_keep = args.keep_pack;
 503         int keep_pipe[2];
 504
 505         side_pid = setup_sideband(fd, xd);
 506
 507         av = argv;
 508         *hdr_arg = 0;
 509         if (!args.keep_pack && unpack_limit) {
 510                 struct pack_header header;
 511
 512                 if (read_pack_header(fd[0], &header))
 513                         die("protocol error: bad pack header");
 514                 snprintf(hdr_arg, sizeof(hdr_arg), "--pack_header=%u,%u",
 515                          ntohl(header.hdr_version), ntohl(header.hdr_entries));
 516                 if (ntohl(header.hdr_entries) < unpack_limit)
 517                         do_keep = 0;
 518                 else
 519                         do_keep = 1;
 520         }
 521
 522         if (do_keep) {
 523                 if (pack_lockfile && pipe(keep_pipe))
 524                         die("fetch-pack: pipe setup failure: %s", strerror(errno));
 525                 *av++ = "index-pack";
 526                 *av++ = "--stdin";
 527                 if (!args.quiet && !args.no_progress)
 528                         *av++ = "-v";
 529                 if (args.use_thin_pack)
 530                         *av++ = "--fix-thin";
 531                 if (args.lock_pack || unpack_limit) {
 532                         int s = sprintf(keep_arg,
 533                                         "--keep=fetch-pack %d on ", getpid());
 534                         if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 535                                 strcpy(keep_arg + s, "localhost");
 536                         *av++ = keep_arg;
 537                 }
 538         }
 539         else {
 540                 *av++ = "unpack-objects";
 541                 if (args.quiet)
 542                         *av++ = "-q";
 543         }
 544         if (*hdr_arg)
 545                 *av++ = hdr_arg;
 546         *av++ = NULL;
 547
 548         pid = fork();
 549         if (pid < 0)
 550                 die("fetch-pack: unable to fork off %s", argv[0]);
 551         if (!pid) {
 552                 dup2(fd[0], 0);
 553                 if (do_keep && pack_lockfile) {
 554                         dup2(keep_pipe[1], 1);
 555                         close(keep_pipe[0]);
 556                         close(keep_pipe[1]);
 557                 }
 558                 close(fd[0]);
 559                 close(fd[1]);
 560                 execv_git_cmd(argv);
 561                 die("%s exec failed", argv[0]);
 562         }
 563         close(fd[0]);
 564         close(fd[1]);
 565         if (do_keep && pack_lockfile) {
 566                 close(keep_pipe[1]);
 567                 *pack_lockfile = index_pack_lockfile(keep_pipe[0]);
 568                 close(keep_pipe[0]);
 569         }
 570         while (waitpid(pid, &status, 0) < 0) {
 571                 if (errno != EINTR)
 572                         die("waiting for %s: %s", argv[0], strerror(errno));
 573         }
 574         if (WIFEXITED(status)) {
 575                 int code = WEXITSTATUS(status);
 576                 if (code)
 577                         die("%s died with error code %d", argv[0], code);
 578                 return 0;
 579         }
 580         if (WIFSIGNALED(status)) {
 581                 int sig = WTERMSIG(status);
 582                 die("%s died of signal %d", argv[0], sig);
 583         }
 584         die("%s died of unnatural causes %d", argv[0], status);
 585 }
 586
 587 static struct ref *do_fetch_pack(int fd[2],
 588                 int nr_match,
 589                 char **match,
 590                 char **pack_lockfile)
 591 {
 592         struct ref *ref;
 593         unsigned char sha1[20];
 594
 595         get_remote_heads(fd[0], &ref, 0, NULL, 0);
 596         if (is_repository_shallow() && !server_supports("shallow"))
 597                 die("Server does not support shallow clients");
 598         if (server_supports("multi_ack")) {
 599                 if (args.verbose)
 600                         fprintf(stderr, "Server supports multi_ack\n");
 601                 multi_ack = 1;
 602         }
 603         if (server_supports("side-band-64k")) {
 604                 if (args.verbose)
 605                         fprintf(stderr, "Server supports side-band-64k\n");
 606                 use_sideband = 2;
 607         }
 608         else if (server_supports("side-band")) {
 609                 if (args.verbose)
 610                         fprintf(stderr, "Server supports side-band\n");
 611                 use_sideband = 1;
 612         }
 613         if (!ref) {
 614                 packet_flush(fd[1]);
 615                 die("no matching remote head");
 616         }
 617         if (everything_local(&ref, nr_match, match)) {
 618                 packet_flush(fd[1]);
 619                 goto all_done;
 620         }
 621         if (find_common(fd, sha1, ref) < 0)
 622                 if (!args.keep_pack)
 623                         /* When cloning, it is not unusual to have
 624                          * no common commit.
 625                          */
 626                         fprintf(stderr, "warning: no common commits\n");
 627
 628         if (get_pack(fd, pack_lockfile))
 629                 die("git-fetch-pack: fetch failed.");
 630
 631  all_done:
 632         return ref;
 633 }
 634
 635 static int remove_duplicates(int nr_heads, char **heads)
 636 {
 637         int src, dst;
 638
 639         for (src = dst = 0; src < nr_heads; src++) {
 640                 /* If heads[src] is different from any of
 641                  * heads[0..dst], push it in.
 642                  */
 643                 int i;
 644                 for (i = 0; i < dst; i++) {
 645                         if (!strcmp(heads[i], heads[src]))
 646                                 break;
 647                 }
 648                 if (i < dst)
 649                         continue;
 650                 if (src != dst)
 651                         heads[dst] = heads[src];
 652                 dst++;
 653         }
 654         return dst;
 655 }
 656
 657 static int fetch_pack_config(const char *var, const char *value)
 658 {
 659         if (strcmp(var, "fetch.unpacklimit") == 0) {
 660                 fetch_unpack_limit = git_config_int(var, value);
 661                 return 0;
 662         }
 663
 664         if (strcmp(var, "transfer.unpacklimit") == 0) {
 665                 transfer_unpack_limit = git_config_int(var, value);
 666                 return 0;
 667         }
 668
 669         return git_default_config(var, value);
 670 }
 671
 672 static struct lock_file lock;
 673
 674 static void fetch_pack_setup(void)
 675 {
 676         static int did_setup;
 677         if (did_setup)
 678                 return;
 679         git_config(fetch_pack_config);
 680         if (0 <= transfer_unpack_limit)
 681                 unpack_limit = transfer_unpack_limit;
 682         else if (0 <= fetch_unpack_limit)
 683                 unpack_limit = fetch_unpack_limit;
 684         did_setup = 1;
 685 }
 686
 687 int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
 688 {
 689         int i, ret, nr_heads;
 690         struct ref *ref;
 691         char *dest = NULL, **heads;
 692
 693         nr_heads = 0;
 694         heads = NULL;
 695         for (i = 1; i < argc; i++) {
 696                 const char *arg = argv[i];
 697
 698                 if (*arg == '-') {
 699                         if (!prefixcmp(arg, "--upload-pack=")) {
 700                                 args.uploadpack = arg + 14;
 701                                 continue;
 702                         }
 703                         if (!prefixcmp(arg, "--exec=")) {
 704                                 args.uploadpack = arg + 7;
 705                                 continue;
 706                         }
 707                         if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
 708                                 args.quiet = 1;
 709                                 continue;
 710                         }
 711                         if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
 712                                 args.lock_pack = args.keep_pack;
 713                                 args.keep_pack = 1;
 714                                 continue;
 715                         }
 716                         if (!strcmp("--thin", arg)) {
 717                                 args.use_thin_pack = 1;
 718                                 continue;
 719                         }
 720                         if (!strcmp("--all", arg)) {
 721                                 args.fetch_all = 1;
 722                                 continue;
 723                         }
 724                         if (!strcmp("-v", arg)) {
 725                                 args.verbose = 1;
 726                                 continue;
 727                         }
 728                         if (!prefixcmp(arg, "--depth=")) {
 729                                 args.depth = strtol(arg + 8, NULL, 0);
 730                                 continue;
 731                         }
 732                         if (!strcmp("--no-progress", arg)) {
 733                                 args.no_progress = 1;
 734                                 continue;
 735                         }
 736                         usage(fetch_pack_usage);
 737                 }
 738                 dest = (char *)arg;
 739                 heads = (char **)(argv + i + 1);
 740                 nr_heads = argc - i - 1;
 741                 break;
 742         }
 743         if (!dest)
 744                 usage(fetch_pack_usage);
 745
 746         ref = fetch_pack(&args, dest, nr_heads, heads, NULL);
 747         ret = !ref;
 748
 749         while (ref) {
 750                 printf("%s %s\n",
 751                        sha1_to_hex(ref->old_sha1), ref->name);
 752                 ref = ref->next;
 753         }
 754
 755         return ret;
 756 }
 757
 758 struct ref *fetch_pack(struct fetch_pack_args *my_args,
 759                 const char *dest,
 760                 int nr_heads,
 761                 char **heads,
 762                 char **pack_lockfile)
 763 {
 764         int i, ret;
 765         int fd[2];
 766         pid_t pid;
 767         struct ref *ref;
 768         struct stat st;
 769
 770         fetch_pack_setup();
 771         memcpy(&args, my_args, sizeof(args));
 772         if (args.depth > 0) {
 773                 if (stat(git_path("shallow"), &st))
 774                         st.st_mtime = 0;
 775         }
 776
 777         pid = git_connect(fd, (char *)dest, args.uploadpack,
 778                           args.verbose ? CONNECT_VERBOSE : 0);
 779         if (pid < 0)
 780                 return NULL;
 781         if (heads && nr_heads)
 782                 nr_heads = remove_duplicates(nr_heads, heads);
 783         ref = do_fetch_pack(fd, nr_heads, heads, pack_lockfile);
 784         close(fd[0]);
 785         close(fd[1]);
 786         ret = finish_connect(pid);
 787
 788         if (!ret && nr_heads) {
 789                 /* If the heads to pull were given, we should have
 790                  * consumed all of them by matching the remote.
 791                  * Otherwise, 'git-fetch remote no-such-ref' would
 792                  * silently succeed without issuing an error.
 793                  */
 794                 for (i = 0; i < nr_heads; i++)
 795                         if (heads[i] && heads[i][0]) {
 796                                 error("no such remote ref %s", heads[i]);
 797                                 ret = 1;
 798                         }
 799         }
 800
 801         if (!ret && args.depth > 0) {
 802                 struct cache_time mtime;
 803                 char *shallow = git_path("shallow");
 804                 int fd;
 805
 806                 mtime.sec = st.st_mtime;
 807 #ifdef USE_NSEC
 808                 mtime.usec = st.st_mtim.usec;
 809 #endif
 810                 if (stat(shallow, &st)) {
 811                         if (mtime.sec)
 812                                 die("shallow file was removed during fetch");
 813                 } else if (st.st_mtime != mtime.sec
 814 #ifdef USE_NSEC
 815                                 || st.st_mtim.usec != mtime.usec
 816 #endif
 817                           )
 818                         die("shallow file was changed during fetch");
 819
 820                 fd = hold_lock_file_for_update(&lock, shallow, 1);
 821                 if (!write_shallow_commits(fd, 0)) {
 822                         unlink(shallow);
 823                         rollback_lock_file(&lock);
 824                 } else {
 825                         close(fd);
 826                         commit_lock_file(&lock);
 827                 }
 828         }
 829
 830         if (ret)
 831                 ref = NULL;
 832
 833         return ref;
 834 }