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