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