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