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])
 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
 507         side_pid = setup_sideband(fd, xd);
 508
 509         av = argv;
 510         *hdr_arg = 0;
 511         if (unpack_limit) {
 512                 struct pack_header header;
 513
 514                 if (read_pack_header(fd[0], &header))
 515                         die("protocol error: bad pack header");
 516                 snprintf(hdr_arg, sizeof(hdr_arg), "--pack_header=%u,%u",
 517                          ntohl(header.hdr_version), ntohl(header.hdr_entries));
 518                 if (ntohl(header.hdr_entries) < unpack_limit)
 519                         do_keep = 0;
 520                 else
 521                         do_keep = 1;
 522         }
 523
 524         if (do_keep) {
 525                 *av++ = "index-pack";
 526                 *av++ = "--stdin";
 527                 if (!quiet && !no_progress)
 528                         *av++ = "-v";
 529                 if (use_thin_pack)
 530                         *av++ = "--fix-thin";
 531                 if (keep_pack > 1 || 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 (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                 close(fd[0]);
 554                 close(fd[1]);
 555                 execv_git_cmd(argv);
 556                 die("%s exec failed", argv[0]);
 557         }
 558         close(fd[0]);
 559         close(fd[1]);
 560         while (waitpid(pid, &status, 0) < 0) {
 561                 if (errno != EINTR)
 562                         die("waiting for %s: %s", argv[0], strerror(errno));
 563         }
 564         if (WIFEXITED(status)) {
 565                 int code = WEXITSTATUS(status);
 566                 if (code)
 567                         die("%s died with error code %d", argv[0], code);
 568                 return 0;
 569         }
 570         if (WIFSIGNALED(status)) {
 571                 int sig = WTERMSIG(status);
 572                 die("%s died of signal %d", argv[0], sig);
 573         }
 574         die("%s died of unnatural causes %d", argv[0], status);
 575 }
 576
 577 static struct ref *do_fetch_pack(int fd[2], int nr_match, char **match)
 578 {
 579         struct ref *ref;
 580         unsigned char sha1[20];
 581
 582         get_remote_heads(fd[0], &ref, 0, NULL, 0);
 583         if (is_repository_shallow() && !server_supports("shallow"))
 584                 die("Server does not support shallow clients");
 585         if (server_supports("multi_ack")) {
 586                 if (verbose)
 587                         fprintf(stderr, "Server supports multi_ack\n");
 588                 multi_ack = 1;
 589         }
 590         if (server_supports("side-band-64k")) {
 591                 if (verbose)
 592                         fprintf(stderr, "Server supports side-band-64k\n");
 593                 use_sideband = 2;
 594         }
 595         else if (server_supports("side-band")) {
 596                 if (verbose)
 597                         fprintf(stderr, "Server supports side-band\n");
 598                 use_sideband = 1;
 599         }
 600         if (!ref) {
 601                 packet_flush(fd[1]);
 602                 die("no matching remote head");
 603         }
 604         if (everything_local(&ref, nr_match, match)) {
 605                 packet_flush(fd[1]);
 606                 goto all_done;
 607         }
 608         if (find_common(fd, sha1, ref) < 0)
 609                 if (keep_pack != 1)
 610                         /* When cloning, it is not unusual to have
 611                          * no common commit.
 612                          */
 613                         fprintf(stderr, "warning: no common commits\n");
 614
 615         if (get_pack(fd))
 616                 die("git-fetch-pack: fetch failed.");
 617
 618  all_done:
 619         return ref;
 620 }
 621
 622 static int remove_duplicates(int nr_heads, char **heads)
 623 {
 624         int src, dst;
 625
 626         for (src = dst = 0; src < nr_heads; src++) {
 627                 /* If heads[src] is different from any of
 628                  * heads[0..dst], push it in.
 629                  */
 630                 int i;
 631                 for (i = 0; i < dst; i++) {
 632                         if (!strcmp(heads[i], heads[src]))
 633                                 break;
 634                 }
 635                 if (i < dst)
 636                         continue;
 637                 if (src != dst)
 638                         heads[dst] = heads[src];
 639                 dst++;
 640         }
 641         heads[dst] = 0;
 642         return dst;
 643 }
 644
 645 static int fetch_pack_config(const char *var, const char *value)
 646 {
 647         if (strcmp(var, "fetch.unpacklimit") == 0) {
 648                 fetch_unpack_limit = git_config_int(var, value);
 649                 return 0;
 650         }
 651
 652         if (strcmp(var, "transfer.unpacklimit") == 0) {
 653                 transfer_unpack_limit = git_config_int(var, value);
 654                 return 0;
 655         }
 656
 657         return git_default_config(var, value);
 658 }
 659
 660 static struct lock_file lock;
 661
 662 void setup_fetch_pack(struct fetch_pack_args *args)
 663 {
 664         uploadpack = args->uploadpack;
 665         quiet = args->quiet;
 666         keep_pack = args->keep_pack;
 667         if (args->unpacklimit >= 0)
 668                 unpack_limit = args->unpacklimit;
 669         if (args->keep_pack)
 670                 unpack_limit = 0;
 671         use_thin_pack = args->use_thin_pack;
 672         fetch_all = args->fetch_all;
 673         verbose = args->verbose;
 674         depth = args->depth;
 675         no_progress = args->no_progress;
 676 }
 677
 678 int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
 679 {
 680         int i, ret, nr_heads;
 681         struct ref *ref;
 682         char *dest = NULL, **heads;
 683
 684         git_config(fetch_pack_config);
 685
 686         if (0 <= transfer_unpack_limit)
 687                 unpack_limit = transfer_unpack_limit;
 688         else if (0 <= fetch_unpack_limit)
 689                 unpack_limit = fetch_unpack_limit;
 690
 691         nr_heads = 0;
 692         heads = NULL;
 693         for (i = 1; i < argc; i++) {
 694                 const char *arg = argv[i];
 695
 696                 if (*arg == '-') {
 697                         if (!prefixcmp(arg, "--upload-pack=")) {
 698                                 uploadpack = arg + 14;
 699                                 continue;
 700                         }
 701                         if (!prefixcmp(arg, "--exec=")) {
 702                                 uploadpack = arg + 7;
 703                                 continue;
 704                         }
 705                         if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
 706                                 quiet = 1;
 707                                 continue;
 708                         }
 709                         if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
 710                                 keep_pack++;
 711                                 unpack_limit = 0;
 712                                 continue;
 713                         }
 714                         if (!strcmp("--thin", arg)) {
 715                                 use_thin_pack = 1;
 716                                 continue;
 717                         }
 718                         if (!strcmp("--all", arg)) {
 719                                 fetch_all = 1;
 720                                 continue;
 721                         }
 722                         if (!strcmp("-v", arg)) {
 723                                 verbose = 1;
 724                                 continue;
 725                         }
 726                         if (!prefixcmp(arg, "--depth=")) {
 727                                 depth = strtol(arg + 8, NULL, 0);
 728                                 continue;
 729                         }
 730                         if (!strcmp("--no-progress", arg)) {
 731                                 no_progress = 1;
 732                                 continue;
 733                         }
 734                         usage(fetch_pack_usage);
 735                 }
 736                 dest = (char *)arg;
 737                 heads = (char **)(argv + i + 1);
 738                 nr_heads = argc - i - 1;
 739                 break;
 740         }
 741         if (!dest)
 742                 usage(fetch_pack_usage);
 743
 744         ref = fetch_pack(dest, nr_heads, heads);
 745
 746         ret = !ref;
 747
 748         while (ref) {
 749                 printf("%s %s\n",
 750                        sha1_to_hex(ref->old_sha1), ref->name);
 751                 ref = ref->next;
 752         }
 753
 754         return ret;
 755 }
 756
 757 struct ref *fetch_pack(const char *dest, int nr_heads, char **heads)
 758 {
 759         int i, ret;
 760         int fd[2];
 761         pid_t pid;
 762         struct ref *ref;
 763         struct stat st;
 764
 765         if (depth > 0) {
 766                 if (stat(git_path("shallow"), &st))
 767                         st.st_mtime = 0;
 768         }
 769
 770         printf("connect to %s\n", dest);
 771
 772         pid = git_connect(fd, (char *)dest, uploadpack,
 773                           verbose ? CONNECT_VERBOSE : 0);
 774         if (pid < 0)
 775                 return NULL;
 776         if (heads && nr_heads)
 777                 nr_heads = remove_duplicates(nr_heads, heads);
 778         ref = do_fetch_pack(fd, nr_heads, heads);
 779         close(fd[0]);
 780         close(fd[1]);
 781         ret = finish_connect(pid);
 782
 783         if (!ret && nr_heads) {
 784                 /* If the heads to pull were given, we should have
 785                  * consumed all of them by matching the remote.
 786                  * Otherwise, 'git-fetch remote no-such-ref' would
 787                  * silently succeed without issuing an error.
 788                  */
 789                 for (i = 0; i < nr_heads; i++)
 790                         if (heads[i] && heads[i][0]) {
 791                                 error("no such remote ref %s", heads[i]);
 792                                 ret = 1;
 793                         }
 794         }
 795
 796         if (!ret && depth > 0) {
 797                 struct cache_time mtime;
 798                 char *shallow = git_path("shallow");
 799                 int fd;
 800
 801                 mtime.sec = st.st_mtime;
 802 #ifdef USE_NSEC
 803                 mtime.usec = st.st_mtim.usec;
 804 #endif
 805                 if (stat(shallow, &st)) {
 806                         if (mtime.sec)
 807                                 die("shallow file was removed during fetch");
 808                 } else if (st.st_mtime != mtime.sec
 809 #ifdef USE_NSEC
 810                                 || st.st_mtim.usec != mtime.usec
 811 #endif
 812                           )
 813                         die("shallow file was changed during fetch");
 814
 815                 fd = hold_lock_file_for_update(&lock, shallow, 1);
 816                 if (!write_shallow_commits(fd, 0)) {
 817                         unlink(shallow);
 818                         rollback_lock_file(&lock);
 819                 } else {
 820                         close(fd);
 821                         commit_lock_file(&lock);
 822                 }
 823         }
 824
 825         if (ret)
 826                 ref = NULL;
 827
 828         return ref;
 829 }