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         heads[dst] = 0;
 658         return dst;
 659 }
 660
 661 static int fetch_pack_config(const char *var, const char *value)
 662 {
 663         if (strcmp(var, "fetch.unpacklimit") == 0) {
 664                 fetch_unpack_limit = git_config_int(var, value);
 665                 return 0;
 666         }
 667
 668         if (strcmp(var, "transfer.unpacklimit") == 0) {
 669                 transfer_unpack_limit = git_config_int(var, value);
 670                 return 0;
 671         }
 672
 673         return git_default_config(var, value);
 674 }
 675
 676 static struct lock_file lock;
 677
 678 void setup_fetch_pack(struct fetch_pack_args *args)
 679 {
 680         uploadpack = args->uploadpack;
 681         quiet = args->quiet;
 682         keep_pack = args->keep_pack;
 683         if (args->unpacklimit >= 0)
 684                 unpack_limit = args->unpacklimit;
 685         if (args->keep_pack)
 686                 unpack_limit = 0;
 687         use_thin_pack = args->use_thin_pack;
 688         fetch_all = args->fetch_all;
 689         verbose = args->verbose;
 690         depth = args->depth;
 691         no_progress = args->no_progress;
 692 }
 693
 694 int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
 695 {
 696         int i, ret, nr_heads;
 697         struct ref *ref;
 698         char *dest = NULL, **heads;
 699
 700         git_config(fetch_pack_config);
 701
 702         if (0 <= transfer_unpack_limit)
 703                 unpack_limit = transfer_unpack_limit;
 704         else if (0 <= fetch_unpack_limit)
 705                 unpack_limit = fetch_unpack_limit;
 706
 707         nr_heads = 0;
 708         heads = NULL;
 709         for (i = 1; i < argc; i++) {
 710                 const char *arg = argv[i];
 711
 712                 if (*arg == '-') {
 713                         if (!prefixcmp(arg, "--upload-pack=")) {
 714                                 uploadpack = arg + 14;
 715                                 continue;
 716                         }
 717                         if (!prefixcmp(arg, "--exec=")) {
 718                                 uploadpack = arg + 7;
 719                                 continue;
 720                         }
 721                         if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
 722                                 quiet = 1;
 723                                 continue;
 724                         }
 725                         if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
 726                                 keep_pack++;
 727                                 unpack_limit = 0;
 728                                 continue;
 729                         }
 730                         if (!strcmp("--thin", arg)) {
 731                                 use_thin_pack = 1;
 732                                 continue;
 733                         }
 734                         if (!strcmp("--all", arg)) {
 735                                 fetch_all = 1;
 736                                 continue;
 737                         }
 738                         if (!strcmp("-v", arg)) {
 739                                 verbose = 1;
 740                                 continue;
 741                         }
 742                         if (!prefixcmp(arg, "--depth=")) {
 743                                 depth = strtol(arg + 8, NULL, 0);
 744                                 continue;
 745                         }
 746                         if (!strcmp("--no-progress", arg)) {
 747                                 no_progress = 1;
 748                                 continue;
 749                         }
 750                         usage(fetch_pack_usage);
 751                 }
 752                 dest = (char *)arg;
 753                 heads = (char **)(argv + i + 1);
 754                 nr_heads = argc - i - 1;
 755                 break;
 756         }
 757         if (!dest)
 758                 usage(fetch_pack_usage);
 759
 760         ref = fetch_pack(dest, nr_heads, heads, NULL);
 761
 762         ret = !ref;
 763
 764         while (ref) {
 765                 printf("%s %s\n",
 766                        sha1_to_hex(ref->old_sha1), ref->name);
 767                 ref = ref->next;
 768         }
 769
 770         return ret;
 771 }
 772
 773 struct ref *fetch_pack(const char *dest,
 774                 int nr_heads,
 775                 char **heads,
 776                 char **pack_lockfile)
 777 {
 778         int i, ret;
 779         int fd[2];
 780         pid_t pid;
 781         struct ref *ref;
 782         struct stat st;
 783
 784         if (depth > 0) {
 785                 if (stat(git_path("shallow"), &st))
 786                         st.st_mtime = 0;
 787         }
 788
 789         pid = git_connect(fd, (char *)dest, uploadpack,
 790                           verbose ? CONNECT_VERBOSE : 0);
 791         if (pid < 0)
 792                 return NULL;
 793         if (heads && nr_heads)
 794                 nr_heads = remove_duplicates(nr_heads, heads);
 795         ref = do_fetch_pack(fd, nr_heads, heads, pack_lockfile);
 796         close(fd[0]);
 797         close(fd[1]);
 798         ret = finish_connect(pid);
 799
 800         if (!ret && nr_heads) {
 801                 /* If the heads to pull were given, we should have
 802                  * consumed all of them by matching the remote.
 803                  * Otherwise, 'git-fetch remote no-such-ref' would
 804                  * silently succeed without issuing an error.
 805                  */
 806                 for (i = 0; i < nr_heads; i++)
 807                         if (heads[i] && heads[i][0]) {
 808                                 error("no such remote ref %s", heads[i]);
 809                                 ret = 1;
 810                         }
 811         }
 812
 813         if (!ret && depth > 0) {
 814                 struct cache_time mtime;
 815                 char *shallow = git_path("shallow");
 816                 int fd;
 817
 818                 mtime.sec = st.st_mtime;
 819 #ifdef USE_NSEC
 820                 mtime.usec = st.st_mtim.usec;
 821 #endif
 822                 if (stat(shallow, &st)) {
 823                         if (mtime.sec)
 824                                 die("shallow file was removed during fetch");
 825                 } else if (st.st_mtime != mtime.sec
 826 #ifdef USE_NSEC
 827                                 || st.st_mtim.usec != mtime.usec
 828 #endif
 829                           )
 830                         die("shallow file was changed during fetch");
 831
 832                 fd = hold_lock_file_for_update(&lock, shallow, 1);
 833                 if (!write_shallow_commits(fd, 0)) {
 834                         unlink(shallow);
 835                         rollback_lock_file(&lock);
 836                 } else {
 837                         close(fd);
 838                         commit_lock_file(&lock);
 839                 }
 840         }
 841
 842         if (ret)
 843                 ref = NULL;
 844
 845         return ref;
 846 }