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