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