Andrew's git / gitweb.git / builtin-fetch-pack.c
?
builtin-fetch-pack.con commit Merge branch 'sp/maint-index-pack' into maint (fcf74db)
   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
  13static int transfer_unpack_limit = -1;
  14static int fetch_unpack_limit = -1;
  15static int unpack_limit = 100;
  16static struct fetch_pack_args args = {
  17        /* .uploadpack = */ "git-upload-pack",
  18};
  19
  20static 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
  29static 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
  37static struct commit_list *rev_list;
  38static int non_common_revs, multi_ack, use_sideband;
  39
  40static 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
  56static 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
  66static 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
  82static 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
 114static 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
 159static 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        }
 291done:
 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
 316static struct commit_list *complete;
 317
 318static 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
 337static 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
 347static 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
 404static 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
 482static 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
 489static 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
 573static 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
 617static 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
 639static 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
 654static struct lock_file lock;
 655
 656static 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
 669int 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
 770struct 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}