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