builtin-fetch-pack.c

   1 #include "cache.h"
   2 #include "refs.h"
   3 #include "pkt-line.h"
   4 #include "commit.h"
   5 #include "tag.h"
   6 #include "exec_cmd.h"
   7 #include "pack.h"
   8 #include "sideband.h"
   9 #include "fetch-pack.h"
  10 #include "run-command.h"
  11
  12 static int transfer_unpack_limit = -1;
  13 static int fetch_unpack_limit = -1;
  14 static int unpack_limit = 100;
  15 static struct fetch_pack_args args;
  16
  17 static 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>...]";
  19 static 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
  33 static struct commit_list *rev_list;
  34 static int non_common_revs, multi_ack, use_thin_pack, use_sideband;
  35
  36 static 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
  51 static 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
  67 static 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
  98 static 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
 143 static 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         }
 269 done:
 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
 293 static struct commit_list *complete;
 294
 295 static 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
 314 static 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
 324 static 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
 381 static 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
 460 static int sideband_demux(int fd, void *data)
 461 {
 462         int *xd = data;
 463
 464         close(xd[1]);
 465         return recv_sideband("fetch-pack", xd[0], fd, 2);
 466 }
 467
 468 static void setup_sideband(int fd[2], int xd[2], struct async *demux)
 469 {
 470         if (!use_sideband) {
 471                 fd[0] = xd[0];
 472                 fd[1] = xd[1];
 473                 return;
 474         }
 475         /* xd[] is talking with upload-pack; subprocess reads from
 476          * xd[0], spits out band#2 to stderr, and feeds us band#1
 477          * through demux->out.
 478          */
 479         demux->proc = sideband_demux;
 480         demux->data = xd;
 481         if (start_async(demux))
 482                 die("fetch-pack: unable to fork off sideband demultiplexer");
 483         close(xd[0]);
 484         fd[0] = demux->out;
 485         fd[1] = xd[1];
 486 }
 487
 488 static int get_pack(int xd[2], char **pack_lockfile)
 489 {
 490         struct async demux;
 491         int fd[2];
 492         const char *argv[20];
 493         char keep_arg[256];
 494         char hdr_arg[256];
 495         const char **av;
 496         int do_keep = args.keep_pack;
 497         struct child_process cmd;
 498
 499         setup_sideband(fd, xd, &demux);
 500
 501         memset(&cmd, 0, sizeof(cmd));
 502         cmd.argv = argv;
 503         av = argv;
 504         *hdr_arg = 0;
 505         if (!args.keep_pack && unpack_limit) {
 506                 struct pack_header header;
 507
 508                 if (read_pack_header(fd[0], &header))
 509                         die("protocol error: bad pack header");
 510                 snprintf(hdr_arg, sizeof(hdr_arg), "--pack_header=%u,%u",
 511                          ntohl(header.hdr_version), ntohl(header.hdr_entries));
 512                 if (ntohl(header.hdr_entries) < unpack_limit)
 513                         do_keep = 0;
 514                 else
 515                         do_keep = 1;
 516         }
 517
 518         if (do_keep) {
 519                 if (pack_lockfile)
 520                         cmd.out = -1;
 521                 *av++ = "index-pack";
 522                 *av++ = "--stdin";
 523                 if (!args.quiet && !args.no_progress)
 524                         *av++ = "-v";
 525                 if (args.use_thin_pack)
 526                         *av++ = "--fix-thin";
 527                 if (args.lock_pack || unpack_limit) {
 528                         int s = sprintf(keep_arg,
 529                                         "--keep=fetch-pack %d on ", getpid());
 530                         if (gethostname(keep_arg + s, sizeof(keep_arg) - s))
 531                                 strcpy(keep_arg + s, "localhost");
 532                         *av++ = keep_arg;
 533                 }
 534         }
 535         else {
 536                 *av++ = "unpack-objects";
 537                 if (args.quiet)
 538                         *av++ = "-q";
 539         }
 540         if (*hdr_arg)
 541                 *av++ = hdr_arg;
 542         *av++ = NULL;
 543
 544         cmd.in = fd[0];
 545         cmd.git_cmd = 1;
 546         if (start_command(&cmd))
 547                 die("fetch-pack: unable to fork off %s", argv[0]);
 548         close(fd[1]);
 549         if (do_keep && pack_lockfile)
 550                 *pack_lockfile = index_pack_lockfile(cmd.out);
 551
 552         if (finish_command(&cmd))
 553                 die("%s failed", argv[0]);
 554         if (use_sideband && finish_async(&demux))
 555                 die("error in sideband demultiplexer");
 556         return 0;
 557 }
 558
 559 static struct ref *do_fetch_pack(int fd[2],
 560                 int nr_match,
 561                 char **match,
 562                 char **pack_lockfile)
 563 {
 564         struct ref *ref;
 565         unsigned char sha1[20];
 566
 567         get_remote_heads(fd[0], &ref, 0, NULL, 0);
 568         if (is_repository_shallow() && !server_supports("shallow"))
 569                 die("Server does not support shallow clients");
 570         if (server_supports("multi_ack")) {
 571                 if (args.verbose)
 572                         fprintf(stderr, "Server supports multi_ack\n");
 573                 multi_ack = 1;
 574         }
 575         if (server_supports("side-band-64k")) {
 576                 if (args.verbose)
 577                         fprintf(stderr, "Server supports side-band-64k\n");
 578                 use_sideband = 2;
 579         }
 580         else if (server_supports("side-band")) {
 581                 if (args.verbose)
 582                         fprintf(stderr, "Server supports side-band\n");
 583                 use_sideband = 1;
 584         }
 585         if (!ref) {
 586                 packet_flush(fd[1]);
 587                 die("no matching remote head");
 588         }
 589         if (everything_local(&ref, nr_match, match)) {
 590                 packet_flush(fd[1]);
 591                 goto all_done;
 592         }
 593         if (find_common(fd, sha1, ref) < 0)
 594                 if (!args.keep_pack)
 595                         /* When cloning, it is not unusual to have
 596                          * no common commit.
 597                          */
 598                         fprintf(stderr, "warning: no common commits\n");
 599
 600         if (get_pack(fd, pack_lockfile))
 601                 die("git-fetch-pack: fetch failed.");
 602
 603  all_done:
 604         return ref;
 605 }
 606
 607 static int remove_duplicates(int nr_heads, char **heads)
 608 {
 609         int src, dst;
 610
 611         for (src = dst = 0; src < nr_heads; src++) {
 612                 /* If heads[src] is different from any of
 613                  * heads[0..dst], push it in.
 614                  */
 615                 int i;
 616                 for (i = 0; i < dst; i++) {
 617                         if (!strcmp(heads[i], heads[src]))
 618                                 break;
 619                 }
 620                 if (i < dst)
 621                         continue;
 622                 if (src != dst)
 623                         heads[dst] = heads[src];
 624                 dst++;
 625         }
 626         return dst;
 627 }
 628
 629 static int fetch_pack_config(const char *var, const char *value)
 630 {
 631         if (strcmp(var, "fetch.unpacklimit") == 0) {
 632                 fetch_unpack_limit = git_config_int(var, value);
 633                 return 0;
 634         }
 635
 636         if (strcmp(var, "transfer.unpacklimit") == 0) {
 637                 transfer_unpack_limit = git_config_int(var, value);
 638                 return 0;
 639         }
 640
 641         return git_default_config(var, value);
 642 }
 643
 644 static struct lock_file lock;
 645
 646 static void fetch_pack_setup(void)
 647 {
 648         static int did_setup;
 649         if (did_setup)
 650                 return;
 651         git_config(fetch_pack_config);
 652         if (0 <= transfer_unpack_limit)
 653                 unpack_limit = transfer_unpack_limit;
 654         else if (0 <= fetch_unpack_limit)
 655                 unpack_limit = fetch_unpack_limit;
 656         did_setup = 1;
 657 }
 658
 659 int cmd_fetch_pack(int argc, const char **argv, const char *prefix)
 660 {
 661         int i, ret, nr_heads;
 662         struct ref *ref;
 663         char *dest = NULL, **heads;
 664
 665         nr_heads = 0;
 666         heads = NULL;
 667         for (i = 1; i < argc; i++) {
 668                 const char *arg = argv[i];
 669
 670                 if (*arg == '-') {
 671                         if (!prefixcmp(arg, "--upload-pack=")) {
 672                                 args.uploadpack = arg + 14;
 673                                 continue;
 674                         }
 675                         if (!prefixcmp(arg, "--exec=")) {
 676                                 args.uploadpack = arg + 7;
 677                                 continue;
 678                         }
 679                         if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
 680                                 args.quiet = 1;
 681                                 continue;
 682                         }
 683                         if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
 684                                 args.lock_pack = args.keep_pack;
 685                                 args.keep_pack = 1;
 686                                 continue;
 687                         }
 688                         if (!strcmp("--thin", arg)) {
 689                                 args.use_thin_pack = 1;
 690                                 continue;
 691                         }
 692                         if (!strcmp("--all", arg)) {
 693                                 args.fetch_all = 1;
 694                                 continue;
 695                         }
 696                         if (!strcmp("-v", arg)) {
 697                                 args.verbose = 1;
 698                                 continue;
 699                         }
 700                         if (!prefixcmp(arg, "--depth=")) {
 701                                 args.depth = strtol(arg + 8, NULL, 0);
 702                                 continue;
 703                         }
 704                         if (!strcmp("--no-progress", arg)) {
 705                                 args.no_progress = 1;
 706                                 continue;
 707                         }
 708                         usage(fetch_pack_usage);
 709                 }
 710                 dest = (char *)arg;
 711                 heads = (char **)(argv + i + 1);
 712                 nr_heads = argc - i - 1;
 713                 break;
 714         }
 715         if (!dest)
 716                 usage(fetch_pack_usage);
 717
 718         ref = fetch_pack(&args, dest, nr_heads, heads, NULL);
 719         ret = !ref;
 720
 721         while (ref) {
 722                 printf("%s %s\n",
 723                        sha1_to_hex(ref->old_sha1), ref->name);
 724                 ref = ref->next;
 725         }
 726
 727         return ret;
 728 }
 729
 730 struct ref *fetch_pack(struct fetch_pack_args *my_args,
 731                 const char *dest,
 732                 int nr_heads,
 733                 char **heads,
 734                 char **pack_lockfile)
 735 {
 736         int i, ret;
 737         int fd[2];
 738         struct child_process *conn;
 739         struct ref *ref;
 740         struct stat st;
 741
 742         fetch_pack_setup();
 743         memcpy(&args, my_args, sizeof(args));
 744         if (args.depth > 0) {
 745                 if (stat(git_path("shallow"), &st))
 746                         st.st_mtime = 0;
 747         }
 748
 749         conn = git_connect(fd, (char *)dest, uploadpack,
 750                           args.verbose ? CONNECT_VERBOSE : 0);
 751         if (heads && nr_heads)
 752                 nr_heads = remove_duplicates(nr_heads, heads);
 753         ref = do_fetch_pack(fd, nr_heads, heads, pack_lockfile);
 754         close(fd[0]);
 755         close(fd[1]);
 756         ret = finish_connect(conn);
 757
 758         if (!ret && nr_heads) {
 759                 /* If the heads to pull were given, we should have
 760                  * consumed all of them by matching the remote.
 761                  * Otherwise, 'git-fetch remote no-such-ref' would
 762                  * silently succeed without issuing an error.
 763                  */
 764                 for (i = 0; i < nr_heads; i++)
 765                         if (heads[i] && heads[i][0]) {
 766                                 error("no such remote ref %s", heads[i]);
 767                                 ret = 1;
 768                         }
 769         }
 770
 771         if (!ret && args.depth > 0) {
 772                 struct cache_time mtime;
 773                 char *shallow = git_path("shallow");
 774                 int fd;
 775
 776                 mtime.sec = st.st_mtime;
 777 #ifdef USE_NSEC
 778                 mtime.usec = st.st_mtim.usec;
 779 #endif
 780                 if (stat(shallow, &st)) {
 781                         if (mtime.sec)
 782                                 die("shallow file was removed during fetch");
 783                 } else if (st.st_mtime != mtime.sec
 784 #ifdef USE_NSEC
 785                                 || st.st_mtim.usec != mtime.usec
 786 #endif
 787                           )
 788                         die("shallow file was changed during fetch");
 789
 790                 fd = hold_lock_file_for_update(&lock, shallow, 1);
 791                 if (!write_shallow_commits(fd, 0)) {
 792                         unlink(shallow);
 793                         rollback_lock_file(&lock);
 794                 } else {
 795                         close(fd);
 796                         commit_lock_file(&lock);
 797                 }
 798         }
 799
 800         if (ret)
 801                 ref = NULL;
 802
 803         return ref;
 804 }