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